@roster-lock/match-agent 0.1.0 → 0.2.0

package/client/node_modules/.vite/deps/chunk-IIDO6PKU.js

@@ -0,0 +1,2337 @@
+import {
+  __commonJS,
+  __privateAdd,
+  __privateMethod,
+  __publicField
+} from "./chunk-WMTNK64S.js";
+
+// ../utils/dist/array/LinkedList.js
+var require_LinkedList = __commonJS({
+  "../utils/dist/array/LinkedList.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LinkedList = void 0;
+    var ListNode = class {
+      constructor(value, next = null, prev = null) {
+        __publicField(this, "value");
+        __publicField(this, "next");
+        __publicField(this, "prev");
+        this.value = value;
+        this.next = next;
+        this.prev = prev;
+      }
+    };
+    var LinkedList = class {
+      constructor() {
+        __publicField(this, "head", null);
+        __publicField(this, "tail", null);
+        __publicField(this, "_length", 0);
+      }
+      push(value) {
+        const node = new ListNode(value);
+        if (!this.tail) {
+          this.head = this.tail = node;
+        } else {
+          this.tail.next = node;
+          node.prev = this.tail;
+          this.tail = node;
+        }
+        this._length++;
+      }
+      pop() {
+        if (!this.tail)
+          return void 0;
+        const value = this.tail.value;
+        this._length--;
+        if (!this.tail.prev) {
+          this.head = null;
+          this.tail = null;
+        } else {
+          this.tail = this.tail.prev;
+          this.tail.next = null;
+        }
+        return value;
+      }
+      shift() {
+        if (!this.head)
+          return void 0;
+        const value = this.head.value;
+        this._length--;
+        if (!this.head.next) {
+          this.head = null;
+          this.tail = null;
+        } else {
+          this.head = this.head.next;
+          this.head.prev = null;
+        }
+        return value;
+      }
+      unshift(value) {
+        const node = new ListNode(value);
+        if (!this.head) {
+          this.head = this.tail = node;
+        } else {
+          this.head.prev = node;
+          node.next = this.head;
+          this.head = node;
+        }
+        this._length++;
+      }
+      peekStart() {
+        var _a;
+        return (_a = this.head) == null ? void 0 : _a.value;
+      }
+      peekEnd() {
+        var _a;
+        return (_a = this.tail) == null ? void 0 : _a.value;
+      }
+      isEmpty() {
+        return this._length === 0;
+      }
+      get length() {
+        return this._length;
+      }
+      [Symbol.iterator]() {
+        let current = this.head;
+        return {
+          next: () => {
+            if (!current)
+              return { done: true, value: void 0 };
+            const value = current.value;
+            current = current.next;
+            return { done: false, value };
+          }
+        };
+      }
+      clear() {
+        this.head = this.tail = null;
+        this._length = 0;
+      }
+    };
+    exports.LinkedList = LinkedList;
+  }
+});
+
+// ../utils/dist/array/duplicate-iterable.js
+var require_duplicate_iterable = __commonJS({
+  "../utils/dist/array/duplicate-iterable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BackPressureStream = void 0;
+    exports.duplicateIterable = duplicateIterable;
+    var LinkedList_1 = require_LinkedList();
+    function duplicateIterable(iterable, numberOfTimes) {
+      if (numberOfTimes === 0)
+        throw new Error("Number of Iterables should be at least 1");
+      const streams = [];
+      for (let i = 0; i < numberOfTimes; i++) {
+        streams.push(new BackPressureStream());
+      }
+      return {
+        streams,
+        start: async () => {
+          try {
+            for await (const item of iterable) {
+              for (const stream of streams) {
+                stream.push(item);
+              }
+            }
+            for (const stream of streams) {
+              stream.end();
+            }
+          } catch (e) {
+            for (const stream of streams) {
+              stream.fail(e);
+            }
+          }
+        }
+      };
+    }
+    var _BackPressureStream_instances, restartLoop_fn;
+    var BackPressureStream = class {
+      constructor() {
+        __privateAdd(this, _BackPressureStream_instances);
+        __publicField(this, "buffer", new LinkedList_1.LinkedList());
+        __publicField(this, "finished", null);
+        __publicField(this, "waiting", null);
+      }
+      push(newItem) {
+        if (this.finished)
+          throw new Error("Already Closed");
+        this.buffer.push(newItem);
+        __privateMethod(this, _BackPressureStream_instances, restartLoop_fn).call(this);
+      }
+      end() {
+        if (this.finished)
+          throw new Error("Already Closed");
+        this.finished = { success: true };
+        __privateMethod(this, _BackPressureStream_instances, restartLoop_fn).call(this);
+      }
+      fail(error) {
+        if (this.finished)
+          throw new Error("Already Closed");
+        this.finished = { success: false, error };
+        __privateMethod(this, _BackPressureStream_instances, restartLoop_fn).call(this);
+      }
+      async *[Symbol.asyncIterator]() {
+        while (!this.finished || this.buffer.length) {
+          while (this.buffer.length) {
+            yield this.buffer.shift();
+          }
+          if (this.finished)
+            break;
+          await new Promise((res) => {
+            this.waiting = res;
+          });
+        }
+        if (!this.finished.success) {
+          throw this.finished.error;
+        }
+      }
+    };
+    _BackPressureStream_instances = new WeakSet();
+    restartLoop_fn = function() {
+      if (!this.waiting)
+        return;
+      const waiting = this.waiting;
+      this.waiting = null;
+      waiting();
+    };
+    exports.BackPressureStream = BackPressureStream;
+  }
+});
+
+// ../utils/dist/array/index.js
+var require_array = __commonJS({
+  "../utils/dist/array/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_duplicate_iterable(), exports);
+    __exportStar(require_LinkedList(), exports);
+  }
+});
+
+// ../utils/dist/buffer.js
+var require_buffer = __commonJS({
+  "../utils/dist/buffer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.mergeBuffers = mergeBuffers;
+    function mergeBuffers(parts) {
+      const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+      let i = 0;
+      for (const p of parts) {
+        out.set(p, i);
+        i += p.length;
+      }
+      return out;
+    }
+  }
+});
+
+// ../utils/dist/string.js
+var require_string = __commonJS({
+  "../utils/dist/string.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.uniqueId = uniqueId;
+    exports.padString = padString;
+    exports.strToBuffer = strToBuffer;
+    exports.bufferToStr = bufferToStr;
+    exports.uint8ArrayToHex = uint8ArrayToHex;
+    exports.hexToUint8Array = hexToUint8Array;
+    exports.fileExtension = fileExtension;
+    var ID_COUNTER = 0;
+    function uniqueId() {
+      return [
+        padString(Date.now().toString(32), 8),
+        padString((ID_COUNTER++).toString(32), 8),
+        padString(Math.random().toString(32).substring(2, 10), 8)
+      ].join("-");
+    }
+    function padString(str, length, padChar = "0") {
+      if (str.length >= length)
+        return str.slice(0, length);
+      return padChar.repeat(length - str.length) + str;
+    }
+    function strToBuffer(str) {
+      return new TextEncoder().encode(str);
+    }
+    function bufferToStr(buffer) {
+      return new TextDecoder().decode(buffer);
+    }
+    function uint8ArrayToHex(array) {
+      return Array.from(array).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+    }
+    function hexToUint8Array(hexStr) {
+      return Uint8Array.from(hexStr.match(/.{2}/g), (b) => parseInt(b, 16));
+    }
+    function fileExtension(filepath) {
+      const normalized = filepath.replaceAll("\\", "/");
+      const fileName = normalized.split("/").pop();
+      if (!fileName)
+        return;
+      const lastDot = fileName.lastIndexOf(".");
+      if (lastDot === -1)
+        return;
+      if (lastDot === 0)
+        return;
+      return fileName.slice(lastDot);
+    }
+  }
+});
+
+// ../utils/dist/JSON.js
+var require_JSON = __commonJS({
+  "../utils/dist/JSON.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.cloneJSON = cloneJSON;
+    exports.compareJSON = compareJSON;
+    exports.canonicalJSONStringify = canonicalJSONStringify;
+    exports.isJSONObject = isJSONObject;
+    function cloneJSON(value) {
+      return JSON.parse(JSON.stringify(value));
+    }
+    function compareJSON(a, b) {
+      return canonicalJSONStringify(a) === canonicalJSONStringify(b);
+    }
+    function canonicalJSONStringify(value) {
+      if (typeof value !== "object")
+        return JSON.stringify(value);
+      if (value === null)
+        return JSON.stringify(value);
+      if (Array.isArray(value)) {
+        const elems = value.map((v) => canonicalJSONStringify(v)).join(",");
+        return `[${elems}]`;
+      }
+      const keys = Object.keys(value).sort();
+      const props = keys.map((key) => {
+        const k = JSON.stringify(key);
+        const v = canonicalJSONStringify(value[key]);
+        return `${k}:${v}`;
+      }).join(",");
+      return `{${props}}`;
+    }
+    function isJSONObject(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+  }
+});
+
+// ../utils/dist/crypto/encryption/symmetric.js
+var require_symmetric = __commonJS({
+  "../utils/dist/crypto/encryption/symmetric.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ENCRYPT_SYMMETRIC = void 0;
+    exports.generateSymmetricEncryptionKey = generateSymmetricEncryptionKey;
+    exports.encryptValue = encryptValue;
+    exports.decryptValue = decryptValue;
+    var string_1 = require_string();
+    var JSON_1 = require_JSON();
+    exports.ENCRYPT_SYMMETRIC = {
+      generateKey: generateSymmetricEncryptionKey,
+      encryptValue,
+      decryptValue
+    };
+    function generateSymmetricEncryptionKey(length = 32) {
+      const bytes = crypto.getRandomValues(new Uint8Array(length));
+      return (0, string_1.uint8ArrayToHex)(bytes);
+    }
+    async function encryptValue(masterKey, value) {
+      const valueString = (0, JSON_1.canonicalJSONStringify)(value);
+      const keyData = (0, string_1.hexToUint8Array)(masterKey);
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const cryptoKey = await crypto.subtle.importKey("raw", keyData, { name: "AES-GCM" }, false, ["encrypt"]);
+      const encryptedBuffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, cryptoKey, (0, string_1.strToBuffer)(valueString));
+      return `${(0, string_1.uint8ArrayToHex)(iv)}:${(0, string_1.uint8ArrayToHex)(new Uint8Array(encryptedBuffer))}`;
+    }
+    async function decryptValue(masterKey, encryptedData) {
+      const [ivHex, encryptedHex] = encryptedData.split(":");
+      const keyData = (0, string_1.hexToUint8Array)(masterKey);
+      const iv = (0, string_1.hexToUint8Array)(ivHex);
+      const encrypted = (0, string_1.hexToUint8Array)(encryptedHex);
+      const cryptoKey = await crypto.subtle.importKey("raw", keyData, { name: "AES-GCM" }, false, ["decrypt"]);
+      const decryptedBuffer = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, cryptoKey, encrypted);
+      const decoder = new TextDecoder();
+      const valueString = decoder.decode(decryptedBuffer);
+      return JSON.parse(valueString);
+    }
+  }
+});
+
+// ../utils/dist/crypto/encryption/index.js
+var require_encryption = __commonJS({
+  "../utils/dist/crypto/encryption/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ENCRYPTION = void 0;
+    var symmetric_1 = require_symmetric();
+    __exportStar(require_symmetric(), exports);
+    exports.ENCRYPTION = {
+      SYMMETRIC: symmetric_1.ENCRYPT_SYMMETRIC
+    };
+  }
+});
+
+// ../utils/dist/crypto/signature/asymmetric.js
+var require_asymmetric = __commonJS({
+  "../utils/dist/crypto/signature/asymmetric.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SIGNATURE_ASYMMETRIC = void 0;
+    exports.generateAsymmetricSignatureKeyPair = generateAsymmetricSignatureKeyPair;
+    exports.createAsymmetricMessageSignature = createAsymmetricMessageSignature;
+    exports.verifyAsymmetricMessageSignature = verifyAsymmetricMessageSignature;
+    var JSON_1 = require_JSON();
+    var string_1 = require_string();
+    var buffer_1 = require_buffer();
+    exports.SIGNATURE_ASYMMETRIC = {
+      generateKeyPair: generateAsymmetricSignatureKeyPair,
+      createSignature: createAsymmetricMessageSignature,
+      verifySignature: verifyAsymmetricMessageSignature
+    };
+    var PKCS8_HEADER = new Uint8Array([
+      48,
+      46,
+      2,
+      1,
+      0,
+      48,
+      5,
+      6,
+      3,
+      43,
+      101,
+      112,
+      4,
+      34,
+      4,
+      32
+    ]);
+    var SPKI_HEADER = new Uint8Array([
+      48,
+      42,
+      48,
+      5,
+      6,
+      3,
+      43,
+      101,
+      112,
+      3,
+      33,
+      0
+    ]);
+    var ED25519 = { name: "Ed25519" };
+    function base64urlToBytes(b64url) {
+      const b64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
+      return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));
+    }
+    async function importPrivKey(raw) {
+      return crypto.subtle.importKey("pkcs8", (0, buffer_1.mergeBuffers)([PKCS8_HEADER, raw]), ED25519, false, ["sign"]);
+    }
+    async function importPubKey(raw) {
+      return crypto.subtle.importKey("spki", (0, buffer_1.mergeBuffers)([SPKI_HEADER, raw]), ED25519, false, ["verify"]);
+    }
+    async function generateAsymmetricSignatureKeyPair() {
+      const keyPair = await crypto.subtle.generateKey(ED25519, true, ["sign", "verify"]);
+      if (!("privateKey" in keyPair))
+        throw new Error("Ed25519 generateKey did not return a key pair");
+      const privJwk = await crypto.subtle.exportKey("jwk", keyPair.privateKey);
+      const pubJwk = await crypto.subtle.exportKey("jwk", keyPair.publicKey);
+      return {
+        privateSigningKey: (0, string_1.uint8ArrayToHex)(base64urlToBytes(privJwk.d)),
+        publicVerificationKey: (0, string_1.uint8ArrayToHex)(base64urlToBytes(pubJwk.x))
+      };
+    }
+    async function createAsymmetricMessageSignature(privateSigningKey, message) {
+      const privKey = await importPrivKey((0, string_1.hexToUint8Array)(privateSigningKey));
+      const messageBytes = (0, string_1.strToBuffer)((0, JSON_1.canonicalJSONStringify)(message));
+      const signature = await crypto.subtle.sign(ED25519, privKey, messageBytes);
+      return (0, string_1.uint8ArrayToHex)(new Uint8Array(signature));
+    }
+    async function verifyAsymmetricMessageSignature(publicVerificationKey, signature, message) {
+      try {
+        const pubKey = await importPubKey((0, string_1.hexToUint8Array)(publicVerificationKey));
+        const messageBytes = (0, string_1.strToBuffer)((0, JSON_1.canonicalJSONStringify)(message));
+        return await crypto.subtle.verify(ED25519, pubKey, (0, string_1.hexToUint8Array)(signature), messageBytes);
+      } catch (e) {
+        return false;
+      }
+    }
+  }
+});
+
+// ../utils/dist/crypto/signature/symmetric.js
+var require_symmetric2 = __commonJS({
+  "../utils/dist/crypto/signature/symmetric.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SIGNATURE_SYMMETRIC = void 0;
+    exports.generateSymmetricSignatureKey = generateSymmetricSignatureKey;
+    exports.createSymmetricMessageSignature = createSymmetricMessageSignature;
+    exports.verifySymmetricMessageSignature = verifySymmetricMessageSignature;
+    var string_1 = require_string();
+    exports.SIGNATURE_SYMMETRIC = {
+      generateKey: generateSymmetricSignatureKey,
+      createSignature: createSymmetricMessageSignature,
+      verifySignature: verifySymmetricMessageSignature
+    };
+    function generateSymmetricSignatureKey() {
+      const bytes = crypto.getRandomValues(new Uint8Array(32));
+      return (0, string_1.uint8ArrayToHex)(bytes);
+    }
+    async function createSymmetricMessageSignature(key, message) {
+      const keyData = (0, string_1.hexToUint8Array)(key);
+      const messageData = (0, string_1.strToBuffer)(message);
+      const cryptoKey = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+      const signatureBuffer = await crypto.subtle.sign("HMAC", cryptoKey, messageData);
+      return (0, string_1.uint8ArrayToHex)(new Uint8Array(signatureBuffer));
+    }
+    async function verifySymmetricMessageSignature(key, message, signature) {
+      const expectedSignature = await createSymmetricMessageSignature(key, message);
+      if (signature.length !== expectedSignature.length) {
+        return false;
+      }
+      let result = 0;
+      for (let i = 0; i < signature.length; i++) {
+        result |= signature.charCodeAt(i) ^ expectedSignature.charCodeAt(i);
+      }
+      return result === 0;
+    }
+  }
+});
+
+// ../utils/dist/crypto/signature/index.js
+var require_signature = __commonJS({
+  "../utils/dist/crypto/signature/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SIGNATURE = void 0;
+    var asymmetric_1 = require_asymmetric();
+    var symmetric_1 = require_symmetric2();
+    __exportStar(require_asymmetric(), exports);
+    __exportStar(require_symmetric2(), exports);
+    exports.SIGNATURE = {
+      ASYMMETRIC: asymmetric_1.SIGNATURE_ASYMMETRIC,
+      SYMMETRIC: symmetric_1.SIGNATURE_SYMMETRIC
+    };
+  }
+});
+
+// ../utils/dist/crypto/sha.js
+var require_sha = __commonJS({
+  "../utils/dist/crypto/sha.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createShaFromJSON = createShaFromJSON;
+    exports.createShaFromString = createShaFromString;
+    exports.createShaFromBuffer = createShaFromBuffer;
+    exports.createShaFromTextStream = createShaFromTextStream;
+    exports.createShaFromUintStream = createShaFromUintStream;
+    var string_1 = require_string();
+    var JSON_1 = require_JSON();
+    var buffer_1 = require_buffer();
+    function createShaFromJSON(value) {
+      return createShaFromString((0, JSON_1.canonicalJSONStringify)(value));
+    }
+    async function createShaFromString(value) {
+      return createShaFromBuffer((0, string_1.strToBuffer)(value));
+    }
+    async function createShaFromBuffer(value) {
+      const hashBuffer = await crypto.subtle.digest("SHA-256", value);
+      return (0, string_1.uint8ArrayToHex)(new Uint8Array(hashBuffer));
+    }
+    async function createShaFromTextStream(value) {
+      const parts = [];
+      for await (const chunk of value)
+        parts.push((0, string_1.strToBuffer)(chunk));
+      return createShaFromBuffer((0, buffer_1.mergeBuffers)(parts));
+    }
+    async function createShaFromUintStream(value) {
+      const parts = [];
+      for await (const chunk of value)
+        parts.push(chunk);
+      return createShaFromBuffer((0, buffer_1.mergeBuffers)(parts));
+    }
+  }
+});
+
+// ../utils/dist/crypto/index.js
+var require_crypto = __commonJS({
+  "../utils/dist/crypto/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_encryption(), exports);
+    __exportStar(require_signature(), exports);
+    __exportStar(require_sha(), exports);
+  }
+});
+
+// ../utils/dist/MessageBridge/types.js
+var require_types = __commonJS({
+  "../utils/dist/MessageBridge/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.castMessage = castMessage;
+    function castMessage(message) {
+      if (typeof message !== "object") {
+        throw new Error("expecting a complex type");
+      }
+      if (Array.isArray(message)) {
+        throw new Error("expecting a complex type");
+      }
+      if (message === null) {
+        throw new Error("expecting a complex type");
+      }
+      if (typeof message.messageType !== "string") {
+        throw new Error("expecting a message type");
+      }
+      if (message.messageType === "event") {
+        if (typeof message.path !== "string") {
+          throw new Error("expecting a path");
+        }
+        if (typeof message.value === "undefined") {
+          throw new Error("expecting a value");
+        }
+        return { messageType: "event", path: message.path, value: message.value };
+      }
+      if (message.messageType === "request") {
+        if (typeof message.id !== "string") {
+          throw new Error("expecting an id");
+        }
+        if (typeof message.path !== "string") {
+          throw new Error("expecting a path");
+        }
+        if (typeof message.value === "undefined") {
+          throw new Error("expecting a value");
+        }
+        return { id: message.id, messageType: "request", path: message.path, value: message.value };
+      }
+      if (message.messageType === "response") {
+        if (typeof message.id !== "string") {
+          throw new Error("expecting an id");
+        }
+        if (typeof message.valueType !== "string") {
+          throw new Error("expecting a value type");
+        }
+        if (message.valueType !== "result" && message.valueType !== "error") {
+          throw new Error("invalid value type");
+        }
+        if (typeof message.value === "undefined") {
+          throw new Error("expecting a value");
+        }
+        return { id: message.id, messageType: "response", valueType: message.valueType, value: message.value };
+      }
+      if (message.messageType === "stream-attempt") {
+        if (typeof message.id !== "string") {
+          throw new Error("expecting an id");
+        }
+        if (typeof message.path !== "string") {
+          throw new Error("expecting a path");
+        }
+        return { id: message.id, messageType: "stream-attempt", path: message.path };
+      }
+      if (message.messageType === "stream-response") {
+        if (typeof message.id !== "string") {
+          throw new Error("expecting an id");
+        }
+        if (!["start", "error"].includes(message.value)) {
+          throw new Error('expecting a value as "start" or "error"');
+        }
+        return { id: message.id, messageType: "stream-response", value: message.value };
+      }
+      if (message.messageType === "stream-data") {
+        if (typeof message.id !== "string") {
+          throw new Error("expecting an id");
+        }
+        if (typeof message.value === "undefined") {
+          throw new Error("expecting a value");
+        }
+        return { id: message.id, messageType: "stream-data", value: message.value };
+      }
+      if (message.messageType === "stream-end") {
+        if (typeof message.id !== "string") {
+          throw new Error("expecting an id");
+        }
+        return { id: message.id, messageType: "stream-end" };
+      }
+      throw new Error("invalid message type");
+    }
+  }
+});
+
+// ../utils/dist/MessageBridge/event.js
+var require_event = __commonJS({
+  "../utils/dist/MessageBridge/event.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventHandler = void 0;
+    var EventHandler = class {
+      constructor(sendMessage, debug) {
+        __publicField(this, "sendMessage");
+        __publicField(this, "debug");
+        __publicField(this, "listeners", {});
+        this.sendMessage = sendMessage;
+        this.debug = debug;
+      }
+      handleMessage(message) {
+        switch (message.messageType) {
+          case "event": {
+            try {
+              const handlers = this.listeners[message.path];
+              if (!handlers)
+                throw new Error(`no event listener at ${message.path}`);
+              Promise.resolve().then(async () => {
+                for (const handler of handlers) {
+                  await handler(message.value);
+                }
+              });
+            } catch (e) {
+              this.debug && console.error("error handling message", e);
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      sendEvent(path, body) {
+        this.sendMessage({
+          path,
+          messageType: "event",
+          value: body
+        });
+      }
+      onEvent(path, handler) {
+        const listeners = this.listeners[path] || [];
+        listeners.push(handler);
+        this.listeners[path] = listeners;
+        return () => {
+          this.listeners[path] = (this.listeners[path] || []).filter((l) => l !== handler);
+        };
+      }
+    };
+    exports.EventHandler = EventHandler;
+  }
+});
+
+// ../utils/dist/MessageBridge/request.js
+var require_request = __commonJS({
+  "../utils/dist/MessageBridge/request.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RequestHandler = void 0;
+    var string_1 = require_string();
+    var RequestHandler = class {
+      constructor(sendMessage, debug) {
+        __publicField(this, "sendMessage");
+        __publicField(this, "debug");
+        __publicField(this, "listeners", {});
+        __publicField(this, "pending", {});
+        this.sendMessage = sendMessage;
+        this.debug = debug;
+      }
+      handleMessage(message) {
+        switch (message.messageType) {
+          case "request": {
+            try {
+              const handler = this.listeners[message.path];
+              if (!handler)
+                throw new Error(`no request listener at ${message.path}`);
+              Promise.resolve().then(async () => {
+                try {
+                  const result = await handler(message.value);
+                  this.sendMessage({
+                    id: message.id,
+                    messageType: "response",
+                    valueType: "result",
+                    value: result
+                  });
+                } catch (e) {
+                  this.sendMessage({
+                    id: message.id,
+                    messageType: "response",
+                    valueType: "error",
+                    value: typeof e === "string" ? e : e instanceof Error ? e.message : "Unknown Error"
+                  });
+                }
+              });
+            } catch (e) {
+              this.sendMessage({
+                id: message.id,
+                messageType: "response",
+                valueType: "error",
+                value: typeof e === "string" ? e : e instanceof Error ? e.message : "Unknown Error"
+              });
+            }
+            return true;
+          }
+          case "response": {
+            try {
+              const pending = this.pending[message.id];
+              if (!pending)
+                throw new Error(`no pending request for ${message.id}`);
+              delete this.pending[message.id];
+              if (message.valueType === "error") {
+                pending.reject(message.value);
+              } else {
+                pending.resolve(message.value);
+              }
+            } catch (e) {
+              this.debug && console.error("error handling message", e);
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      sendRequest(path, body) {
+        return new Promise((resolve, reject) => {
+          const id = (0, string_1.uniqueId)();
+          this.pending[id] = { resolve, reject };
+          this.sendMessage({
+            id,
+            path,
+            messageType: "request",
+            value: body
+          });
+        });
+      }
+      onRequest(path, handler) {
+        if (path in this.listeners) {
+          throw new Error(`Duplicate Path: ${path}`);
+        }
+        this.listeners[path] = handler;
+        return () => {
+          if (this.listeners[path] === handler)
+            delete this.listeners[path];
+        };
+      }
+    };
+    exports.RequestHandler = RequestHandler;
+  }
+});
+
+// ../utils/dist/SimpleEvent.js
+var require_SimpleEvent = __commonJS({
+  "../utils/dist/SimpleEvent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createSimpleEmitter = createSimpleEmitter;
+    function createSimpleEmitter(config = {
+      allowDuplicateCallback: false,
+      maximumListeners: Number.POSITIVE_INFINITY,
+      suppressErrors: true
+    }) {
+      if (config.maximumListeners <= 0) {
+        throw new Error("maximumListeners can't be less than or equal to 0");
+      }
+      const context = {
+        config,
+        listeners: []
+      };
+      const emitter = SimpleEmitter.bind(context);
+      emitter.onReturnOff = emitter;
+      emitter.on = addListener.bind(context);
+      emitter.off = removeListener.bind(context);
+      emitter.emit = emitEvent.bind(context);
+      emitter.filter = filterEvent.bind(context);
+      context.on = emitter.on;
+      context.off = emitter.off;
+      return emitter;
+    }
+    function SimpleEmitter(cb) {
+      this.on(cb);
+      return () => this.off(cb);
+    }
+    function addListener(cb) {
+      if (this.config.maximumListeners === this.listeners.length) {
+        throw new Error("Hit Maximum Listeners");
+      }
+      if (!this.config.allowDuplicateCallback) {
+        for (const listener of this.listeners) {
+          if (listener === cb) {
+            throw new Error("Can't add listener multiple times");
+          }
+        }
+      }
+      this.listeners.push(cb);
+    }
+    function removeListener(cb) {
+      const offset = this.listeners.indexOf(cb);
+      if (offset === -1) {
+        return false;
+      }
+      this.listeners.splice(offset, 1);
+      return true;
+    }
+    function emitEvent(...args) {
+      for (const listener of this.listeners) {
+        try {
+          listener(...args);
+        } catch (e) {
+          if (!this.config.suppressErrors)
+            throw e;
+        }
+      }
+    }
+    function filterEvent(filter) {
+      const newEmitter = createSimpleEmitter(this.config);
+      const weakRef = new WeakRef(newEmitter);
+      const listener = (...args) => {
+        const newEmitter2 = weakRef.deref();
+        if (!newEmitter2)
+          return this.off(listener);
+        if (filter(...args))
+          newEmitter2.emit(...args);
+      };
+      this.on(listener);
+      return newEmitter;
+    }
+  }
+});
+
+// ../utils/dist/MessageBridge/stream.js
+var require_stream = __commonJS({
+  "../utils/dist/MessageBridge/stream.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StreamHandler = exports.StreamRequest = exports.SimpleStream = void 0;
+    var SimpleEvent_1 = require_SimpleEvent();
+    var string_1 = require_string();
+    var SimpleStream = class {
+      constructor(_sendData, _sendEnd) {
+        __publicField(this, "_sendData");
+        __publicField(this, "_sendEnd");
+        __publicField(this, "state", "setup");
+        __publicField(this, "onData", (0, SimpleEvent_1.createSimpleEmitter)());
+        __publicField(this, "onEnd", (0, SimpleEvent_1.createSimpleEmitter)());
+        this._sendData = _sendData;
+        this._sendEnd = _sendEnd;
+        this.onEnd(() => {
+          if (this.state === "active") {
+            this.state = "closed";
+          }
+        });
+      }
+      sendData(data) {
+        if (this.state === "setup")
+          throw new Error("Cannot send on stream during setup. Defer with Promise.resolve().then(() => stream.sendData(...))");
+        if (this.state === "failed")
+          throw new Error("Cannot send on stream after failed to connect.");
+        if (this.state === "closed")
+          throw new Error("Cannot send on stream after closed.");
+        this._sendData(data);
+      }
+      sendEnd() {
+        if (this.state === "setup")
+          throw new Error("Cannot send on stream during setup. Defer with Promise.resolve().then(() => stream.sendEnd())");
+        if (this.state === "failed")
+          throw new Error("Cannot end on stream after failed to connect.");
+        if (this.state === "closed")
+          throw new Error("Cannot end on stream after closed.");
+        this._sendEnd();
+        this.onEnd.emit();
+      }
+    };
+    exports.SimpleStream = SimpleStream;
+    var StreamRequest = class extends SimpleStream {
+      constructor(sendData, sendEnd) {
+        super(sendData, sendEnd);
+        __publicField(this, "waitForOpen");
+        __publicField(this, "_resolveOpen");
+        __publicField(this, "_rejectOpen");
+        this.waitForOpen = new Promise((resolve, reject) => {
+          this._resolveOpen = resolve;
+          this._rejectOpen = reject;
+        });
+      }
+    };
+    exports.StreamRequest = StreamRequest;
+    var StreamHandler = class {
+      constructor(sendMessage, debug) {
+        __publicField(this, "sendMessage");
+        __publicField(this, "debug");
+        __publicField(this, "listeners", {});
+        __publicField(this, "pending", {});
+        __publicField(this, "active", {});
+        this.sendMessage = sendMessage;
+        this.debug = debug;
+      }
+      handleMessage(message) {
+        switch (message.messageType) {
+          case "stream-attempt": {
+            try {
+              if (this.active[message.id])
+                throw new Error("Duplicate Stream Id");
+              const handler = this.listeners[message.path];
+              if (!handler)
+                throw new Error(`no request listener at ${message.path}`);
+              const stream = this.createStream(message.id);
+              const result = handler(stream);
+              stream.state = "active";
+              this.active[message.id] = stream;
+              this.sendMessage({
+                id: message.id,
+                messageType: "stream-response",
+                value: "start"
+              });
+              Promise.resolve(result).catch((e) => {
+                this.debug && console.warn("stream error handling suppressed", e);
+              });
+            } catch (e) {
+              this.sendMessage({
+                id: message.id,
+                messageType: "stream-response",
+                value: "error"
+              });
+            }
+            return true;
+          }
+          case "stream-response": {
+            const pending = this.pending[message.id];
+            if (!pending)
+              throw new Error(`no pending stream for ${message.id}`);
+            if (this.active[message.id])
+              throw new Error("Duplicate Stream Id");
+            delete this.pending[message.id];
+            if (message.value === "error") {
+              pending.reject("Failed to establish stream");
+              return true;
+            }
+            this.active[message.id] = pending.stream;
+            pending.resolve(pending.stream);
+            return true;
+          }
+          case "stream-data": {
+            const active = this.active[message.id];
+            if (!active)
+              throw new Error(`no active stream for ${message.id}`);
+            active.onData.emit(message.value);
+            return true;
+          }
+          case "stream-end": {
+            const active = this.active[message.id];
+            if (!active)
+              throw new Error(`no active stream for ${message.id}`);
+            delete this.active[message.id];
+            active.onEnd.emit();
+            return true;
+          }
+        }
+        return false;
+      }
+      createStreamRequest(streamId) {
+        const stream = new StreamRequest((data) => {
+          if (!(streamId in this.active)) {
+            throw new Error("Stream isn't active");
+          }
+          this.sendMessage({
+            id: streamId,
+            messageType: "stream-data",
+            value: data
+          });
+        }, () => {
+          if (!(streamId in this.active)) {
+            throw new Error("Stream isn't active");
+          }
+          delete this.active[streamId];
+          this.sendMessage({
+            id: streamId,
+            messageType: "stream-end"
+          });
+        });
+        return stream;
+      }
+      createStream(streamId) {
+        const stream = new SimpleStream((data) => {
+          if (!(streamId in this.active)) {
+            throw new Error("Stream isn't active");
+          }
+          this.sendMessage({
+            id: streamId,
+            messageType: "stream-data",
+            value: data
+          });
+        }, () => {
+          if (!(streamId in this.active)) {
+            throw new Error("Stream isn't active");
+          }
+          delete this.active[streamId];
+          this.sendMessage({
+            id: streamId,
+            messageType: "stream-end"
+          });
+        });
+        return stream;
+      }
+      sendStream(path) {
+        const id = (0, string_1.uniqueId)();
+        const stream = this.createStreamRequest(id);
+        stream.state = "setup";
+        this.pending[id] = {
+          stream,
+          resolve: () => {
+            stream.state = "active";
+            stream._resolveOpen();
+          },
+          reject: (reason) => {
+            stream.state = "failed";
+            stream._rejectOpen(reason);
+          }
+        };
+        Promise.resolve().then(() => this.sendMessage({ id, path, messageType: "stream-attempt" }));
+        return stream;
+      }
+      onStream(path, handler) {
+        if (path in this.listeners) {
+          throw new Error(`Duplicate Path: ${path}`);
+        }
+        this.listeners[path] = handler;
+        return () => {
+          if (this.listeners[path] === handler)
+            delete this.listeners[path];
+        };
+      }
+    };
+    exports.StreamHandler = StreamHandler;
+  }
+});
+
+// ../utils/dist/MessageBridge/index.js
+var require_MessageBridge = __commonJS({
+  "../utils/dist/MessageBridge/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BridgeRequest = exports.BridgedSession = exports.MessageBridge = void 0;
+    var types_1 = require_types();
+    var event_1 = require_event();
+    var request_1 = require_request();
+    var stream_1 = require_stream();
+    var MessageBridge = class {
+      constructor(sendMessage, debug = false) {
+        __publicField(this, "sendMessage");
+        __publicField(this, "debug");
+        __publicField(this, "_destroyed", false);
+        __publicField(this, "eventHandler");
+        __publicField(this, "requestHandler");
+        __publicField(this, "streamHandler");
+        this.sendMessage = sendMessage;
+        this.debug = debug;
+        this.eventHandler = new event_1.EventHandler(sendMessage, debug);
+        this.requestHandler = new request_1.RequestHandler(sendMessage, debug);
+        this.streamHandler = new stream_1.StreamHandler(sendMessage, debug);
+      }
+      async handleMessage(messageRaw) {
+        const message = (0, types_1.castMessage)(messageRaw);
+        if (this.eventHandler.handleMessage(message))
+          return;
+        if (this.requestHandler.handleMessage(message))
+          return;
+        if (this.streamHandler.handleMessage(message))
+          return;
+      }
+      destroy() {
+        if (this._destroyed)
+          return;
+        this._destroyed = true;
+        const error = new Error("Bridge destroyed");
+        for (const pending of Object.values(this.requestHandler.pending)) {
+          pending.reject(error);
+        }
+        this.requestHandler.pending = {};
+        for (const pending of Object.values(this.streamHandler.pending)) {
+          pending.reject(error);
+        }
+        this.streamHandler.pending = {};
+        for (const stream of Object.values(this.streamHandler.active)) {
+          stream.onEnd.emit();
+        }
+        this.streamHandler.active = {};
+      }
+      sendBridge(path) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return new BridgeRequest(this.sendStream(path), this.debug);
+      }
+      onBridge(path, handler) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.onStream(path, (stream) => {
+          const session = new BridgedSession(stream, this.debug);
+          return handler(session);
+        });
+      }
+      sendStream(path) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.streamHandler.sendStream(path);
+      }
+      onStream(path, handler) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.streamHandler.onStream(path, handler);
+      }
+      sendRequest(path, body) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.requestHandler.sendRequest(path, body);
+      }
+      onRequest(path, handler) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.requestHandler.onRequest(path, handler);
+      }
+      sendEvent(path, body) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.eventHandler.sendEvent(path, body);
+      }
+      onEvent(path, handler) {
+        if (this._destroyed)
+          throw new Error("Bridge destroyed");
+        return this.eventHandler.onEvent(path, handler);
+      }
+    };
+    exports.MessageBridge = MessageBridge;
+    var BridgedSession = class extends MessageBridge {
+      constructor(stream, debug) {
+        super((msg) => stream.sendData(msg), debug);
+        __publicField(this, "_stream");
+        this._stream = stream;
+        stream.onData((data) => this.handleMessage(data));
+        stream.onEnd(() => this.destroy());
+      }
+      get onEnd() {
+        return this._stream.onEnd;
+      }
+      sendEnd() {
+        this._stream.sendEnd();
+      }
+    };
+    exports.BridgedSession = BridgedSession;
+    var BridgeRequest = class extends BridgedSession {
+      constructor(stream, debug) {
+        super(stream, debug);
+        __publicField(this, "_request");
+        this._request = stream;
+        stream.waitForOpen.catch(() => {
+          this.destroy();
+        });
+      }
+      get waitForOpen() {
+        return this._request.waitForOpen;
+      }
+    };
+    exports.BridgeRequest = BridgeRequest;
+  }
+});
+
+// ../utils/dist/Promise/withResolvers.js
+var require_withResolvers = __commonJS({
+  "../utils/dist/Promise/withResolvers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.promiseWithResolvers = promiseWithResolvers;
+    function promiseWithResolvers() {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      return { promise, resolve, reject };
+    }
+  }
+});
+
+// ../utils/dist/Promise/SimpleEvent.js
+var require_SimpleEvent2 = __commonJS({
+  "../utils/dist/Promise/SimpleEvent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.waitForEvent = waitForEvent;
+    exports.waitForEventTimeout = waitForEventTimeout;
+    var withResolvers_1 = require_withResolvers();
+    function waitForEvent(event, abortSignal) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        return Promise.reject(new Error("Aborted"));
+      }
+      const { promise, resolve, reject } = (0, withResolvers_1.promiseWithResolvers)();
+      const off = event(((...args) => {
+        resolve(args);
+      }));
+      promise.finally(() => {
+        off();
+      });
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", () => reject(new Error("Aborted")));
+      }
+      return promise;
+    }
+    function waitForEventTimeout(event, timeout, abortSignal) {
+      if (abortSignal == null ? void 0 : abortSignal.aborted) {
+        return Promise.reject(new Error("Aborted"));
+      }
+      const { promise, resolve, reject } = (0, withResolvers_1.promiseWithResolvers)();
+      const eventTimedOut = () => resolve();
+      let to = setTimeout(eventTimedOut, timeout);
+      const off = event(((...args) => {
+        clearTimeout(to);
+        to = setTimeout(eventTimedOut, timeout);
+      }));
+      promise.finally(() => {
+        off();
+        clearTimeout(to);
+      });
+      if (abortSignal) {
+        abortSignal.addEventListener("abort", () => reject(new Error("Aborted")));
+      }
+      return promise;
+    }
+  }
+});
+
+// ../utils/dist/Promise/waitForBridgeEvent.js
+var require_waitForBridgeEvent = __commonJS({
+  "../utils/dist/Promise/waitForBridgeEvent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.waitForBridgeEvent = waitForBridgeEvent;
+    var withResolvers_1 = require_withResolvers();
+    function waitForBridgeEvent(bridge, event, timeout) {
+      const { resolve, reject, promise } = (0, withResolvers_1.promiseWithResolvers)();
+      const to = setTimeout(() => {
+        reject(new Error("Timeout"));
+      }, timeout);
+      bridge.onEvent(event, (data) => {
+        resolve(data);
+      });
+      promise.finally(() => {
+        clearTimeout(to);
+      }).catch(() => {
+      });
+      return promise;
+    }
+  }
+});
+
+// ../utils/dist/Promise/index.js
+var require_Promise = __commonJS({
+  "../utils/dist/Promise/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.delay = delay;
+    __exportStar(require_SimpleEvent2(), exports);
+    __exportStar(require_waitForBridgeEvent(), exports);
+    __exportStar(require_withResolvers(), exports);
+    function delay(ms) {
+      return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/path-to-regexp@8.4.2/node_modules/path-to-regexp/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@8.4.2/node_modules/path-to-regexp/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PathError = exports.TokenData = void 0;
+    exports.parse = parse;
+    exports.compile = compile;
+    exports.match = match;
+    exports.pathToRegexp = pathToRegexp;
+    exports.stringify = stringify;
+    var DEFAULT_DELIMITER = "/";
+    var NOOP_VALUE = (value) => value;
+    var ID_START = /^[$_\p{ID_Start}]$/u;
+    var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+    var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
+    function escapeText(str) {
+      return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
+    }
+    function escape(str) {
+      return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+    }
+    var TokenData = class {
+      constructor(tokens, originalPath) {
+        this.tokens = tokens;
+        this.originalPath = originalPath;
+      }
+    };
+    exports.TokenData = TokenData;
+    var PathError = class extends TypeError {
+      constructor(message, originalPath) {
+        let text = message;
+        if (originalPath)
+          text += `: ${originalPath}`;
+        text += `; visit https://git.new/pathToRegexpError for info`;
+        super(text);
+        this.originalPath = originalPath;
+      }
+    };
+    exports.PathError = PathError;
+    function parse(str, options = {}) {
+      const { encodePath = NOOP_VALUE } = options;
+      const chars = [...str];
+      let index = 0;
+      function consumeUntil(end) {
+        const output = [];
+        let path = "";
+        function writePath() {
+          if (!path)
+            return;
+          output.push({
+            type: "text",
+            value: encodePath(path)
+          });
+          path = "";
+        }
+        while (index < chars.length) {
+          const value = chars[index++];
+          if (value === end) {
+            writePath();
+            return output;
+          }
+          if (value === "\\") {
+            if (index === chars.length) {
+              throw new PathError(`Unexpected end after \\ at index ${index}`, str);
+            }
+            path += chars[index++];
+            continue;
+          }
+          if (value === ":" || value === "*") {
+            const type = value === ":" ? "param" : "wildcard";
+            let name = "";
+            if (ID_START.test(chars[index])) {
+              do {
+                name += chars[index++];
+              } while (ID_CONTINUE.test(chars[index]));
+            } else if (chars[index] === '"') {
+              let quoteStart = index;
+              while (index < chars.length) {
+                if (chars[++index] === '"') {
+                  index++;
+                  quoteStart = 0;
+                  break;
+                }
+                if (chars[index] === "\\")
+                  index++;
+                name += chars[index];
+              }
+              if (quoteStart) {
+                throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+              }
+            }
+            if (!name) {
+              throw new PathError(`Missing parameter name at index ${index}`, str);
+            }
+            writePath();
+            output.push({ type, name });
+            continue;
+          }
+          if (value === "{") {
+            writePath();
+            output.push({
+              type: "group",
+              tokens: consumeUntil("}")
+            });
+            continue;
+          }
+          if (value === "}" || value === "(" || value === ")" || value === "[" || value === "]" || value === "+" || value === "?" || value === "!") {
+            throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+          }
+          path += value;
+        }
+        if (end) {
+          throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
+        }
+        writePath();
+        return output;
+      }
+      return new TokenData(consumeUntil(""), str);
+    }
+    function compile(path, options = {}) {
+      const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+      const data = typeof path === "object" ? path : parse(path, options);
+      const fn = tokensToFunction(data.tokens, delimiter, encode);
+      return function path2(params = {}) {
+        const missing = [];
+        const path3 = fn(params, missing);
+        if (missing.length) {
+          throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
+        }
+        return path3;
+      };
+    }
+    function tokensToFunction(tokens, delimiter, encode) {
+      const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
+      return (data, missing) => {
+        let result = "";
+        for (const encoder of encoders) {
+          result += encoder(data, missing);
+        }
+        return result;
+      };
+    }
+    function tokenToFunction(token, delimiter, encode) {
+      if (token.type === "text")
+        return () => token.value;
+      if (token.type === "group") {
+        const fn = tokensToFunction(token.tokens, delimiter, encode);
+        return (data, missing) => {
+          const len = missing.length;
+          const value = fn(data, missing);
+          if (missing.length === len)
+            return value;
+          missing.length = len;
+          return "";
+        };
+      }
+      const encodeValue = encode || NOOP_VALUE;
+      if (token.type === "wildcard" && encode !== false) {
+        return (data, missing) => {
+          const value = data[token.name];
+          if (value == null) {
+            missing.push(token.name);
+            return "";
+          }
+          if (!Array.isArray(value) || value.length === 0) {
+            throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+          }
+          let result = "";
+          for (let i = 0; i < value.length; i++) {
+            if (typeof value[i] !== "string") {
+              throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+            }
+            if (i > 0)
+              result += delimiter;
+            result += encodeValue(value[i]);
+          }
+          return result;
+        };
+      }
+      return (data, missing) => {
+        const value = data[token.name];
+        if (value == null) {
+          missing.push(token.name);
+          return "";
+        }
+        if (typeof value !== "string") {
+          throw new TypeError(`Expected "${token.name}" to be a string`);
+        }
+        return encodeValue(value);
+      };
+    }
+    function match(path, options = {}) {
+      const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+      const { regexp, keys } = pathToRegexp(path, options);
+      const decoders = keys.map((key) => {
+        if (decode === false)
+          return NOOP_VALUE;
+        if (key.type === "param")
+          return decode;
+        return (value) => value.split(delimiter).map(decode);
+      });
+      return function match2(input) {
+        const m = regexp.exec(input);
+        if (!m)
+          return false;
+        const path2 = m[0];
+        const params = /* @__PURE__ */ Object.create(null);
+        for (let i = 1; i < m.length; i++) {
+          if (m[i] === void 0)
+            continue;
+          const key = keys[i - 1];
+          const decoder = decoders[i - 1];
+          params[key.name] = decoder(m[i]);
+        }
+        return { path: path2, params };
+      };
+    }
+    function pathToRegexp(path, options = {}) {
+      const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
+      const keys = [];
+      let source = "";
+      let combinations = 0;
+      function process(path2) {
+        if (Array.isArray(path2)) {
+          for (const p of path2)
+            process(p);
+          return;
+        }
+        const data = typeof path2 === "object" ? path2 : parse(path2, options);
+        flatten(data.tokens, 0, [], (tokens) => {
+          if (combinations >= 256) {
+            throw new PathError("Too many path combinations", data.originalPath);
+          }
+          if (combinations > 0)
+            source += "|";
+          source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+          combinations++;
+        });
+      }
+      process(path);
+      let pattern = `^(?:${source})`;
+      if (trailing)
+        pattern += "(?:" + escape(delimiter) + "$)?";
+      pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+      return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
+    }
+    function flatten(tokens, index, result, callback) {
+      while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "group") {
+          const len = result.length;
+          flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+          result.length = len;
+          continue;
+        }
+        result.push(token);
+      }
+      callback(result);
+    }
+    function toRegExpSource(tokens, delimiter, keys, originalPath) {
+      let result = "";
+      let backtrack = "";
+      let wildcardBacktrack = "";
+      let prevCaptureType = 0;
+      let hasSegmentCapture = 0;
+      let index = 0;
+      function hasInSegment(index2, type) {
+        while (index2 < tokens.length) {
+          const token = tokens[index2++];
+          if (token.type === type)
+            return true;
+          if (token.type === "text") {
+            if (token.value.includes(delimiter))
+              break;
+          }
+        }
+        return false;
+      }
+      function peekText(index2) {
+        let result2 = "";
+        while (index2 < tokens.length) {
+          const token = tokens[index2++];
+          if (token.type !== "text")
+            break;
+          result2 += token.value;
+        }
+        return result2;
+      }
+      while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "text") {
+          result += escape(token.value);
+          backtrack += token.value;
+          if (prevCaptureType === 2)
+            wildcardBacktrack += token.value;
+          if (token.value.includes(delimiter))
+            hasSegmentCapture = 0;
+          continue;
+        }
+        if (token.type === "param" || token.type === "wildcard") {
+          if (prevCaptureType && !backtrack) {
+            throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
+          }
+          if (token.type === "param") {
+            result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})` : `(${negate(delimiter, "")}+)`;
+            hasSegmentCapture |= prevCaptureType = 1;
+          } else {
+            result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
+            wildcardBacktrack = "";
+            hasSegmentCapture |= prevCaptureType = 2;
+          }
+          keys.push(token);
+          backtrack = "";
+          continue;
+        }
+        throw new TypeError(`Unknown token type: ${token.type}`);
+      }
+      return result;
+    }
+    function negate(a, b) {
+      if (b.length > a.length)
+        return negate(b, a);
+      if (a === b)
+        b = "";
+      if (b.length > 1)
+        return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+      if (a.length > 1)
+        return `(?:(?!${escape(a)})[^${escape(b)}])`;
+      return `[^${escape(a + b)}]`;
+    }
+    function stringifyTokens(tokens, index) {
+      let value = "";
+      while (index < tokens.length) {
+        const token = tokens[index++];
+        if (token.type === "text") {
+          value += escapeText(token.value);
+          continue;
+        }
+        if (token.type === "group") {
+          value += "{" + stringifyTokens(token.tokens, 0) + "}";
+          continue;
+        }
+        if (token.type === "param") {
+          value += ":" + stringifyName(token.name, tokens[index]);
+          continue;
+        }
+        if (token.type === "wildcard") {
+          value += "*" + stringifyName(token.name, tokens[index]);
+          continue;
+        }
+        throw new TypeError(`Unknown token type: ${token.type}`);
+      }
+      return value;
+    }
+    function stringify(data) {
+      return stringifyTokens(data.tokens, 0);
+    }
+    function stringifyName(name, next) {
+      if (!ID.test(name))
+        return JSON.stringify(name);
+      if ((next === null || next === void 0 ? void 0 : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+        return JSON.stringify(name);
+      }
+      return name;
+    }
+  }
+});
+
+// ../utils/dist/async.js
+var require_async = __commonJS({
+  "../utils/dist/async.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.eachSeries = eachSeries;
+    function eachSeries(values, iterator, finishedCB) {
+      let index = 0;
+      function next(err) {
+        if (err)
+          return finishedCB(err);
+        if (index >= values.length)
+          return finishedCB();
+        iterator(values[index++], next);
+      }
+      next();
+    }
+  }
+});
+
+// ../utils/dist/Router/Generic.js
+var require_Generic = __commonJS({
+  "../utils/dist/Router/Generic.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GenericRouter = void 0;
+    var path_to_regexp_1 = require_dist();
+    var async_1 = require_async();
+    var GenericRouter = class _GenericRouter {
+      constructor(getRequestURL, getRequestMethod, config = {}) {
+        __publicField(this, "getRequestURL");
+        __publicField(this, "getRequestMethod");
+        __publicField(this, "config");
+        __publicField(this, "handlers", []);
+        this.getRequestURL = getRequestURL;
+        this.getRequestMethod = getRequestMethod;
+        this.config = config;
+      }
+      use(path, ...callbacks) {
+        return this.addHandler("*", path, true, ...callbacks);
+      }
+      all(path, ...callbacks) {
+        return this.addHandler("*", path, false, ...callbacks);
+      }
+      addHandler(method, path, isPrefix, ...callbacks) {
+        const matcher = (0, path_to_regexp_1.match)(path, { end: !isPrefix, decode: decodeURIComponent });
+        const realCallbacks = callbacks.map((callback) => callback instanceof _GenericRouter ? (request, params, cb) => callback.handleRequest(request, cb, params) : callback);
+        this.handlers.push({
+          method,
+          path,
+          matcher,
+          callbacks: realCallbacks,
+          isPrefix
+        });
+        return this;
+      }
+      handleRequest(request, callback, parentRoute) {
+        if (!parentRoute) {
+          parentRoute = {
+            url: new URL(this.getRequestURL(request).href, "ws://localhost:80"),
+            params: {}
+          };
+        } else {
+          parentRoute = {
+            url: new URL(parentRoute.url.href),
+            params: !this.config.mergeParams ? {} : { ...parentRoute.params }
+          };
+        }
+        const pathname = parentRoute.url.pathname;
+        if (pathname === null) {
+          Promise.resolve(new Error("no pathname in request")).then(callback);
+          return;
+        }
+        const method = this.getRequestMethod(request);
+        (0, async_1.eachSeries)(this.handlers, (handler, nextHandler) => {
+          if (handler.method !== method && handler.method !== "*")
+            return nextHandler();
+          const matchResult = handler.matcher(pathname);
+          if (matchResult === false)
+            return nextHandler();
+          const { params, path: matchedPath } = matchResult;
+          const nextInfo = {
+            url: new URL(parentRoute.url.toString()),
+            params: { ...parentRoute.params, ...params }
+          };
+          if (handler.isPrefix) {
+            nextInfo.url.pathname = nextInfo.url.pathname.slice(matchedPath.length) || "/";
+          }
+          (0, async_1.eachSeries)(handler.callbacks, async (fn, nextFn) => {
+            let callbacks = 0;
+            let failed = false;
+            try {
+              await fn(request, nextInfo, (err) => {
+                callbacks++;
+                if (callbacks > 1) {
+                  console.error("Callback called multiple times", callbacks);
+                  console.trace();
+                  return;
+                }
+                if (failed) {
+                  console.error("Callback called after error", callbacks);
+                  console.trace();
+                  return;
+                }
+                nextFn(err);
+              });
+            } catch (e) {
+              if (callbacks > 0) {
+                console.error("Error occured after callback called");
+                console.trace();
+                return;
+              }
+              failed = true;
+              nextFn(e);
+            }
+          }, nextHandler);
+        }, callback);
+      }
+    };
+    exports.GenericRouter = GenericRouter;
+  }
+});
+
+// ../utils/dist/Router/index.js
+var require_Router = __commonJS({
+  "../utils/dist/Router/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_Generic(), exports);
+  }
+});
+
+// ../utils/dist/SimpleMessenger/types.js
+var require_types2 = __commonJS({
+  "../utils/dist/SimpleMessenger/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../utils/dist/SimpleMessenger/request.js
+var require_request2 = __commonJS({
+  "../utils/dist/SimpleMessenger/request.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.handleRequest = handleRequest;
+    exports.makeRequest = makeRequest;
+    var string_1 = require_string();
+    var withResolvers_1 = require_withResolvers();
+    function castRequest(message) {
+      if (typeof message !== "object")
+        return false;
+      if (Array.isArray(message) || message === null)
+        return false;
+      if (!("type" in message) || message.type !== "request")
+        return false;
+      if (!("path" in message) || typeof message.path !== "string")
+        return false;
+      if (!("id" in message) || typeof message.id !== "string")
+        return false;
+      if (!("data" in message))
+        return false;
+      return true;
+    }
+    function handleRequest(messager, path, handler) {
+      messager.onMessage(async (message) => {
+        if (!castRequest(message)) {
+          return console.log("Ignoring Message, Invalid Request Message", message);
+        }
+        const { path: messagePath, id: messageId, data } = message;
+        if (messagePath !== path) {
+          return console.warn("Ignoring Message, different path");
+        }
+        ;
+        try {
+          const result = await handler(data);
+          messager.sendMessage({
+            type: "response",
+            path,
+            id: messageId,
+            responseType: "result",
+            data: result
+          });
+        } catch (e) {
+          if (!(e instanceof Error)) {
+            e = new Error("Unkown Error");
+          }
+          messager.sendMessage({
+            type: "response",
+            path,
+            id: messageId,
+            responseType: "error",
+            data: { message: e.message }
+          });
+        }
+      });
+    }
+    function castResponse(message) {
+      if (typeof message !== "object")
+        return false;
+      if (Array.isArray(message) || message === null)
+        return false;
+      if (!("type" in message) || message.type !== "response")
+        return false;
+      if (!("path" in message) || typeof message.path !== "string")
+        return false;
+      if (!("id" in message) || typeof message.id !== "string")
+        return false;
+      if (!("responseType" in message) || typeof message.responseType !== "string" || ["result", "error"].includes(message.responseType))
+        return false;
+      if (!("data" in message))
+        return false;
+      return true;
+    }
+    function makeRequest(messager, path, data) {
+      const originalId = (0, string_1.uniqueId)();
+      const { resolve, reject, promise } = (0, withResolvers_1.promiseWithResolvers)();
+      const off = messager.onMessage(async (message) => {
+        try {
+          if (!castResponse(message)) {
+            return console.log("Ignoring Message, Invalid Response Message", message);
+          }
+          const { path: messagePath, id: messageId, responseType, data: dataUncasted } = message;
+          if (messagePath !== path) {
+            return console.warn("Ignoring Message, different path");
+          }
+          ;
+          if (originalId !== messageId) {
+            return console.warn("Ignoring Message, different ids");
+          }
+          const data2 = dataUncasted;
+          if (responseType === "error") {
+            throw new ResponseError("Response Failed", data2);
+          }
+          off();
+          resolve(data2);
+        } catch (e) {
+          off();
+          reject(e);
+        }
+      });
+      messager.sendMessage({ type: "request", path, id: originalId, ...data ? { data } : {} });
+      return promise;
+    }
+    var ResponseError = class extends Error {
+      constructor(message, data) {
+        super(message);
+        __publicField(this, "data");
+        this.data = data;
+      }
+    };
+  }
+});
+
+// ../utils/dist/SimpleMessenger/trigger.js
+var require_trigger = __commonJS({
+  "../utils/dist/SimpleMessenger/trigger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.handleTrigger = handleTrigger;
+    exports.makeTrigger = makeTrigger;
+    function castTrigger(message) {
+      if (typeof message !== "object")
+        return false;
+      if (Array.isArray(message) || message === null)
+        return false;
+      if (!("type" in message) || message.type !== "trigger")
+        return false;
+      if (!("path" in message) || typeof message.path !== "string")
+        return false;
+      if (!("data" in message))
+        return false;
+      return true;
+    }
+    function handleTrigger(messager, path, handler) {
+      messager.onMessage(async (message) => {
+        if (!castTrigger(message)) {
+          return console.log("Ignoring Message, Invalid Trigger Message", message);
+        }
+        const { path: messagePath, data } = message;
+        if (messagePath !== path) {
+          return console.warn("Ignoring Message, different path");
+        }
+        ;
+        handler(data);
+      });
+    }
+    function makeTrigger(messager, path, data) {
+      return messager.sendMessage({
+        type: "trigger",
+        path,
+        ...data ? { data } : {}
+      });
+    }
+  }
+});
+
+// ../utils/dist/SimpleMessenger/index.js
+var require_SimpleMessenger = __commonJS({
+  "../utils/dist/SimpleMessenger/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_types2(), exports);
+    __exportStar(require_request2(), exports);
+    __exportStar(require_trigger(), exports);
+  }
+});
+
+// ../utils/dist/tree/index.js
+var require_tree = __commonJS({
+  "../utils/dist/tree/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.treeHasCycle = treeHasCycle;
+    exports.findAllCycles = findAllCycles;
+    exports.getCyclesUsingKey = getCyclesUsingKey;
+    var State;
+    (function(State2) {
+      State2[State2["Unchecked"] = 0] = "Unchecked";
+      State2[State2["Checking"] = 1] = "Checking";
+      State2[State2["NoProblems"] = 2] = "NoProblems";
+    })(State || (State = {}));
+    function treeHasCycle(keys, getRequires) {
+      const checkState = /* @__PURE__ */ new Map();
+      let activeError = null;
+      for (const name of keys) {
+        checkState.set(name, State.Unchecked);
+      }
+      function checkDependencies(name, depChain) {
+        checkState.set(name, State.Checking);
+        depChain.push(name);
+        const requireList = getRequires(name);
+        for (const required of requireList) {
+          if (!checkState.has(required)) {
+            activeError = `Missing required ${required} for ${name}`;
+            return null;
+          }
+          const requiredState = checkState.get(required);
+          if (requiredState === State.NoProblems)
+            continue;
+          if (requiredState === State.Checking) {
+            depChain.push(required);
+            return depChain;
+          }
+          const descendantChain = checkDependencies(required, depChain);
+          if (descendantChain)
+            return descendantChain;
+        }
+        checkState.set(name, State.NoProblems);
+        depChain.pop();
+        return null;
+      }
+      for (const name of keys) {
+        if (checkState.get(name) === State.Unchecked) {
+          const chain = checkDependencies(name, []);
+          if (chain)
+            return chain;
+        }
+        if (activeError)
+          break;
+      }
+      if (activeError)
+        throw new Error(activeError);
+      return null;
+    }
+    var FindAllState;
+    (function(FindAllState2) {
+      FindAllState2[FindAllState2["Unchecked"] = 0] = "Unchecked";
+      FindAllState2[FindAllState2["Checking"] = 1] = "Checking";
+      FindAllState2[FindAllState2["Finished"] = 2] = "Finished";
+    })(FindAllState || (FindAllState = {}));
+    function findAllCycles(keys, getRequires) {
+      const checkState = /* @__PURE__ */ new Map();
+      const cycles = [];
+      let activeError = null;
+      for (const name of keys) {
+        checkState.set(name, FindAllState.Unchecked);
+      }
+      function checkDependencies(name, depChain) {
+        checkState.set(name, FindAllState.Checking);
+        depChain.push(name);
+        const requireList = getRequires(name);
+        for (const required of requireList) {
+          if (!checkState.has(required)) {
+            activeError = `Missing required ${required} for ${name}`;
+            return;
+          }
+          const requiredState = checkState.get(required);
+          if (requiredState === FindAllState.Finished)
+            continue;
+          if (requiredState === FindAllState.Checking) {
+            const newCycle = [...depChain, required];
+            while (newCycle[0] !== newCycle.at(-1))
+              newCycle.shift();
+            cycles.push(newCycle);
+            continue;
+          }
+          checkDependencies(required, depChain);
+          if (activeError)
+            return;
+        }
+        checkState.set(name, FindAllState.Finished);
+        depChain.pop();
+        return;
+      }
+      for (const name of keys) {
+        if (checkState.get(name) === FindAllState.Unchecked) {
+          checkDependencies(name, []);
+        }
+        if (activeError)
+          break;
+      }
+      if (activeError)
+        throw new Error(activeError);
+      return cycles;
+    }
+    function getCyclesUsingKey(key, allCycles) {
+      const pieceCycles = [];
+      for (const cycleMutable of allCycles) {
+        if (!cycleMutable.includes(key))
+          continue;
+        const cycle = [...cycleMutable];
+        if (cycle[0] === key) {
+          pieceCycles.push(cycle);
+          continue;
+        }
+        cycle.shift();
+        while (cycle[0] !== key) {
+          const first = cycle.shift();
+          if (!first)
+            throw new Error("Empty cycle, shouldn't happen");
+          cycle.push(first);
+        }
+        cycle.push(key);
+        pieceCycles.push(cycle);
+      }
+      return pieceCycles;
+    }
+  }
+});
+
+// ../utils/dist/fetch.js
+var require_fetch = __commonJS({
+  "../utils/dist/fetch.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fetchBody = fetchBody;
+    exports.handleFetch = handleFetch;
+    function fetchBody(method, body) {
+      return {
+        method,
+        body: JSON.stringify(body),
+        headers: {
+          "Content-Type": "application/json"
+        }
+      };
+    }
+    async function handleFetch(fetched) {
+      const response = await fetched;
+      const json = await response.json();
+      if (!response.ok) {
+        throw new FetchError("Fetch Failed", response, json);
+      }
+      return json;
+    }
+    var FetchError = class extends Error {
+      constructor(message, response, body) {
+        super(message);
+        __publicField(this, "response");
+        __publicField(this, "body");
+        __publicField(this, "url");
+        __publicField(this, "statusCode");
+        this.response = response;
+        this.body = body;
+        this.url = response.url;
+        this.statusCode = response.status;
+      }
+    };
+  }
+});
+
+// ../utils/dist/index.js
+var require_dist2 = __commonJS({
+  "../utils/dist/index.js"(exports) {
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_array(), exports);
+    __exportStar(require_buffer(), exports);
+    __exportStar(require_crypto(), exports);
+    __exportStar(require_MessageBridge(), exports);
+    __exportStar(require_Promise(), exports);
+    __exportStar(require_Router(), exports);
+    __exportStar(require_SimpleMessenger(), exports);
+    __exportStar(require_tree(), exports);
+    __exportStar(require_async(), exports);
+    __exportStar(require_fetch(), exports);
+    __exportStar(require_JSON(), exports);
+    __exportStar(require_SimpleEvent(), exports);
+    __exportStar(require_string(), exports);
+  }
+});
+
+export {
+  require_dist2 as require_dist
+};
+//# sourceMappingURL=chunk-IIDO6PKU.js.map