topazcube 0.1.18 → 0.1.21

package/dist/server.js

@@ -1,3 +1,1432 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/@roamhq/wrtc/lib/binding.js
+var require_binding = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/binding.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var triple = `${os.platform()}-${os.arch()}`;
+    var pathsToTry = [
+      `../build-${triple}/wrtc.node`,
+      `../build-${triple}/Debug/wrtc.node`,
+      `../build-${triple}/Release/wrtc.node`,
+      `@roamhq/wrtc-${triple}`,
+      // For installations that can't resolve node_modules directly, like AWS Lambda
+      `./node_modules/@roamhq/wrtc-${triple}`,
+      `./node_modules/@roamhq/wrtc-${triple}/wrtc.node`
+    ];
+    var succeeded = false;
+    for (const path of pathsToTry) {
+      try {
+        module.exports = __require(path);
+        succeeded = true;
+        break;
+      } catch (error) {
+        void error;
+      }
+    }
+    if (!succeeded) {
+      throw new Error(
+        `Could not find wrtc binary on any of the paths: ${pathsToTry}`
+      );
+    }
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/eventtarget.js
+var require_eventtarget = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/eventtarget.js"(exports, module) {
+    "use strict";
+    function EventTarget() {
+      this._listeners = {};
+    }
+    EventTarget.prototype.addEventListener = function addEventListener(type, listener) {
+      const listeners = this._listeners = this._listeners || {};
+      if (!listeners[type]) {
+        listeners[type] = /* @__PURE__ */ new Set();
+      }
+      listeners[type].add(listener);
+    };
+    EventTarget.prototype.dispatchEvent = function dispatchEvent(event) {
+      let listeners = this._listeners = this._listeners || {};
+      process.nextTick(() => {
+        listeners = new Set(listeners[event.type] || []);
+        const dummyListener = this["on" + event.type];
+        if (typeof dummyListener === "function") {
+          listeners.add(dummyListener);
+        }
+        listeners.forEach((listener) => {
+          if (typeof listener === "object" && typeof listener.handleEvent === "function") {
+            listener.handleEvent(event);
+          } else {
+            listener.call(this, event);
+          }
+        });
+      });
+    };
+    EventTarget.prototype.removeEventListener = function removeEventListener(type, listener) {
+      const listeners = this._listeners = this._listeners || {};
+      if (listeners[type]) {
+        listeners[type].delete(listener);
+      }
+    };
+    module.exports = EventTarget;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/mediadevices.js
+var require_mediadevices = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/mediadevices.js"(exports, module) {
+    "use strict";
+    var inherits = __require("util").inherits;
+    var { getDisplayMedia, getUserMedia } = require_binding();
+    var EventTarget = require_eventtarget();
+    function MediaDevices() {
+    }
+    inherits(MediaDevices, EventTarget);
+    MediaDevices.prototype.enumerateDevices = function enumerateDevices() {
+      throw new Error(
+        "Not yet implemented; file a feature request against node-webrtc"
+      );
+    };
+    MediaDevices.prototype.getSupportedConstraints = function getSupportedConstraints() {
+      return {
+        width: true,
+        height: true
+      };
+    };
+    MediaDevices.prototype.getDisplayMedia = getDisplayMedia;
+    MediaDevices.prototype.getUserMedia = getUserMedia;
+    module.exports = MediaDevices;
+  }
+});
+
+// node_modules/webidl-conversions/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/webidl-conversions/lib/index.js"(exports) {
+    "use strict";
+    function makeException(ErrorType, message, options) {
+      if (options.globals) {
+        ErrorType = options.globals[ErrorType.name];
+      }
+      return new ErrorType(`${options.context ? options.context : "Value"} ${message}.`);
+    }
+    function toNumber(value, options) {
+      if (typeof value === "bigint") {
+        throw makeException(TypeError, "is a BigInt which cannot be converted to a number", options);
+      }
+      if (!options.globals) {
+        return Number(value);
+      }
+      return options.globals.Number(value);
+    }
+    function evenRound(x) {
+      if (x > 0 && x % 1 === 0.5 && (x & 1) === 0 || x < 0 && x % 1 === -0.5 && (x & 1) === 1) {
+        return censorNegativeZero(Math.floor(x));
+      }
+      return censorNegativeZero(Math.round(x));
+    }
+    function integerPart(n) {
+      return censorNegativeZero(Math.trunc(n));
+    }
+    function sign(x) {
+      return x < 0 ? -1 : 1;
+    }
+    function modulo(x, y) {
+      const signMightNotMatch = x % y;
+      if (sign(y) !== sign(signMightNotMatch)) {
+        return signMightNotMatch + y;
+      }
+      return signMightNotMatch;
+    }
+    function censorNegativeZero(x) {
+      return x === 0 ? 0 : x;
+    }
+    function createIntegerConversion(bitLength, { unsigned }) {
+      let lowerBound, upperBound;
+      if (unsigned) {
+        lowerBound = 0;
+        upperBound = 2 ** bitLength - 1;
+      } else {
+        lowerBound = -(2 ** (bitLength - 1));
+        upperBound = 2 ** (bitLength - 1) - 1;
+      }
+      const twoToTheBitLength = 2 ** bitLength;
+      const twoToOneLessThanTheBitLength = 2 ** (bitLength - 1);
+      return (value, options = {}) => {
+        let x = toNumber(value, options);
+        x = censorNegativeZero(x);
+        if (options.enforceRange) {
+          if (!Number.isFinite(x)) {
+            throw makeException(TypeError, "is not a finite number", options);
+          }
+          x = integerPart(x);
+          if (x < lowerBound || x > upperBound) {
+            throw makeException(
+              TypeError,
+              `is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`,
+              options
+            );
+          }
+          return x;
+        }
+        if (!Number.isNaN(x) && options.clamp) {
+          x = Math.min(Math.max(x, lowerBound), upperBound);
+          x = evenRound(x);
+          return x;
+        }
+        if (!Number.isFinite(x) || x === 0) {
+          return 0;
+        }
+        x = integerPart(x);
+        if (x >= lowerBound && x <= upperBound) {
+          return x;
+        }
+        x = modulo(x, twoToTheBitLength);
+        if (!unsigned && x >= twoToOneLessThanTheBitLength) {
+          return x - twoToTheBitLength;
+        }
+        return x;
+      };
+    }
+    function createLongLongConversion(bitLength, { unsigned }) {
+      const upperBound = Number.MAX_SAFE_INTEGER;
+      const lowerBound = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
+      const asBigIntN = unsigned ? BigInt.asUintN : BigInt.asIntN;
+      return (value, options = {}) => {
+        let x = toNumber(value, options);
+        x = censorNegativeZero(x);
+        if (options.enforceRange) {
+          if (!Number.isFinite(x)) {
+            throw makeException(TypeError, "is not a finite number", options);
+          }
+          x = integerPart(x);
+          if (x < lowerBound || x > upperBound) {
+            throw makeException(
+              TypeError,
+              `is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`,
+              options
+            );
+          }
+          return x;
+        }
+        if (!Number.isNaN(x) && options.clamp) {
+          x = Math.min(Math.max(x, lowerBound), upperBound);
+          x = evenRound(x);
+          return x;
+        }
+        if (!Number.isFinite(x) || x === 0) {
+          return 0;
+        }
+        let xBigInt = BigInt(integerPart(x));
+        xBigInt = asBigIntN(bitLength, xBigInt);
+        return Number(xBigInt);
+      };
+    }
+    exports.any = (value) => {
+      return value;
+    };
+    exports.undefined = () => {
+      return void 0;
+    };
+    exports.boolean = (value) => {
+      return Boolean(value);
+    };
+    exports.byte = createIntegerConversion(8, { unsigned: false });
+    exports.octet = createIntegerConversion(8, { unsigned: true });
+    exports.short = createIntegerConversion(16, { unsigned: false });
+    exports["unsigned short"] = createIntegerConversion(16, { unsigned: true });
+    exports.long = createIntegerConversion(32, { unsigned: false });
+    exports["unsigned long"] = createIntegerConversion(32, { unsigned: true });
+    exports["long long"] = createLongLongConversion(64, { unsigned: false });
+    exports["unsigned long long"] = createLongLongConversion(64, { unsigned: true });
+    exports.double = (value, options = {}) => {
+      const x = toNumber(value, options);
+      if (!Number.isFinite(x)) {
+        throw makeException(TypeError, "is not a finite floating-point value", options);
+      }
+      return x;
+    };
+    exports["unrestricted double"] = (value, options = {}) => {
+      const x = toNumber(value, options);
+      return x;
+    };
+    exports.float = (value, options = {}) => {
+      const x = toNumber(value, options);
+      if (!Number.isFinite(x)) {
+        throw makeException(TypeError, "is not a finite floating-point value", options);
+      }
+      if (Object.is(x, -0)) {
+        return x;
+      }
+      const y = Math.fround(x);
+      if (!Number.isFinite(y)) {
+        throw makeException(TypeError, "is outside the range of a single-precision floating-point value", options);
+      }
+      return y;
+    };
+    exports["unrestricted float"] = (value, options = {}) => {
+      const x = toNumber(value, options);
+      if (isNaN(x)) {
+        return x;
+      }
+      if (Object.is(x, -0)) {
+        return x;
+      }
+      return Math.fround(x);
+    };
+    exports.DOMString = (value, options = {}) => {
+      if (options.treatNullAsEmptyString && value === null) {
+        return "";
+      }
+      if (typeof value === "symbol") {
+        throw makeException(TypeError, "is a symbol, which cannot be converted to a string", options);
+      }
+      const StringCtor = options.globals ? options.globals.String : String;
+      return StringCtor(value);
+    };
+    exports.ByteString = (value, options = {}) => {
+      const x = exports.DOMString(value, options);
+      let c;
+      for (let i = 0; (c = x.codePointAt(i)) !== void 0; ++i) {
+        if (c > 255) {
+          throw makeException(TypeError, "is not a valid ByteString", options);
+        }
+      }
+      return x;
+    };
+    exports.USVString = (value, options = {}) => {
+      const S = exports.DOMString(value, options);
+      const n = S.length;
+      const U = [];
+      for (let i = 0; i < n; ++i) {
+        const c = S.charCodeAt(i);
+        if (c < 55296 || c > 57343) {
+          U.push(String.fromCodePoint(c));
+        } else if (56320 <= c && c <= 57343) {
+          U.push(String.fromCodePoint(65533));
+        } else if (i === n - 1) {
+          U.push(String.fromCodePoint(65533));
+        } else {
+          const d = S.charCodeAt(i + 1);
+          if (56320 <= d && d <= 57343) {
+            const a = c & 1023;
+            const b = d & 1023;
+            U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b));
+            ++i;
+          } else {
+            U.push(String.fromCodePoint(65533));
+          }
+        }
+      }
+      return U.join("");
+    };
+    exports.object = (value, options = {}) => {
+      if (value === null || typeof value !== "object" && typeof value !== "function") {
+        throw makeException(TypeError, "is not an object", options);
+      }
+      return value;
+    };
+    var abByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+    var sabByteLengthGetter = typeof SharedArrayBuffer === "function" ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get : null;
+    function isNonSharedArrayBuffer(value) {
+      try {
+        abByteLengthGetter.call(value);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function isSharedArrayBuffer(value) {
+      try {
+        sabByteLengthGetter.call(value);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    function isArrayBufferDetached(value) {
+      try {
+        new Uint8Array(value);
+        return false;
+      } catch {
+        return true;
+      }
+    }
+    exports.ArrayBuffer = (value, options = {}) => {
+      if (!isNonSharedArrayBuffer(value)) {
+        if (options.allowShared && !isSharedArrayBuffer(value)) {
+          throw makeException(TypeError, "is not an ArrayBuffer or SharedArrayBuffer", options);
+        }
+        throw makeException(TypeError, "is not an ArrayBuffer", options);
+      }
+      if (isArrayBufferDetached(value)) {
+        throw makeException(TypeError, "is a detached ArrayBuffer", options);
+      }
+      return value;
+    };
+    var dvByteLengthGetter = Object.getOwnPropertyDescriptor(DataView.prototype, "byteLength").get;
+    exports.DataView = (value, options = {}) => {
+      try {
+        dvByteLengthGetter.call(value);
+      } catch (e) {
+        throw makeException(TypeError, "is not a DataView", options);
+      }
+      if (!options.allowShared && isSharedArrayBuffer(value.buffer)) {
+        throw makeException(TypeError, "is backed by a SharedArrayBuffer, which is not allowed", options);
+      }
+      if (isArrayBufferDetached(value.buffer)) {
+        throw makeException(TypeError, "is backed by a detached ArrayBuffer", options);
+      }
+      return value;
+    };
+    var typedArrayNameGetter = Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(Uint8Array).prototype,
+      Symbol.toStringTag
+    ).get;
+    [
+      Int8Array,
+      Int16Array,
+      Int32Array,
+      Uint8Array,
+      Uint16Array,
+      Uint32Array,
+      Uint8ClampedArray,
+      Float32Array,
+      Float64Array
+    ].forEach((func) => {
+      const { name } = func;
+      const article = /^[AEIOU]/u.test(name) ? "an" : "a";
+      exports[name] = (value, options = {}) => {
+        if (!ArrayBuffer.isView(value) || typedArrayNameGetter.call(value) !== name) {
+          throw makeException(TypeError, `is not ${article} ${name} object`, options);
+        }
+        if (!options.allowShared && isSharedArrayBuffer(value.buffer)) {
+          throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", options);
+        }
+        if (isArrayBufferDetached(value.buffer)) {
+          throw makeException(TypeError, "is a view on a detached ArrayBuffer", options);
+        }
+        return value;
+      };
+    });
+    exports.ArrayBufferView = (value, options = {}) => {
+      if (!ArrayBuffer.isView(value)) {
+        throw makeException(TypeError, "is not a view on an ArrayBuffer or SharedArrayBuffer", options);
+      }
+      if (!options.allowShared && isSharedArrayBuffer(value.buffer)) {
+        throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", options);
+      }
+      if (isArrayBufferDetached(value.buffer)) {
+        throw makeException(TypeError, "is a view on a detached ArrayBuffer", options);
+      }
+      return value;
+    };
+    exports.BufferSource = (value, options = {}) => {
+      if (ArrayBuffer.isView(value)) {
+        if (!options.allowShared && isSharedArrayBuffer(value.buffer)) {
+          throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", options);
+        }
+        if (isArrayBufferDetached(value.buffer)) {
+          throw makeException(TypeError, "is a view on a detached ArrayBuffer", options);
+        }
+        return value;
+      }
+      if (!options.allowShared && !isNonSharedArrayBuffer(value)) {
+        throw makeException(TypeError, "is not an ArrayBuffer or a view on one", options);
+      }
+      if (options.allowShared && !isSharedArrayBuffer(value) && !isNonSharedArrayBuffer(value)) {
+        throw makeException(TypeError, "is not an ArrayBuffer, SharedArrayBuffer, or a view on one", options);
+      }
+      if (isArrayBufferDetached(value)) {
+        throw makeException(TypeError, "is a detached ArrayBuffer", options);
+      }
+      return value;
+    };
+    exports.DOMTimeStamp = exports["unsigned long long"];
+  }
+});
+
+// node_modules/domexception/lib/utils.js
+var require_utils = __commonJS({
+  "node_modules/domexception/lib/utils.js"(exports, module) {
+    "use strict";
+    function isObject(value) {
+      return typeof value === "object" && value !== null || typeof value === "function";
+    }
+    var hasOwn = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
+    function define(target, source) {
+      for (const key of Reflect.ownKeys(source)) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+        if (descriptor && !Reflect.defineProperty(target, key, descriptor)) {
+          throw new TypeError(`Cannot redefine property: ${String(key)}`);
+        }
+      }
+    }
+    function newObjectInRealm(globalObject, object) {
+      const ctorRegistry = initCtorRegistry(globalObject);
+      return Object.defineProperties(
+        Object.create(ctorRegistry["%Object.prototype%"]),
+        Object.getOwnPropertyDescriptors(object)
+      );
+    }
+    var wrapperSymbol = Symbol("wrapper");
+    var implSymbol = Symbol("impl");
+    var sameObjectCaches = Symbol("SameObject caches");
+    var ctorRegistrySymbol = Symbol.for("[webidl2js] constructor registry");
+    var AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
+    }).prototype);
+    function initCtorRegistry(globalObject) {
+      if (hasOwn(globalObject, ctorRegistrySymbol)) {
+        return globalObject[ctorRegistrySymbol];
+      }
+      const ctorRegistry = /* @__PURE__ */ Object.create(null);
+      ctorRegistry["%Object.prototype%"] = globalObject.Object.prototype;
+      ctorRegistry["%IteratorPrototype%"] = Object.getPrototypeOf(
+        Object.getPrototypeOf(new globalObject.Array()[Symbol.iterator]())
+      );
+      try {
+        ctorRegistry["%AsyncIteratorPrototype%"] = Object.getPrototypeOf(
+          Object.getPrototypeOf(
+            globalObject.eval("(async function* () {})").prototype
+          )
+        );
+      } catch {
+        ctorRegistry["%AsyncIteratorPrototype%"] = AsyncIteratorPrototype;
+      }
+      globalObject[ctorRegistrySymbol] = ctorRegistry;
+      return ctorRegistry;
+    }
+    function getSameObject(wrapper, prop, creator) {
+      if (!wrapper[sameObjectCaches]) {
+        wrapper[sameObjectCaches] = /* @__PURE__ */ Object.create(null);
+      }
+      if (prop in wrapper[sameObjectCaches]) {
+        return wrapper[sameObjectCaches][prop];
+      }
+      wrapper[sameObjectCaches][prop] = creator();
+      return wrapper[sameObjectCaches][prop];
+    }
+    function wrapperForImpl(impl) {
+      return impl ? impl[wrapperSymbol] : null;
+    }
+    function implForWrapper(wrapper) {
+      return wrapper ? wrapper[implSymbol] : null;
+    }
+    function tryWrapperForImpl(impl) {
+      const wrapper = wrapperForImpl(impl);
+      return wrapper ? wrapper : impl;
+    }
+    function tryImplForWrapper(wrapper) {
+      const impl = implForWrapper(wrapper);
+      return impl ? impl : wrapper;
+    }
+    var iterInternalSymbol = Symbol("internal");
+    function isArrayIndexPropName(P) {
+      if (typeof P !== "string") {
+        return false;
+      }
+      const i = P >>> 0;
+      if (i === 2 ** 32 - 1) {
+        return false;
+      }
+      const s = `${i}`;
+      if (P !== s) {
+        return false;
+      }
+      return true;
+    }
+    var byteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
+    function isArrayBuffer(value) {
+      try {
+        byteLengthGetter.call(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    function iteratorResult([key, value], kind) {
+      let result;
+      switch (kind) {
+        case "key":
+          result = key;
+          break;
+        case "value":
+          result = value;
+          break;
+        case "key+value":
+          result = [key, value];
+          break;
+      }
+      return { value: result, done: false };
+    }
+    var supportsPropertyIndex = Symbol("supports property index");
+    var supportedPropertyIndices = Symbol("supported property indices");
+    var supportsPropertyName = Symbol("supports property name");
+    var supportedPropertyNames = Symbol("supported property names");
+    var indexedGet = Symbol("indexed property get");
+    var indexedSetNew = Symbol("indexed property set new");
+    var indexedSetExisting = Symbol("indexed property set existing");
+    var namedGet = Symbol("named property get");
+    var namedSetNew = Symbol("named property set new");
+    var namedSetExisting = Symbol("named property set existing");
+    var namedDelete = Symbol("named property delete");
+    var asyncIteratorNext = Symbol("async iterator get the next iteration result");
+    var asyncIteratorReturn = Symbol("async iterator return steps");
+    var asyncIteratorInit = Symbol("async iterator initialization steps");
+    var asyncIteratorEOI = Symbol("async iterator end of iteration");
+    module.exports = exports = {
+      isObject,
+      hasOwn,
+      define,
+      newObjectInRealm,
+      wrapperSymbol,
+      implSymbol,
+      getSameObject,
+      ctorRegistrySymbol,
+      initCtorRegistry,
+      wrapperForImpl,
+      implForWrapper,
+      tryWrapperForImpl,
+      tryImplForWrapper,
+      iterInternalSymbol,
+      isArrayBuffer,
+      isArrayIndexPropName,
+      supportsPropertyIndex,
+      supportedPropertyIndices,
+      supportsPropertyName,
+      supportedPropertyNames,
+      indexedGet,
+      indexedSetNew,
+      indexedSetExisting,
+      namedGet,
+      namedSetNew,
+      namedSetExisting,
+      namedDelete,
+      asyncIteratorNext,
+      asyncIteratorReturn,
+      asyncIteratorInit,
+      asyncIteratorEOI,
+      iteratorResult
+    };
+  }
+});
+
+// node_modules/domexception/lib/legacy-error-codes.json
+var require_legacy_error_codes = __commonJS({
+  "node_modules/domexception/lib/legacy-error-codes.json"(exports, module) {
+    module.exports = {
+      IndexSizeError: 1,
+      HierarchyRequestError: 3,
+      WrongDocumentError: 4,
+      InvalidCharacterError: 5,
+      NoModificationAllowedError: 7,
+      NotFoundError: 8,
+      NotSupportedError: 9,
+      InUseAttributeError: 10,
+      InvalidStateError: 11,
+      SyntaxError: 12,
+      InvalidModificationError: 13,
+      NamespaceError: 14,
+      InvalidAccessError: 15,
+      TypeMismatchError: 17,
+      SecurityError: 18,
+      NetworkError: 19,
+      AbortError: 20,
+      URLMismatchError: 21,
+      QuotaExceededError: 22,
+      TimeoutError: 23,
+      InvalidNodeTypeError: 24,
+      DataCloneError: 25
+    };
+  }
+});
+
+// node_modules/domexception/lib/DOMException-impl.js
+var require_DOMException_impl = __commonJS({
+  "node_modules/domexception/lib/DOMException-impl.js"(exports) {
+    "use strict";
+    var legacyErrorCodes = require_legacy_error_codes();
+    var idlUtils = require_utils();
+    exports.implementation = class DOMExceptionImpl {
+      constructor(globalObject, [message, name]) {
+        this.name = name;
+        this.message = message;
+      }
+      get code() {
+        return legacyErrorCodes[this.name] || 0;
+      }
+    };
+    exports.init = (impl) => {
+      if (Error.captureStackTrace) {
+        const wrapper = idlUtils.wrapperForImpl(impl);
+        Error.captureStackTrace(wrapper, wrapper.constructor);
+      }
+    };
+  }
+});
+
+// node_modules/domexception/lib/DOMException.js
+var require_DOMException = __commonJS({
+  "node_modules/domexception/lib/DOMException.js"(exports) {
+    "use strict";
+    var conversions = require_lib();
+    var utils = require_utils();
+    var implSymbol = utils.implSymbol;
+    var ctorRegistrySymbol = utils.ctorRegistrySymbol;
+    var interfaceName = "DOMException";
+    exports.is = (value) => {
+      return utils.isObject(value) && utils.hasOwn(value, implSymbol) && value[implSymbol] instanceof Impl.implementation;
+    };
+    exports.isImpl = (value) => {
+      return utils.isObject(value) && value instanceof Impl.implementation;
+    };
+    exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
+      if (exports.is(value)) {
+        return utils.implForWrapper(value);
+      }
+      throw new globalObject.TypeError(`${context} is not of type 'DOMException'.`);
+    };
+    function makeWrapper(globalObject, newTarget) {
+      let proto;
+      if (newTarget !== void 0) {
+        proto = newTarget.prototype;
+      }
+      if (!utils.isObject(proto)) {
+        proto = globalObject[ctorRegistrySymbol]["DOMException"].prototype;
+      }
+      return Object.create(proto);
+    }
+    exports.create = (globalObject, constructorArgs, privateData) => {
+      const wrapper = makeWrapper(globalObject);
+      return exports.setup(wrapper, globalObject, constructorArgs, privateData);
+    };
+    exports.createImpl = (globalObject, constructorArgs, privateData) => {
+      const wrapper = exports.create(globalObject, constructorArgs, privateData);
+      return utils.implForWrapper(wrapper);
+    };
+    exports._internalSetup = (wrapper, globalObject) => {
+    };
+    exports.setup = (wrapper, globalObject, constructorArgs = [], privateData = {}) => {
+      privateData.wrapper = wrapper;
+      exports._internalSetup(wrapper, globalObject);
+      Object.defineProperty(wrapper, implSymbol, {
+        value: new Impl.implementation(globalObject, constructorArgs, privateData),
+        configurable: true
+      });
+      wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+      if (Impl.init) {
+        Impl.init(wrapper[implSymbol]);
+      }
+      return wrapper;
+    };
+    exports.new = (globalObject, newTarget) => {
+      const wrapper = makeWrapper(globalObject, newTarget);
+      exports._internalSetup(wrapper, globalObject);
+      Object.defineProperty(wrapper, implSymbol, {
+        value: Object.create(Impl.implementation.prototype),
+        configurable: true
+      });
+      wrapper[implSymbol][utils.wrapperSymbol] = wrapper;
+      if (Impl.init) {
+        Impl.init(wrapper[implSymbol]);
+      }
+      return wrapper[implSymbol];
+    };
+    var exposed = /* @__PURE__ */ new Set(["Window", "Worker"]);
+    exports.install = (globalObject, globalNames) => {
+      if (!globalNames.some((globalName) => exposed.has(globalName))) {
+        return;
+      }
+      const ctorRegistry = utils.initCtorRegistry(globalObject);
+      class DOMException {
+        constructor() {
+          const args = [];
+          {
+            let curArg = arguments[0];
+            if (curArg !== void 0) {
+              curArg = conversions["DOMString"](curArg, {
+                context: "Failed to construct 'DOMException': parameter 1",
+                globals: globalObject
+              });
+            } else {
+              curArg = "";
+            }
+            args.push(curArg);
+          }
+          {
+            let curArg = arguments[1];
+            if (curArg !== void 0) {
+              curArg = conversions["DOMString"](curArg, {
+                context: "Failed to construct 'DOMException': parameter 2",
+                globals: globalObject
+              });
+            } else {
+              curArg = "Error";
+            }
+            args.push(curArg);
+          }
+          return exports.setup(Object.create(new.target.prototype), globalObject, args);
+        }
+        get name() {
+          const esValue = this !== null && this !== void 0 ? this : globalObject;
+          if (!exports.is(esValue)) {
+            throw new globalObject.TypeError(
+              "'get name' called on an object that is not a valid instance of DOMException."
+            );
+          }
+          return esValue[implSymbol]["name"];
+        }
+        get message() {
+          const esValue = this !== null && this !== void 0 ? this : globalObject;
+          if (!exports.is(esValue)) {
+            throw new globalObject.TypeError(
+              "'get message' called on an object that is not a valid instance of DOMException."
+            );
+          }
+          return esValue[implSymbol]["message"];
+        }
+        get code() {
+          const esValue = this !== null && this !== void 0 ? this : globalObject;
+          if (!exports.is(esValue)) {
+            throw new globalObject.TypeError(
+              "'get code' called on an object that is not a valid instance of DOMException."
+            );
+          }
+          return esValue[implSymbol]["code"];
+        }
+      }
+      Object.defineProperties(DOMException.prototype, {
+        name: { enumerable: true },
+        message: { enumerable: true },
+        code: { enumerable: true },
+        [Symbol.toStringTag]: { value: "DOMException", configurable: true },
+        INDEX_SIZE_ERR: { value: 1, enumerable: true },
+        DOMSTRING_SIZE_ERR: { value: 2, enumerable: true },
+        HIERARCHY_REQUEST_ERR: { value: 3, enumerable: true },
+        WRONG_DOCUMENT_ERR: { value: 4, enumerable: true },
+        INVALID_CHARACTER_ERR: { value: 5, enumerable: true },
+        NO_DATA_ALLOWED_ERR: { value: 6, enumerable: true },
+        NO_MODIFICATION_ALLOWED_ERR: { value: 7, enumerable: true },
+        NOT_FOUND_ERR: { value: 8, enumerable: true },
+        NOT_SUPPORTED_ERR: { value: 9, enumerable: true },
+        INUSE_ATTRIBUTE_ERR: { value: 10, enumerable: true },
+        INVALID_STATE_ERR: { value: 11, enumerable: true },
+        SYNTAX_ERR: { value: 12, enumerable: true },
+        INVALID_MODIFICATION_ERR: { value: 13, enumerable: true },
+        NAMESPACE_ERR: { value: 14, enumerable: true },
+        INVALID_ACCESS_ERR: { value: 15, enumerable: true },
+        VALIDATION_ERR: { value: 16, enumerable: true },
+        TYPE_MISMATCH_ERR: { value: 17, enumerable: true },
+        SECURITY_ERR: { value: 18, enumerable: true },
+        NETWORK_ERR: { value: 19, enumerable: true },
+        ABORT_ERR: { value: 20, enumerable: true },
+        URL_MISMATCH_ERR: { value: 21, enumerable: true },
+        QUOTA_EXCEEDED_ERR: { value: 22, enumerable: true },
+        TIMEOUT_ERR: { value: 23, enumerable: true },
+        INVALID_NODE_TYPE_ERR: { value: 24, enumerable: true },
+        DATA_CLONE_ERR: { value: 25, enumerable: true }
+      });
+      Object.defineProperties(DOMException, {
+        INDEX_SIZE_ERR: { value: 1, enumerable: true },
+        DOMSTRING_SIZE_ERR: { value: 2, enumerable: true },
+        HIERARCHY_REQUEST_ERR: { value: 3, enumerable: true },
+        WRONG_DOCUMENT_ERR: { value: 4, enumerable: true },
+        INVALID_CHARACTER_ERR: { value: 5, enumerable: true },
+        NO_DATA_ALLOWED_ERR: { value: 6, enumerable: true },
+        NO_MODIFICATION_ALLOWED_ERR: { value: 7, enumerable: true },
+        NOT_FOUND_ERR: { value: 8, enumerable: true },
+        NOT_SUPPORTED_ERR: { value: 9, enumerable: true },
+        INUSE_ATTRIBUTE_ERR: { value: 10, enumerable: true },
+        INVALID_STATE_ERR: { value: 11, enumerable: true },
+        SYNTAX_ERR: { value: 12, enumerable: true },
+        INVALID_MODIFICATION_ERR: { value: 13, enumerable: true },
+        NAMESPACE_ERR: { value: 14, enumerable: true },
+        INVALID_ACCESS_ERR: { value: 15, enumerable: true },
+        VALIDATION_ERR: { value: 16, enumerable: true },
+        TYPE_MISMATCH_ERR: { value: 17, enumerable: true },
+        SECURITY_ERR: { value: 18, enumerable: true },
+        NETWORK_ERR: { value: 19, enumerable: true },
+        ABORT_ERR: { value: 20, enumerable: true },
+        URL_MISMATCH_ERR: { value: 21, enumerable: true },
+        QUOTA_EXCEEDED_ERR: { value: 22, enumerable: true },
+        TIMEOUT_ERR: { value: 23, enumerable: true },
+        INVALID_NODE_TYPE_ERR: { value: 24, enumerable: true },
+        DATA_CLONE_ERR: { value: 25, enumerable: true }
+      });
+      ctorRegistry[interfaceName] = DOMException;
+      Object.defineProperty(globalObject, interfaceName, {
+        configurable: true,
+        writable: true,
+        value: DOMException
+      });
+    };
+    var Impl = require_DOMException_impl();
+  }
+});
+
+// node_modules/domexception/webidl2js-wrapper.js
+var require_webidl2js_wrapper = __commonJS({
+  "node_modules/domexception/webidl2js-wrapper.js"(exports, module) {
+    "use strict";
+    var DOMException = require_DOMException();
+    function installOverride(globalObject, globalNames) {
+      if (typeof globalObject.Error !== "function") {
+        throw new Error("Internal error: Error constructor is not present on the given global object.");
+      }
+      DOMException.install(globalObject, globalNames);
+      Object.setPrototypeOf(globalObject.DOMException.prototype, globalObject.Error.prototype);
+    }
+    module.exports = { ...DOMException, install: installOverride };
+  }
+});
+
+// node_modules/domexception/index.js
+var require_domexception = __commonJS({
+  "node_modules/domexception/index.js"(exports, module) {
+    "use strict";
+    var DOMException = require_webidl2js_wrapper();
+    var sharedGlobalObject = { Array, Error, Object, Promise, String, TypeError };
+    DOMException.install(sharedGlobalObject, ["Window"]);
+    module.exports = sharedGlobalObject.DOMException;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/datachannelevent.js
+var require_datachannelevent = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/datachannelevent.js"(exports, module) {
+    "use strict";
+    function RTCDataChannelEvent(type, eventInitDict) {
+      Object.defineProperties(this, {
+        bubbles: {
+          value: false
+        },
+        cancelable: {
+          value: false
+        },
+        type: {
+          value: type,
+          enumerable: true
+        },
+        channel: {
+          value: eventInitDict.channel,
+          enumerable: true
+        },
+        target: {
+          value: eventInitDict.target,
+          enumerable: true
+        }
+      });
+    }
+    module.exports = RTCDataChannelEvent;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/icecandidate.js
+var require_icecandidate = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/icecandidate.js"(exports, module) {
+    "use strict";
+    function RTCIceCandidate(candidateInitDict) {
+      [
+        "candidate",
+        "sdpMid",
+        "sdpMLineIndex",
+        "foundation",
+        "component",
+        "priority",
+        "address",
+        "protocol",
+        "port",
+        "type",
+        "tcpType",
+        "relatedAddress",
+        "relatedPort",
+        "usernameFragment"
+      ].forEach((property) => {
+        if (candidateInitDict && property in candidateInitDict) {
+          this[property] = candidateInitDict[property];
+        } else {
+          this[property] = null;
+        }
+      });
+      this.toJSON = () => {
+        const { candidate, sdpMid, sdpMLineIndex, usernameFragment } = this;
+        let json = {
+          candidate,
+          sdpMid,
+          sdpMLineIndex
+        };
+        if (usernameFragment) {
+          json.usernameFragment = usernameFragment;
+        }
+        return json;
+      };
+    }
+    module.exports = RTCIceCandidate;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/rtcpeerconnectioniceevent.js
+var require_rtcpeerconnectioniceevent = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/rtcpeerconnectioniceevent.js"(exports, module) {
+    "use strict";
+    function RTCPeerConnectionIceEvent(type, eventInitDict) {
+      Object.defineProperties(this, {
+        type: {
+          value: type,
+          enumerable: true
+        },
+        candidate: {
+          value: eventInitDict.candidate,
+          enumerable: true
+        },
+        target: {
+          value: eventInitDict.target,
+          enumerable: true
+        }
+      });
+    }
+    module.exports = RTCPeerConnectionIceEvent;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/rtcpeerconnectioniceerrorevent.js
+var require_rtcpeerconnectioniceerrorevent = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/rtcpeerconnectioniceerrorevent.js"(exports, module) {
+    "use strict";
+    function RTCPeerConnectionIceErrorEvent(type, eventInitDict) {
+      Object.defineProperties(this, {
+        type: {
+          value: type,
+          enumerable: true
+        },
+        address: {
+          value: eventInitDict.address,
+          enumerable: true
+        },
+        port: {
+          value: eventInitDict.port,
+          enumerable: true
+        },
+        url: {
+          value: eventInitDict.url,
+          enumerable: true
+        },
+        errorCode: {
+          value: eventInitDict.errorCode,
+          enumerable: true
+        },
+        errorText: {
+          value: eventInitDict.errorText,
+          enumerable: true
+        },
+        target: {
+          value: eventInitDict.target,
+          enumerable: true
+        }
+      });
+    }
+    module.exports = RTCPeerConnectionIceErrorEvent;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/sessiondescription.js
+var require_sessiondescription = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/sessiondescription.js"(exports, module) {
+    "use strict";
+    function RTCSessionDescription(descriptionInitDict) {
+      if (descriptionInitDict) {
+        this.type = descriptionInitDict.type;
+        this.sdp = descriptionInitDict.sdp;
+      }
+      this.toJSON = () => {
+        const { sdp, type } = this;
+        return {
+          sdp,
+          type
+        };
+      };
+    }
+    module.exports = RTCSessionDescription;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/peerconnection.js
+var require_peerconnection = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/peerconnection.js"(exports, module) {
+    "use strict";
+    var inherits = __require("util").inherits;
+    var _webrtc = require_binding();
+    var EventTarget = require_eventtarget();
+    var RTCDataChannelEvent = require_datachannelevent();
+    var RTCIceCandidate = require_icecandidate();
+    var RTCPeerConnectionIceEvent = require_rtcpeerconnectioniceevent();
+    var RTCPeerConnectionIceErrorEvent = require_rtcpeerconnectioniceerrorevent();
+    var RTCSessionDescription = require_sessiondescription();
+    function RTCPeerConnection() {
+      var self = this;
+      var pc = new _webrtc.RTCPeerConnection(arguments[0] || {});
+      EventTarget.call(this);
+      pc.ontrack = function ontrack(receiver, streams, transceiver) {
+        self.dispatchEvent({
+          type: "track",
+          track: receiver.track,
+          receiver,
+          streams,
+          transceiver,
+          target: self
+        });
+      };
+      pc.onconnectionstatechange = function onconnectionstatechange() {
+        self.dispatchEvent({ type: "connectionstatechange", target: self });
+      };
+      pc.onicecandidate = function onicecandidate(candidate) {
+        var icecandidate = new RTCIceCandidate(candidate);
+        self.dispatchEvent(
+          new RTCPeerConnectionIceEvent("icecandidate", {
+            candidate: icecandidate,
+            target: self
+          })
+        );
+      };
+      pc.onicecandidateerror = function onicecandidateerror(eventInitDict) {
+        eventInitDict.target = self;
+        var icecandidateerror = new RTCPeerConnectionIceErrorEvent(
+          "icecandidateerror",
+          eventInitDict
+        );
+        self.dispatchEvent(icecandidateerror);
+      };
+      pc.onsignalingstatechange = function onsignalingstatechange() {
+        self.dispatchEvent({ type: "signalingstatechange", target: self });
+      };
+      pc.oniceconnectionstatechange = function oniceconnectionstatechange() {
+        self.dispatchEvent({ type: "iceconnectionstatechange", target: self });
+      };
+      pc.onicegatheringstatechange = function onicegatheringstatechange() {
+        self.dispatchEvent({ type: "icegatheringstatechange", target: self });
+        if (self.iceGatheringState === "complete" && self.connectionState !== "closed") {
+          self.dispatchEvent(
+            new RTCPeerConnectionIceEvent("icecandidate", {
+              candidate: null,
+              target: self
+            })
+          );
+        }
+      };
+      pc.onnegotiationneeded = function onnegotiationneeded() {
+        self.dispatchEvent({ type: "negotiationneeded", target: self });
+      };
+      pc.ondatachannel = function ondatachannel(channel) {
+        self.dispatchEvent(
+          new RTCDataChannelEvent("datachannel", { channel, target: self })
+        );
+      };
+      Object.defineProperties(this, {
+        _pc: {
+          value: pc
+        },
+        canTrickleIceCandidates: {
+          get: function getCanTrickleIceCandidates() {
+            return pc.canTrickleIceCandidates;
+          },
+          enumerable: true
+        },
+        connectionState: {
+          get: function getConnectionState() {
+            return pc.connectionState;
+          },
+          enumerable: true
+        },
+        currentLocalDescription: {
+          get: function getCurrentLocalDescription() {
+            return pc.currentLocalDescription ? new RTCSessionDescription(pc.currentLocalDescription) : null;
+          },
+          enumerable: true
+        },
+        localDescription: {
+          get: function getLocalDescription() {
+            return pc.localDescription ? new RTCSessionDescription(pc.localDescription) : null;
+          },
+          enumerable: true
+        },
+        pendingLocalDescription: {
+          get: function getPendingLocalDescription() {
+            return pc.pendingLocalDescription ? new RTCSessionDescription(pc.pendingLocalDescription) : null;
+          },
+          enumerable: true
+        },
+        currentRemoteDescription: {
+          get: function getCurrentRemoteDescription() {
+            return pc.currentRemoteDescription ? new RTCSessionDescription(pc.currentRemoteDescription) : null;
+          },
+          enumerable: true
+        },
+        remoteDescription: {
+          get: function getRemoteDescription() {
+            return pc.remoteDescription ? new RTCSessionDescription(pc.remoteDescription) : null;
+          },
+          enumerable: true
+        },
+        pendingRemoteDescription: {
+          get: function getPendingRemoteDescription() {
+            return pc.pendingRemoteDescription ? new RTCSessionDescription(pc.pendingRemoteDescription) : null;
+          },
+          enumerable: true
+        },
+        signalingState: {
+          get: function getSignalingState() {
+            return pc.signalingState;
+          },
+          enumerable: true
+        },
+        readyState: {
+          get: function getReadyState() {
+            return pc.getReadyState();
+          }
+        },
+        sctp: {
+          get: function() {
+            return pc.sctp;
+          },
+          enumerable: true
+        },
+        iceGatheringState: {
+          get: function getIceGatheringState() {
+            return pc.iceGatheringState;
+          },
+          enumerable: true
+        },
+        iceConnectionState: {
+          get: function getIceConnectionState() {
+            return pc.iceConnectionState;
+          },
+          enumerable: true
+        },
+        onconnectionstatechange: {
+          value: null,
+          writable: true,
+          enumerable: true
+        },
+        ondatachannel: {
+          value: null,
+          writable: true,
+          enumerable: true
+        },
+        oniceconnectionstatechange: {
+          value: null,
+          writable: true,
+          enumerable: true
+        },
+        onicegatheringstatechange: {
+          value: null,
+          writable: true,
+          enumerable: true
+        },
+        onnegotiationneeded: {
+          value: null,
+          writable: true,
+          enumerable: true
+        },
+        onsignalingstatechange: {
+          value: null,
+          writable: true,
+          enumerable: true
+        }
+      });
+    }
+    inherits(RTCPeerConnection, EventTarget);
+    RTCPeerConnection.prototype.ontrack = null;
+    RTCPeerConnection.prototype.addIceCandidate = function addIceCandidate(candidate) {
+      if (!candidate?.candidate) {
+        candidate = void 0;
+      }
+      var promise = this._pc.addIceCandidate(candidate);
+      if (arguments.length === 3) {
+        promise.then(arguments[1], arguments[2]);
+      }
+      return promise;
+    };
+    RTCPeerConnection.prototype.addTransceiver = function addTransceiver() {
+      return this._pc.addTransceiver.apply(this._pc, arguments);
+    };
+    RTCPeerConnection.prototype.addTrack = function addTrack(track, ...streams) {
+      return this._pc.addTrack(track, streams);
+    };
+    RTCPeerConnection.prototype.close = function close() {
+      this._pc.close();
+    };
+    RTCPeerConnection.prototype.createDataChannel = function createDataChannel() {
+      return this._pc.createDataChannel.apply(this._pc, arguments);
+    };
+    RTCPeerConnection.prototype.createOffer = function createOffer() {
+      var options = arguments.length === 3 ? arguments[2] : arguments[0];
+      var promise = this._pc.createOffer(options || {});
+      if (arguments.length >= 2) {
+        promise.then(arguments[0], arguments[1]);
+      }
+      return promise;
+    };
+    RTCPeerConnection.prototype.createAnswer = function createAnswer() {
+      var options = arguments.length === 3 ? arguments[2] : arguments[0];
+      var promise = this._pc.createAnswer(options || {});
+      if (arguments.length >= 2) {
+        promise.then(arguments[0], arguments[1]);
+      }
+      return promise;
+    };
+    RTCPeerConnection.prototype.getConfiguration = function getConfiguration() {
+      return this._pc.getConfiguration();
+    };
+    RTCPeerConnection.prototype.getReceivers = function getReceivers() {
+      return this._pc.getReceivers();
+    };
+    RTCPeerConnection.prototype.getSenders = function getSenders() {
+      return this._pc.getSenders();
+    };
+    RTCPeerConnection.prototype.getTransceivers = function getTransceivers() {
+      return this._pc.getTransceivers();
+    };
+    RTCPeerConnection.prototype.getStats = function getStats() {
+      return this._pc.getStats(arguments[0]);
+    };
+    RTCPeerConnection.prototype.removeTrack = function removeTrack(sender) {
+      this._pc.removeTrack(sender);
+    };
+    RTCPeerConnection.prototype.setConfiguration = function setConfiguration(configuration) {
+      return this._pc.setConfiguration(configuration);
+    };
+    RTCPeerConnection.prototype.setLocalDescription = function setLocalDescription(description) {
+      var promise = this._pc.setLocalDescription(description);
+      if (arguments.length === 3) {
+        promise.then(arguments[1], arguments[2]);
+      }
+      return promise;
+    };
+    RTCPeerConnection.prototype.setRemoteDescription = function setRemoteDescription(description) {
+      var promise = this._pc.setRemoteDescription(description);
+      if (arguments.length === 3) {
+        promise.then(arguments[1], arguments[2]);
+      }
+      return promise;
+    };
+    RTCPeerConnection.prototype.restartIce = function restartIce() {
+      return this._pc.restartIce();
+    };
+    module.exports = RTCPeerConnection;
+  }
+});
+
+// node_modules/@roamhq/wrtc/lib/index.js
+var require_lib2 = __commonJS({
+  "node_modules/@roamhq/wrtc/lib/index.js"(exports, module) {
+    "use strict";
+    var { inherits } = __require("util");
+    var {
+      MediaStream,
+      MediaStreamTrack,
+      RTCAudioSink,
+      RTCAudioSource,
+      RTCDataChannel,
+      RTCDtlsTransport,
+      RTCIceTransport,
+      RTCRtpReceiver,
+      RTCRtpSender,
+      RTCRtpTransceiver,
+      RTCSctpTransport,
+      RTCVideoSink,
+      RTCVideoSource,
+      getUserMedia,
+      i420ToRgba,
+      rgbaToI420,
+      setDOMException
+    } = require_binding();
+    var EventTarget = require_eventtarget();
+    var MediaDevices = require_mediadevices();
+    inherits(MediaStream, EventTarget);
+    inherits(MediaStreamTrack, EventTarget);
+    inherits(RTCAudioSink, EventTarget);
+    inherits(RTCDataChannel, EventTarget);
+    inherits(RTCDtlsTransport, EventTarget);
+    inherits(RTCIceTransport, EventTarget);
+    inherits(RTCSctpTransport, EventTarget);
+    inherits(RTCVideoSink, EventTarget);
+    try {
+      setDOMException(require_domexception());
+    } catch (error) {
+      void error;
+    }
+    RTCDataChannel.prototype.send = function send(data) {
+      const implSymbol = Object.getOwnPropertySymbols(data).find(
+        (symbol) => symbol.toString() === "Symbol(impl)"
+      );
+      if (data[implSymbol] && data[implSymbol]._buffer) {
+        data = data[implSymbol]._buffer;
+      }
+      this._send(data);
+    };
+    var mediaDevices = new MediaDevices();
+    var nonstandard = {
+      i420ToRgba,
+      RTCAudioSink,
+      RTCAudioSource,
+      RTCVideoSink,
+      RTCVideoSource,
+      rgbaToI420
+    };
+    module.exports = {
+      MediaStream,
+      MediaStreamTrack,
+      RTCDataChannel,
+      RTCDataChannelEvent: require_datachannelevent(),
+      RTCDtlsTransport,
+      RTCIceCandidate: require_icecandidate(),
+      RTCIceTransport,
+      RTCPeerConnection: require_peerconnection(),
+      RTCPeerConnectionIceEvent: require_rtcpeerconnectioniceevent(),
+      RTCPeerConnectionIceErrorEvent: require_rtcpeerconnectioniceerrorevent(),
+      RTCRtpReceiver,
+      RTCRtpSender,
+      RTCRtpTransceiver,
+      RTCSctpTransport,
+      RTCSessionDescription: require_sessiondescription(),
+      getUserMedia,
+      mediaDevices,
+      nonstandard
+    };
+  }
+});
+
 // src/server.ts
 import * as https from "https";
 import * as fs from "fs";
