完成世界书、骰子、apiconfig页面处理

frontend/node_modules/uuid/README.md

@@ -0,0 +1,510 @@
+<!--
+  -- This file is auto-generated from README_js.md. Changes should be made there.
+  -->
+
+# uuid [![CI](https://github.com/uuidjs/uuid/workflows/CI/badge.svg)](https://github.com/uuidjs/uuid/actions?query=workflow%3ACI) [![Browser](https://github.com/uuidjs/uuid/workflows/Browser/badge.svg)](https://github.com/uuidjs/uuid/actions/workflows/browser.yml)
+
+For the creation of [RFC9562](https://www.rfc-editor.org/rfc/rfc9562.html) (formerly [RFC4122](https://www.rfc-editor.org/rfc/rfc4122.html)) UUIDs
+
+- **Complete** - Support for all RFC9562 UUID versions
+- **Cross-platform** - Support for...
+  - ESM & Common JS
+  - [Typescript](#support)
+  - [Chrome, Safari, Firefox, and Edge](#support)
+  - [NodeJS](#support)
+  - [React Native / Expo](#react-native--expo)
+- **Secure** - Uses modern `crypto` API for random values
+- **Compact** - Zero-dependency, [tree-shakable](https://developer.mozilla.org/en-US/docs/Glossary/Tree_shaking)
+- **CLI** - [`uuid` command line](#command-line) utility
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> `uuid@11` is now available:  See the [CHANGELOG](./CHANGELOG.md) for details. TL;DR:
+> * TypeScript support is now included  (remove `@types/uuid` from your dependencies)
+> * Subtle changes to how the `options` arg is interpreted for `v1()`, `v6()`, and `v7()`. [See details](#options-handling-for-timestamp-uuids)
+> * Binary UUIDs are now `Uint8Array`s.  (May impact callers of `parse()`, `stringify()`,  or that pass an `option#buf` argument to `v1()`-`v7()`.)
+
+## Quickstart
+
+**1. Install**
+
+```shell
+npm install uuid
+```
+
+**2. Create a UUID**
+
+ESM-syntax (must use named exports):
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
+```
+
+... CommonJS:
+
+```javascript
+const { v4: uuidv4 } = require('uuid');
+uuidv4(); // ⇨ '1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed'
+```
+
+For timestamp UUIDs, namespace UUIDs, and other options read on ...
+
+## API Summary
+
+|  |  |  |
+| --- | --- | --- |
+| [`uuid.NIL`](#uuidnil) | The nil UUID string (all zeros) | New in `uuid@8.3` |
+| [`uuid.MAX`](#uuidmax) | The max UUID string (all ones) | New in `uuid@9.1` |
+| [`uuid.parse()`](#uuidparsestr) | Convert UUID string to array of bytes | New in `uuid@8.3` |
+| [`uuid.stringify()`](#uuidstringifyarr-offset) | Convert array of bytes to UUID string | New in `uuid@8.3` |
+| [`uuid.v1()`](#uuidv1options-buffer-offset) | Create a version 1 (timestamp) UUID |  |
+| [`uuid.v1ToV6()`](#uuidv1tov6uuid) | Create a version 6 UUID from a version 1 UUID | New in `uuid@10` |
+| [`uuid.v3()`](#uuidv3name-namespace-buffer-offset) | Create a version 3 (namespace w/ MD5) UUID |  |
+| [`uuid.v4()`](#uuidv4options-buffer-offset) | Create a version 4 (random) UUID |  |
+| [`uuid.v5()`](#uuidv5name-namespace-buffer-offset) | Create a version 5 (namespace w/ SHA-1) UUID |  |
+| [`uuid.v6()`](#uuidv6options-buffer-offset) | Create a version 6 (timestamp, reordered) UUID | New in `uuid@10` |
+| [`uuid.v6ToV1()`](#uuidv6tov1uuid) | Create a version 1 UUID from a version 6 UUID | New in `uuid@10` |
+| [`uuid.v7()`](#uuidv7options-buffer-offset) | Create a version 7 (Unix Epoch time-based) UUID | New in `uuid@10` |
+| ~~[`uuid.v8()`](#uuidv8)~~ | "Intentionally left blank" |  |
+| [`uuid.validate()`](#uuidvalidatestr) | Test a string to see if it is a valid UUID | New in `uuid@8.3` |
+| [`uuid.version()`](#uuidversionstr) | Detect RFC version of a UUID | New in `uuid@8.3` |
+
+## API
+
+### uuid.NIL
+
+The nil UUID string (all zeros).
+
+Example:
+
+```javascript
+import { NIL as NIL_UUID } from 'uuid';
+
+NIL_UUID; // ⇨ '00000000-0000-0000-0000-000000000000'
+```
+
+### uuid.MAX
+
+The max UUID string (all ones).
+
+Example:
+
+```javascript
+import { MAX as MAX_UUID } from 'uuid';
+
+MAX_UUID; // ⇨ 'ffffffff-ffff-ffff-ffff-ffffffffffff'
+```
+
+### uuid.parse(str)
+
+Convert UUID string to array of bytes
+
+|           |                                          |
+| --------- | ---------------------------------------- |
+| `str`     | A valid UUID `String`                    |
+| _returns_ | `Uint8Array[16]`                         |
+| _throws_  | `TypeError` if `str` is not a valid UUID |
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> Ordering of values in the byte arrays used by `parse()` and `stringify()` follows the left &Rarr; right order of hex-pairs in UUID strings. As shown in the example below.
+
+Example:
+
+```javascript
+import { parse as uuidParse } from 'uuid';
+
+// Parse a UUID
+uuidParse('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨
+// Uint8Array(16) [
+//   110, 192, 189, 127,  17,
+//   192,  67, 218, 151,  94,
+//    42, 138, 217, 235, 174,
+//    11
+// ]
+```
+
+### uuid.stringify(arr[, offset])
+
+Convert array of bytes to UUID string
+
+|                |                                                                              |
+| -------------- | ---------------------------------------------------------------------------- |
+| `arr`          | `Array`-like collection of 16 values (starting from `offset`) between 0-255. |
+| [`offset` = 0] | `Number` Starting index in the Array                                         |
+| _returns_      | `String`                                                                     |
+| _throws_       | `TypeError` if a valid UUID string cannot be generated                       |
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> Ordering of values in the byte arrays used by `parse()` and `stringify()` follows the left &Rarr; right order of hex-pairs in UUID strings. As shown in the example below.
+
+Example:
+
+```javascript
+import { stringify as uuidStringify } from 'uuid';
+
+const uuidBytes = Uint8Array.of(
+  0x6e,
+  0xc0,
+  0xbd,
+  0x7f,
+  0x11,
+  0xc0,
+  0x43,
+  0xda,
+  0x97,
+  0x5e,
+  0x2a,
+  0x8a,
+  0xd9,
+  0xeb,
+  0xae,
+  0x0b
+);
+
+uuidStringify(uuidBytes); // ⇨ '6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'
+```
+
+### uuid.v1([options[, buffer[, offset]]])
+
+Create an RFC version 1 (timestamp) UUID
+
+|  |  |
+| --- | --- |
+| [`options`] | `Object` with one or more of the following properties: |
+| [`options.node = (random)` ] | RFC "node" field as an `Array[6]` of byte values (per 4.1.6) |
+| [`options.clockseq = (random)`] | RFC "clock sequence" as a `Number` between 0 - 0x3fff |
+| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) |
+| [`options.nsecs = 0`] | RFC "timestamp" field (`Number` of nanoseconds to add to `msecs`, should be 0-10,000) |
+| [`options.random = (random)`] | `Array` of 16 random bytes (0-255) used to generate other fields, above |
+| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
+| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+| _throws_ | `Error` if more than 10M UUIDs/sec are requested |
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> The default [node id](https://datatracker.ietf.org/doc/html/rfc9562#section-5.1) (the last 12 digits in the UUID) is generated once, randomly, on process startup, and then remains unchanged for the duration of the process.
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> `options.random` and `options.rng` are only meaningful on the very first call to `v1()`, where they may be passed to initialize the internal `node` and `clockseq` fields.
+
+Example:
+
+```javascript
+import { v1 as uuidv1 } from 'uuid';
+
+uuidv1(); // ⇨ '2c5ea4c0-4067-11e9-9bdd-2b0d7b3dcb6d'
+```
+
+Example using `options`:
+
+```javascript
+import { v1 as uuidv1 } from 'uuid';
+
+const options = {
+  node: Uint8Array.of(0x01, 0x23, 0x45, 0x67, 0x89, 0xab),
+  clockseq: 0x1234,
+  msecs: new Date('2011-11-01').getTime(),
+  nsecs: 5678,
+};
+uuidv1(options); // ⇨ '710b962e-041c-11e1-9234-0123456789ab'
+```
+
+### uuid.v1ToV6(uuid)
+
+Convert a UUID from version 1 to version 6
+
+```javascript
+import { v1ToV6 } from 'uuid';
+
+v1ToV6('92f62d9e-22c4-11ef-97e9-325096b39f47'); // ⇨ '1ef22c49-2f62-6d9e-97e9-325096b39f47'
+```
+
+### uuid.v3(name, namespace[, buffer[, offset]])
+
+Create an RFC version 3 (namespace w/ MD5) UUID
+
+API is identical to `v5()`, but uses "v3" instead.
+
+<!-- prettier-ignore -->
+> [!IMPORTANT]
+> Per the RFC, "_If backward compatibility is not an issue, SHA-1 [Version 5] is preferred_."
+
+### uuid.v4([options[, buffer[, offset]]])
+
+Create an RFC version 4 (random) UUID
+
+|  |  |
+| --- | --- |
+| [`options`] | `Object` with one or more of the following properties: |
+| [`options.random`] | `Array` of 16 random bytes (0-255) |
+| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
+| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+
+Example:
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+
+uuidv4(); // ⇨ '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'
+```
+
+Example using predefined `random` values:
+
+```javascript
+import { v4 as uuidv4 } from 'uuid';
+
+const v4options = {
+  random: Uint8Array.of(
+    0x10,
+    0x91,
+    0x56,
+    0xbe,
+    0xc4,
+    0xfb,
+    0xc1,
+    0xea,
+    0x71,
+    0xb4,
+    0xef,
+    0xe1,
+    0x67,
+    0x1c,
+    0x58,
+    0x36
+  ),
+};
+uuidv4(v4options); // ⇨ '109156be-c4fb-41ea-b1b4-efe1671c5836'
+```
+
+### uuid.v5(name, namespace[, buffer[, offset]])
+
+Create an RFC version 5 (namespace w/ SHA-1) UUID
+
+|  |  |
+| --- | --- |
+| `name` | `String \| Array` |
+| `namespace` | `String \| Array[16]` Namespace UUID |
+| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> The RFC `DNS` and `URL` namespaces are available as `v5.DNS` and `v5.URL`.
+
+Example with custom namespace:
+
+```javascript
+import { v5 as uuidv5 } from 'uuid';
+
+// Define a custom namespace.  Readers, create your own using something like
+// https://www.uuidgenerator.net/
+const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
+
+uuidv5('Hello, World!', MY_NAMESPACE); // ⇨ '630eb68f-e0fa-5ecc-887a-7c7a62614681'
+```
+
+Example with RFC `URL` namespace:
+
+```javascript
+import { v5 as uuidv5 } from 'uuid';
+
+uuidv5('https://www.w3.org/', uuidv5.URL); // ⇨ 'c106a26a-21bb-5538-8bf2-57095d1976c1'
+```
+
+### uuid.v6([options[, buffer[, offset]]])
+
+Create an RFC version 6 (timestamp, reordered) UUID
+
+This method takes the same arguments as uuid.v1().
+
+```javascript
+import { v6 as uuidv6 } from 'uuid';
+
+uuidv6(); // ⇨ '1e940672-c5ea-64c0-9b5d-ab8dfbbd4bed'
+```
+
+Example using `options`:
+
+```javascript
+import { v6 as uuidv6 } from 'uuid';
+
+const options = {
+  node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
+  clockseq: 0x1234,
+  msecs: new Date('2011-11-01').getTime(),
+  nsecs: 5678,
+};
+uuidv6(options); // ⇨ '1e1041c7-10b9-662e-9234-0123456789ab'
+```
+
+### uuid.v6ToV1(uuid)
+
+Convert a UUID from version 6 to version 1
+
+```javascript
+import { v6ToV1 } from 'uuid';
+
+v6ToV1('1ef22c49-2f62-6d9e-97e9-325096b39f47'); // ⇨ '92f62d9e-22c4-11ef-97e9-325096b39f47'
+```
+
+### uuid.v7([options[, buffer[, offset]]])
+
+Create an RFC version 7 (random) UUID
+
+|  |  |
+| --- | --- |
+| [`options`] | `Object` with one or more of the following properties: |
+| [`options.msecs = (current time)`] | RFC "timestamp" field (`Number` of milliseconds, unix epoch) |
+| [`options.random = (random)`] | `Array` of 16 random bytes (0-255) used to generate other fields, above |
+| [`options.rng`] | Alternative to `options.random`, a `Function` that returns an `Array` of 16 random bytes (0-255) |
+| [`options.seq = (random)`] | 32-bit sequence `Number` between 0 - 0xffffffff. This may be provided to help ensure uniqueness for UUIDs generated within the same millisecond time interval. Default = random value. |
+| [`buffer`] | `Uint8Array` or `Uint8Array` subtype (e.g. Node.js `Buffer`). If provided, binary UUID is written into the array, starting at `offset` |
+| [`offset` = 0] | `Number` Index to start writing UUID bytes in `buffer` |
+| _returns_ | UUID `String` if no `buffer` is specified, otherwise returns `buffer` |
+
+Example:
+
+```javascript
+import { v7 as uuidv7 } from 'uuid';
+
+uuidv7(); // ⇨ '01695553-c90c-705a-b56d-778dfbbd4bed'
+```
+
+### ~~uuid.v8()~~
+
+**_"Intentionally left blank"_**
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> Version 8 (experimental) UUIDs are "[for experimental or vendor-specific use cases](https://www.rfc-editor.org/rfc/rfc9562.html#name-uuid-version-8)".  The RFC does not define a creation algorithm for them, which is why this package does not offer a `v8()` method.  The `validate()` and `version()` methods do work with such UUIDs, however.
+
+### uuid.validate(str)
+
+Test a string to see if it is a valid UUID
+
+|           |                                                     |
+| --------- | --------------------------------------------------- |
+| `str`     | `String` to validate                                |
+| _returns_ | `true` if string is a valid UUID, `false` otherwise |
+
+Example:
+
+```javascript
+import { validate as uuidValidate } from 'uuid';
+
+uuidValidate('not a UUID'); // ⇨ false
+uuidValidate('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ true
+```
+
+Using `validate` and `version` together it is possible to do per-version validation, e.g. validate for only v4 UUIds.
+
+```javascript
+import { version as uuidVersion } from 'uuid';
+import { validate as uuidValidate } from 'uuid';
+
+function uuidValidateV4(uuid) {
+  return uuidValidate(uuid) && uuidVersion(uuid) === 4;
+}
+
+const v1Uuid = 'd9428888-122b-11e1-b85c-61cd3cbb3210';
+const v4Uuid = '109156be-c4fb-41ea-b1b4-efe1671c5836';
+
+uuidValidateV4(v4Uuid); // ⇨ true
+uuidValidateV4(v1Uuid); // ⇨ false
+```
+
+### uuid.version(str)
+
+Detect RFC version of a UUID
+
+|           |                                          |
+| --------- | ---------------------------------------- |
+| `str`     | A valid UUID `String`                    |
+| _returns_ | `Number` The RFC version of the UUID     |
+| _throws_  | `TypeError` if `str` is not a valid UUID |
+
+Example:
+
+```javascript
+import { version as uuidVersion } from 'uuid';
+
+uuidVersion('45637ec4-c85f-11ea-87d0-0242ac130003'); // ⇨ 1
+uuidVersion('6ec0bd7f-11c0-43da-975e-2a8ad9ebae0b'); // ⇨ 4
+```
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> This method returns `0` for the `NIL` UUID, and `15` for the `MAX` UUID.
+
+## Command Line
+
+UUIDs can be generated from the command line using `uuid`.
+
+```shell
+$ npx uuid
+ddeb27fb-d9a0-4624-be4d-4615062daed4
+```
+
+The default is to generate version 4 UUIDS, however the other versions are supported. Type `uuid --help` for details:
+
+```shell
+$ npx uuid --help
+
+Usage:
+  uuid
+  uuid v1
+  uuid v3 <name> <namespace uuid>
+  uuid v4
+  uuid v5 <name> <namespace uuid>
+  uuid v7
+  uuid --help
+
+Note: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs
+defined by RFC9562
+```
+
+## `options` Handling for Timestamp UUIDs
+
+Prior to `uuid@11`, it was possible for `options` state to interfere with the internal state used to ensure uniqueness of timestamp-based UUIDs (the `v1()`, `v6()`, and `v7()` methods). Starting with `uuid@11`, this issue has been addressed by using the presence of the `options` argument as a flag to select between two possible behaviors:
+
+- Without `options`: Internal state is utilized to improve UUID uniqueness.
+- With `options`: Internal state is **NOT** used and, instead, appropriate defaults are applied as needed.
+
+## Support
+
+**Browsers**: `uuid` [builds are tested](/uuidjs/uuid/blob/main/wdio.conf.js) against the latest version of desktop Chrome, Safari, Firefox, and Edge. Mobile versions of these same browsers are expected to work but aren't currently tested.
+
+**Node**: `uuid` [builds are tested](https://github.com/uuidjs/uuid/blob/main/.github/workflows/ci.yml#L26-L27) against node ([LTS releases](https://github.com/nodejs/Release)), plus one prior. E.g. `node@18` is in maintainence mode, and `node@22` is the current LTS release. So `uuid` supports `node@16`-`node@22`.
+
+**Typescript**: TS versions released within the past two years are supported. [source](https://github.com/microsoft/TypeScript/issues/49088#issuecomment-2468723715)
+
+## Known issues
+
+<!-- This header is referenced as an anchor in src/rng-browser.ts -->
+
+### "getRandomValues() not supported"
+
+This error occurs in environments where the standard [`crypto.getRandomValues()`](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) API is not supported. This issue can be resolved by adding an appropriate polyfill:
+
+#### React Native / Expo
+
+1. Install [`react-native-get-random-values`](https://github.com/LinusU/react-native-get-random-values#readme)
+1. Import it _before_ `uuid`. Since `uuid` might also appear as a transitive dependency of some other imports it's safest to just import `react-native-get-random-values` as the very first thing in your entry point:
+
+```javascript
+import 'react-native-get-random-values';
+import { v4 as uuidv4 } from 'uuid';
+```
+
+---
+
+Markdown generated from [README_js.md](README_js.md) by <a href="https://github.com/broofa/runmd"><image height="13" src="https://camo.githubusercontent.com/5c7c603cd1e6a43370b0a5063d457e0dabb74cf317adc7baba183acb686ee8d0/687474703a2f2f692e696d6775722e636f6d2f634a4b6f3662552e706e67" /></a>

frontend/node_modules/uuid/dist/cjs-browser/max.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "ffffffff-ffff-ffff-ffff-ffffffffffff";
+export default _default;

frontend/node_modules/uuid/dist/cjs-browser/native.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+exports.default = { randomUUID };

frontend/node_modules/uuid/dist/cjs-browser/nil.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = '00000000-0000-0000-0000-000000000000';

frontend/node_modules/uuid/dist/cjs-browser/parse.d.ts

@@ -0,0 +1,2 @@
+declare function parse(uuid: string): Uint8Array;
+export default parse;

frontend/node_modules/uuid/dist/cjs-browser/types.d.ts

@@ -0,0 +1,21 @@
+export type UUIDTypes<TBuf extends Uint8Array = Uint8Array> = string | TBuf;
+export type Version1Options = {
+    node?: Uint8Array;
+    clockseq?: number;
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+    msecs?: number;
+    nsecs?: number;
+    _v6?: boolean;
+};
+export type Version4Options = {
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+};
+export type Version6Options = Version1Options;
+export type Version7Options = {
+    random?: Uint8Array;
+    msecs?: number;
+    seq?: number;
+    rng?: () => Uint8Array;
+};

frontend/node_modules/uuid/dist/cjs-browser/v35.d.ts

@@ -0,0 +1,7 @@
+import { UUIDTypes } from './types.js';
+export declare function stringToBytes(str: string): Uint8Array;
+export declare const DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+export declare const URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+type HashFunction = (bytes: Uint8Array) => Uint8Array;
+export default function v35<TBuf extends Uint8Array = Uint8Array>(version: 0x30 | 0x50, hash: HashFunction, value: string | Uint8Array, namespace: UUIDTypes, buf?: TBuf, offset?: number): UUIDTypes<TBuf>;
+export {};

frontend/node_modules/uuid/dist/cjs-browser/v5.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URL = exports.DNS = void 0;
+const sha1_js_1 = require("./sha1.js");
+const v35_js_1 = require("./v35.js");
+var v35_js_2 = require("./v35.js");
+Object.defineProperty(exports, "DNS", { enumerable: true, get: function () { return v35_js_2.DNS; } });
+Object.defineProperty(exports, "URL", { enumerable: true, get: function () { return v35_js_2.URL; } });
+function v5(value, namespace, buf, offset) {
+    return (0, v35_js_1.default)(0x50, sha1_js_1.default, value, namespace, buf, offset);
+}
+v5.DNS = v35_js_1.DNS;
+v5.URL = v35_js_1.URL;
+exports.default = v5;

frontend/node_modules/uuid/dist/cjs-browser/v6.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stringify_js_1 = require("./stringify.js");
+const v1_js_1 = require("./v1.js");
+const v1ToV6_js_1 = require("./v1ToV6.js");
+function v6(options, buf, offset) {
+    options ??= {};
+    offset ??= 0;
+    let bytes = (0, v1_js_1.default)({ ...options, _v6: true }, new Uint8Array(16));
+    bytes = (0, v1ToV6_js_1.default)(bytes);
+    if (buf) {
+        for (let i = 0; i < 16; i++) {
+            buf[offset + i] = bytes[i];
+        }
+        return buf;
+    }
+    return (0, stringify_js_1.unsafeStringify)(bytes);
+}
+exports.default = v6;

frontend/node_modules/uuid/dist/cjs-browser/v6ToV1.d.ts

@@ -0,0 +1,2 @@
+export default function v6ToV1(uuid: string): string;
+export default function v6ToV1(uuid: Uint8Array): Uint8Array;

frontend/node_modules/uuid/dist/cjs-browser/version.d.ts

@@ -0,0 +1,2 @@
+declare function version(uuid: string): number;
+export default version;

frontend/node_modules/uuid/dist/cjs/index.d.ts

@@ -0,0 +1,15 @@
+export type * from './types.js';
+export { default as MAX } from './max.js';
+export { default as NIL } from './nil.js';
+export { default as parse } from './parse.js';
+export { default as stringify } from './stringify.js';
+export { default as v1 } from './v1.js';
+export { default as v1ToV6 } from './v1ToV6.js';
+export { default as v3 } from './v3.js';
+export { default as v4 } from './v4.js';
+export { default as v5 } from './v5.js';
+export { default as v6 } from './v6.js';
+export { default as v6ToV1 } from './v6ToV1.js';
+export { default as v7 } from './v7.js';
+export { default as validate } from './validate.js';
+export { default as version } from './version.js';

frontend/node_modules/uuid/dist/cjs/max.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = 'ffffffff-ffff-ffff-ffff-ffffffffffff';

frontend/node_modules/uuid/dist/cjs/md5.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+declare function md5(bytes: Uint8Array): Buffer;
+export default md5;

frontend/node_modules/uuid/dist/cjs/native.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { randomUUID } from 'crypto';
+declare const _default: {
+    randomUUID: typeof randomUUID;
+};
+export default _default;

frontend/node_modules/uuid/dist/cjs/native.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+exports.default = { randomUUID: crypto_1.randomUUID };

frontend/node_modules/uuid/dist/cjs/nil.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "00000000-0000-0000-0000-000000000000";
+export default _default;

frontend/node_modules/uuid/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

frontend/node_modules/uuid/dist/cjs/rng.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const rnds8Pool = new Uint8Array(256);
+let poolPtr = rnds8Pool.length;
+function rng() {
+    if (poolPtr > rnds8Pool.length - 16) {
+        (0, crypto_1.randomFillSync)(rnds8Pool);
+        poolPtr = 0;
+    }
+    return rnds8Pool.slice(poolPtr, (poolPtr += 16));
+}
+exports.default = rng;

frontend/node_modules/uuid/dist/cjs/sha1.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+declare function sha1(bytes: Uint8Array): Buffer;
+export default sha1;

frontend/node_modules/uuid/dist/cjs/sha1.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+function sha1(bytes) {
+    if (Array.isArray(bytes)) {
+        bytes = Buffer.from(bytes);
+    }
+    else if (typeof bytes === 'string') {
+        bytes = Buffer.from(bytes, 'utf8');
+    }
+    return (0, crypto_1.createHash)('sha1').update(bytes).digest();
+}
+exports.default = sha1;

frontend/node_modules/uuid/dist/cjs/stringify.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsafeStringify = void 0;
+const validate_js_1 = require("./validate.js");
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+exports.unsafeStringify = unsafeStringify;
+function stringify(arr, offset = 0) {
+    const uuid = unsafeStringify(arr, offset);
+    if (!(0, validate_js_1.default)(uuid)) {
+        throw TypeError('Stringified UUID is invalid');
+    }
+    return uuid;
+}
+exports.default = stringify;

frontend/node_modules/uuid/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

frontend/node_modules/uuid/dist/cjs/uuid-bin.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const v1_js_1 = require("./v1.js");
+const v3_js_1 = require("./v3.js");
+const v4_js_1 = require("./v4.js");
+const v5_js_1 = require("./v5.js");
+const v6_js_1 = require("./v6.js");
+const v7_js_1 = require("./v7.js");
+function usage() {
+    console.log('Usage:');
+    console.log('  uuid');
+    console.log('  uuid v1');
+    console.log('  uuid v3 <name> <namespace uuid>');
+    console.log('  uuid v4');
+    console.log('  uuid v5 <name> <namespace uuid>');
+    console.log('  uuid v6');
+    console.log('  uuid v7');
+    console.log('  uuid --help');
+    console.log('\nNote: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC9562');
+}
+const args = process.argv.slice(2);
+if (args.indexOf('--help') >= 0) {
+    usage();
+    process.exit(0);
+}
+const version = args.shift() || 'v4';
+switch (version) {
+    case 'v1':
+        console.log((0, v1_js_1.default)());
+        break;
+    case 'v3': {
+        const name = args.shift();
+        let namespace = args.shift();
+        assert.ok(name != null, 'v3 name not specified');
+        assert.ok(namespace != null, 'v3 namespace not specified');
+        if (namespace === 'URL') {
+            namespace = v3_js_1.default.URL;
+        }
+        if (namespace === 'DNS') {
+            namespace = v3_js_1.default.DNS;
+        }
+        console.log((0, v3_js_1.default)(name, namespace));
+        break;
+    }
+    case 'v4':
+        console.log((0, v4_js_1.default)());
+        break;
+    case 'v5': {
+        const name = args.shift();
+        let namespace = args.shift();
+        assert.ok(name != null, 'v5 name not specified');
+        assert.ok(namespace != null, 'v5 namespace not specified');
+        if (namespace === 'URL') {
+            namespace = v5_js_1.default.URL;
+        }
+        if (namespace === 'DNS') {
+            namespace = v5_js_1.default.DNS;
+        }
+        console.log((0, v5_js_1.default)(name, namespace));
+        break;
+    }
+    case 'v6':
+        console.log((0, v6_js_1.default)());
+        break;
+    case 'v7':
+        console.log((0, v7_js_1.default)());
+        break;
+    default:
+        usage();
+        process.exit(1);
+}

frontend/node_modules/uuid/dist/cjs/v3.d.ts

@@ -0,0 +1,9 @@
+import { UUIDTypes } from './types.js';
+export { DNS, URL } from './v35.js';
+declare function v3(value: string | Uint8Array, namespace: UUIDTypes, buf?: undefined, offset?: number): string;
+declare function v3<TBuf extends Uint8Array = Uint8Array>(value: string | Uint8Array, namespace: UUIDTypes, buf: TBuf, offset?: number): TBuf;
+declare namespace v3 {
+    var DNS: string;
+    var URL: string;
+}
+export default v3;

frontend/node_modules/uuid/dist/cjs/v35.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URL = exports.DNS = exports.stringToBytes = void 0;
+const parse_js_1 = require("./parse.js");
+const stringify_js_1 = require("./stringify.js");
+function stringToBytes(str) {
+    str = unescape(encodeURIComponent(str));
+    const bytes = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; ++i) {
+        bytes[i] = str.charCodeAt(i);
+    }
+    return bytes;
+}
+exports.stringToBytes = stringToBytes;
+exports.DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+exports.URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+function v35(version, hash, value, namespace, buf, offset) {
+    const valueBytes = typeof value === 'string' ? stringToBytes(value) : value;
+    const namespaceBytes = typeof namespace === 'string' ? (0, parse_js_1.default)(namespace) : namespace;
+    if (typeof namespace === 'string') {
+        namespace = (0, parse_js_1.default)(namespace);
+    }
+    if (namespace?.length !== 16) {
+        throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    }
+    let bytes = new Uint8Array(16 + valueBytes.length);
+    bytes.set(namespaceBytes);
+    bytes.set(valueBytes, namespaceBytes.length);
+    bytes = hash(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | version;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    if (buf) {
+        offset = offset || 0;
+        for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = bytes[i];
+        }
+        return buf;
+    }
+    return (0, stringify_js_1.unsafeStringify)(bytes);
+}
+exports.default = v35;

frontend/node_modules/uuid/dist/cjs/v4.d.ts

@@ -0,0 +1,4 @@
+import { Version4Options } from './types.js';
+declare function v4(options?: Version4Options, buf?: undefined, offset?: number): string;
+declare function v4<TBuf extends Uint8Array = Uint8Array>(options: Version4Options | undefined, buf: TBuf, offset?: number): TBuf;
+export default v4;

frontend/node_modules/uuid/dist/cjs/v4.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const native_js_1 = require("./native.js");
+const rng_js_1 = require("./rng.js");
+const stringify_js_1 = require("./stringify.js");
+function v4(options, buf, offset) {
+    if (native_js_1.default.randomUUID && !buf && !options) {
+        return native_js_1.default.randomUUID();
+    }
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? (0, rng_js_1.default)();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    if (buf) {
+        offset = offset || 0;
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
+        for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = rnds[i];
+        }
+        return buf;
+    }
+    return (0, stringify_js_1.unsafeStringify)(rnds);
+}
+exports.default = v4;

frontend/node_modules/uuid/dist/cjs/v5.d.ts

@@ -0,0 +1,9 @@
+import { UUIDTypes } from './types.js';
+export { DNS, URL } from './v35.js';
+declare function v5(value: string | Uint8Array, namespace: UUIDTypes, buf?: undefined, offset?: number): string;
+declare function v5<TBuf extends Uint8Array = Uint8Array>(value: string | Uint8Array, namespace: UUIDTypes, buf: TBuf, offset?: number): TBuf;
+declare namespace v5 {
+    var DNS: string;
+    var URL: string;
+}
+export default v5;

frontend/node_modules/uuid/dist/esm-browser/nil.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "00000000-0000-0000-0000-000000000000";
+export default _default;

frontend/node_modules/uuid/dist/esm-browser/parse.d.ts

@@ -0,0 +1,2 @@
+declare function parse(uuid: string): Uint8Array;
+export default parse;

frontend/node_modules/uuid/dist/esm-browser/parse.js

@@ -0,0 +1,9 @@
+import validate from './validate.js';
+function parse(uuid) {
+    if (!validate(uuid)) {
+        throw TypeError('Invalid UUID');
+    }
+    let v;
+    return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff, (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 0xff, (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 0xff, (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 0xff, ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff, (v / 0x100000000) & 0xff, (v >>> 24) & 0xff, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff);
+}
+export default parse;

frontend/node_modules/uuid/dist/esm-browser/rng.d.ts

@@ -0,0 +1 @@
+export default function rng(): Uint8Array;

frontend/node_modules/uuid/dist/esm-browser/sha1.d.ts

@@ -0,0 +1,2 @@
+declare function sha1(bytes: Uint8Array): Uint8Array;
+export default sha1;

frontend/node_modules/uuid/dist/esm-browser/stringify.d.ts

@@ -0,0 +1,3 @@
+export declare function unsafeStringify(arr: Uint8Array, offset?: number): string;
+declare function stringify(arr: Uint8Array, offset?: number): string;
+export default stringify;

frontend/node_modules/uuid/dist/esm-browser/types.d.ts

@@ -0,0 +1,21 @@
+export type UUIDTypes<TBuf extends Uint8Array = Uint8Array> = string | TBuf;
+export type Version1Options = {
+    node?: Uint8Array;
+    clockseq?: number;
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+    msecs?: number;
+    nsecs?: number;
+    _v6?: boolean;
+};
+export type Version4Options = {
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+};
+export type Version6Options = Version1Options;
+export type Version7Options = {
+    random?: Uint8Array;
+    msecs?: number;
+    seq?: number;
+    rng?: () => Uint8Array;
+};

frontend/node_modules/uuid/dist/esm-browser/uuid-bin.d.ts

@@ -0,0 +1 @@
+export {};

frontend/node_modules/uuid/dist/esm-browser/uuid-bin.js

@@ -0,0 +1,70 @@
+import * as assert from 'assert';
+import v1 from './v1.js';
+import v3 from './v3.js';
+import v4 from './v4.js';
+import v5 from './v5.js';
+import v6 from './v6.js';
+import v7 from './v7.js';
+function usage() {
+    console.log('Usage:');
+    console.log('  uuid');
+    console.log('  uuid v1');
+    console.log('  uuid v3 <name> <namespace uuid>');
+    console.log('  uuid v4');
+    console.log('  uuid v5 <name> <namespace uuid>');
+    console.log('  uuid v6');
+    console.log('  uuid v7');
+    console.log('  uuid --help');
+    console.log('\nNote: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC9562');
+}
+const args = process.argv.slice(2);
+if (args.indexOf('--help') >= 0) {
+    usage();
+    process.exit(0);
+}
+const version = args.shift() || 'v4';
+switch (version) {
+    case 'v1':
+        console.log(v1());
+        break;
+    case 'v3': {
+        const name = args.shift();
+        let namespace = args.shift();
+        assert.ok(name != null, 'v3 name not specified');
+        assert.ok(namespace != null, 'v3 namespace not specified');
+        if (namespace === 'URL') {
+            namespace = v3.URL;
+        }
+        if (namespace === 'DNS') {
+            namespace = v3.DNS;
+        }
+        console.log(v3(name, namespace));
+        break;
+    }
+    case 'v4':
+        console.log(v4());
+        break;
+    case 'v5': {
+        const name = args.shift();
+        let namespace = args.shift();
+        assert.ok(name != null, 'v5 name not specified');
+        assert.ok(namespace != null, 'v5 namespace not specified');
+        if (namespace === 'URL') {
+            namespace = v5.URL;
+        }
+        if (namespace === 'DNS') {
+            namespace = v5.DNS;
+        }
+        console.log(v5(name, namespace));
+        break;
+    }
+    case 'v6':
+        console.log(v6());
+        break;
+    case 'v7':
+        console.log(v7());
+        break;
+    default:
+        usage();
+        process.exit(1);
+}

frontend/node_modules/uuid/dist/esm-browser/v3.js

@@ -0,0 +1,9 @@
+import md5 from './md5.js';
+import v35, { DNS, URL } from './v35.js';
+export { DNS, URL } from './v35.js';
+function v3(value, namespace, buf, offset) {
+    return v35(0x30, md5, value, namespace, buf, offset);
+}
+v3.DNS = DNS;
+v3.URL = URL;
+export default v3;

frontend/node_modules/uuid/dist/esm/max.js

@@ -0,0 +1 @@
+export default 'ffffffff-ffff-ffff-ffff-ffffffffffff';

frontend/node_modules/uuid/dist/esm/md5.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+declare function md5(bytes: Uint8Array): Buffer;
+export default md5;

frontend/node_modules/uuid/dist/esm/native.js

@@ -0,0 +1,2 @@
+import { randomUUID } from 'crypto';
+export default { randomUUID };

frontend/node_modules/uuid/dist/esm/nil.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "00000000-0000-0000-0000-000000000000";
+export default _default;

frontend/node_modules/uuid/dist/esm/regex.d.ts

@@ -0,0 +1,2 @@
+declare const _default: RegExp;
+export default _default;

frontend/node_modules/uuid/dist/esm/rng.js

@@ -0,0 +1,10 @@
+import { randomFillSync } from 'crypto';
+const rnds8Pool = new Uint8Array(256);
+let poolPtr = rnds8Pool.length;
+export default function rng() {
+    if (poolPtr > rnds8Pool.length - 16) {
+        randomFillSync(rnds8Pool);
+        poolPtr = 0;
+    }
+    return rnds8Pool.slice(poolPtr, (poolPtr += 16));
+}

frontend/node_modules/uuid/dist/esm/sha1.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+declare function sha1(bytes: Uint8Array): Buffer;
+export default sha1;

frontend/node_modules/uuid/dist/esm/stringify.d.ts

@@ -0,0 +1,3 @@
+export declare function unsafeStringify(arr: Uint8Array, offset?: number): string;
+declare function stringify(arr: Uint8Array, offset?: number): string;
+export default stringify;

frontend/node_modules/uuid/dist/esm/stringify.js

@@ -0,0 +1,35 @@
+import validate from './validate.js';
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+export function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+function stringify(arr, offset = 0) {
+    const uuid = unsafeStringify(arr, offset);
+    if (!validate(uuid)) {
+        throw TypeError('Stringified UUID is invalid');
+    }
+    return uuid;
+}
+export default stringify;

frontend/node_modules/uuid/dist/esm/types.d.ts

@@ -0,0 +1,21 @@
+export type UUIDTypes<TBuf extends Uint8Array = Uint8Array> = string | TBuf;
+export type Version1Options = {
+    node?: Uint8Array;
+    clockseq?: number;
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+    msecs?: number;
+    nsecs?: number;
+    _v6?: boolean;
+};
+export type Version4Options = {
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+};
+export type Version6Options = Version1Options;
+export type Version7Options = {
+    random?: Uint8Array;
+    msecs?: number;
+    seq?: number;
+    rng?: () => Uint8Array;
+};

frontend/node_modules/uuid/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

frontend/node_modules/uuid/dist/esm/v1ToV6.d.ts

@@ -0,0 +1,2 @@
+export default function v1ToV6(uuid: string): string;
+export default function v1ToV6(uuid: Uint8Array): Uint8Array;

frontend/node_modules/uuid/dist/esm/v3.js

@@ -0,0 +1,9 @@
+import md5 from './md5.js';
+import v35, { DNS, URL } from './v35.js';
+export { DNS, URL } from './v35.js';
+function v3(value, namespace, buf, offset) {
+    return v35(0x30, md5, value, namespace, buf, offset);
+}
+v3.DNS = DNS;
+v3.URL = URL;
+export default v3;

frontend/node_modules/uuid/dist/esm/v35.d.ts

@@ -0,0 +1,7 @@
+import { UUIDTypes } from './types.js';
+export declare function stringToBytes(str: string): Uint8Array;
+export declare const DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+export declare const URL = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+type HashFunction = (bytes: Uint8Array) => Uint8Array;
+export default function v35<TBuf extends Uint8Array = Uint8Array>(version: 0x30 | 0x50, hash: HashFunction, value: string | Uint8Array, namespace: UUIDTypes, buf?: TBuf, offset?: number): UUIDTypes<TBuf>;
+export {};

frontend/node_modules/uuid/dist/esm/v35.js

@@ -0,0 +1,36 @@
+import parse from './parse.js';
+import { unsafeStringify } from './stringify.js';
+export function stringToBytes(str) {
+    str = unescape(encodeURIComponent(str));
+    const bytes = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; ++i) {
+        bytes[i] = str.charCodeAt(i);
+    }
+    return bytes;
+}
+export const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+export const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+export default function v35(version, hash, value, namespace, buf, offset) {
+    const valueBytes = typeof value === 'string' ? stringToBytes(value) : value;
+    const namespaceBytes = typeof namespace === 'string' ? parse(namespace) : namespace;
+    if (typeof namespace === 'string') {
+        namespace = parse(namespace);
+    }
+    if (namespace?.length !== 16) {
+        throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    }
+    let bytes = new Uint8Array(16 + valueBytes.length);
+    bytes.set(namespaceBytes);
+    bytes.set(valueBytes, namespaceBytes.length);
+    bytes = hash(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | version;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    if (buf) {
+        offset = offset || 0;
+        for (let i = 0; i < 16; ++i) {
+            buf[offset + i] = bytes[i];
+        }
+        return buf;
+    }
+    return unsafeStringify(bytes);
+}

frontend/node_modules/uuid/dist/esm/v6ToV1.js

@@ -0,0 +1,10 @@
+import parse from './parse.js';
+import { unsafeStringify } from './stringify.js';
+export default function v6ToV1(uuid) {
+    const v6Bytes = typeof uuid === 'string' ? parse(uuid) : uuid;
+    const v1Bytes = _v6ToV1(v6Bytes);
+    return typeof uuid === 'string' ? unsafeStringify(v1Bytes) : v1Bytes;
+}
+function _v6ToV1(v6Bytes) {
+    return Uint8Array.of(((v6Bytes[3] & 0x0f) << 4) | ((v6Bytes[4] >> 4) & 0x0f), ((v6Bytes[4] & 0x0f) << 4) | ((v6Bytes[5] & 0xf0) >> 4), ((v6Bytes[5] & 0x0f) << 4) | (v6Bytes[6] & 0x0f), v6Bytes[7], ((v6Bytes[1] & 0x0f) << 4) | ((v6Bytes[2] & 0xf0) >> 4), ((v6Bytes[2] & 0x0f) << 4) | ((v6Bytes[3] & 0xf0) >> 4), 0x10 | ((v6Bytes[0] & 0xf0) >> 4), ((v6Bytes[0] & 0x0f) << 4) | ((v6Bytes[1] & 0xf0) >> 4), v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]);
+}

frontend/node_modules/uuid/dist/esm/validate.d.ts

@@ -0,0 +1,2 @@
+declare function validate(uuid: unknown): boolean;
+export default validate;