@@ -247,7 +1676,6 @@ import fastjsonpatch from "fast-json-patch";
 import { WebSocketServer } from "ws";
 import { MongoClient } from "mongodb";
 import { glMatrix } from "gl-matrix";
-import wrtc from "@roamhq/wrtc";
 glMatrix.setMatrixArrayType(Array);
 var fastPatchProperties = {
   "type": true,
@@ -317,9 +1745,11 @@ var TopazCubeServer = class {
   documents = {};
   isLoading = {};
   _documentChanges = {};
+  _documentChanged = {};
   _documentState = {};
   update = 0;
   lastUpdate = 0;
+  _saveiv = null;
   _loopiv = null;
   _statsiv = null;
   _stillUpdating = false;
@@ -463,6 +1893,7 @@ var TopazCubeServer = class {
     );
     if (!this._documentChanges[name]) {
       this._documentChanges[name] = [];
+      this._documentChanged[name] = false;
     }
   }
   _createEmptyDocument(name) {
@@ -521,6 +1952,9 @@ var TopazCubeServer = class {
     this._statsiv = setInterval(() => {
       this._doStats();
     }, 1e3);
+    this._saveiv = setInterval(() => {
+      this._saveChanges();
+    }, 6e4);
   }
   _loop() {
     let now = Date.now();
@@ -610,12 +2044,14 @@ var TopazCubeServer = class {
       let name = message.n;
       if (!this._documentChanges[name]) {
         this._documentChanges[name] = [];
+        this._documentChanged[name] = false;
       }
       for (let op of message.p) {
         if (!this.canSync(client, name, op)) {
           continue;
         }
         this._documentChanges[name].push(op);
+        this._documentChanged[name] = true;
         let dop = msgop(op);
         applyOperation(this.documents[name], dop);
       }
@@ -631,6 +2067,10 @@ var TopazCubeServer = class {
       let ping = time - message.st;
       client.ctdiff = message.ct + ping / 2 - time;
       client.ping = ping;
+    } else if (message.c == "rtc-offer") {
+      this._processOffer(client, message);
+    } else if (message.c == "rtc-candidate") {
+      this._processICECandidate(client, message);
     } else if (message.c == "sub") {
       await this._checkDocument(message.n, client);
       if (!this.documents[message.n]) {
@@ -907,6 +2347,7 @@ var TopazCubeServer = class {
   }
   _onDocumentChange(name, op, target, path, value) {
     this._documentChanges[name]?.push(opmsg(op, target, path, value));
+    this._documentChanged[name] = true;
   }
   propertyChange(name, id, property) {
     let doc = this.documents[name];
@@ -924,7 +2365,24 @@ var TopazCubeServer = class {
     e["__changed_" + property] = true;
   }
   /*= WEBRTC ===================================================================*/
+  _wrtc = null;
+  async _loadWebRTC() {
+    if (!this._wrtc) {
+      try {
+        this._wrtc = await Promise.resolve().then(() => __toESM(require_lib2(), 1));
+      } catch (error) {
+        this.error("WebRTC module not available:", error);
+        throw new Error("WebRTC functionality requires @roamhq/wrtc and platform-specific binary packages");
+      }
+    }
+    return this._wrtc;
+  }
   async _processOffer(client, data) {
+    if (!this.allowWebRTC) {
+      this.warn("WebRTC is disabled");
+      return;
+    }
+    const wrtc = await this._loadWebRTC();
     const peerConnection = new wrtc.RTCPeerConnection({
       iceServers: [
         { urls: "stun:stun.l.google.com:19302" },
@@ -1195,6 +2653,17 @@ var TopazCubeServer = class {
       await this._saveDocument(name);
     }
   }
+  async _saveChanges() {
+    if (!this.allowSave) {
+      return;
+    }
+    for (let name in this._documentChanged) {
+      if (this._documentChanged[name]) {
+        await this._saveDocument(name);
+        this._documentChanged[name] = false;
+      }
+    }
+  }
   _initServerDocument() {
     this.documents["_server"] = {
       nextUID: 100
@@ -1206,6 +2675,8 @@ var TopazCubeServer = class {
       this.log("\nEXIT: Caught interrupt signal " + signal);
       this._exited = true;
       clearInterval(this._loopiv);
+      clearInterval(this._statsiv);
+      clearInterval(this._saveiv);
       this.onBeforeExit();
       this.broadcast({ server: "Going down" });
       this._saveAllDocuments();