@dxos/codec-protobuf 2.33.9-dev.7d11f506 → 2.33.9-dev.b6f4ca19

package/dist/{index.js → browser.js}

@@ -23,6 +23,3662 @@ var __copyProps = (to, from, except, desc) => {
 var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, mod2));
 var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
+// ../../../common/temp/node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js
+var require_shams = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/shams.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function hasSymbols() {
+      if (typeof Symbol !== "function" || typeof Object.getOwnPropertySymbols !== "function") {
+        return false;
+      }
+      if (typeof Symbol.iterator === "symbol") {
+        return true;
+      }
+      var obj = {};
+      var sym = Symbol("test");
+      var symObj = Object(sym);
+      if (typeof sym === "string") {
+        return false;
+      }
+      if (Object.prototype.toString.call(sym) !== "[object Symbol]") {
+        return false;
+      }
+      if (Object.prototype.toString.call(symObj) !== "[object Symbol]") {
+        return false;
+      }
+      var symVal = 42;
+      obj[sym] = symVal;
+      for (sym in obj) {
+        return false;
+      }
+      if (typeof Object.keys === "function" && Object.keys(obj).length !== 0) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyNames === "function" && Object.getOwnPropertyNames(obj).length !== 0) {
+        return false;
+      }
+      var syms = Object.getOwnPropertySymbols(obj);
+      if (syms.length !== 1 || syms[0] !== sym) {
+        return false;
+      }
+      if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) {
+        return false;
+      }
+      if (typeof Object.getOwnPropertyDescriptor === "function") {
+        var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
+        if (descriptor.value !== symVal || descriptor.enumerable !== true) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/has-tostringtag@1.0.0/node_modules/has-tostringtag/shams.js
+var require_shams2 = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/has-tostringtag@1.0.0/node_modules/has-tostringtag/shams.js"(exports2, module2) {
+    "use strict";
+    var hasSymbols = require_shams();
+    module2.exports = function hasToStringTagShams() {
+      return hasSymbols() && !!Symbol.toStringTag;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/index.js
+var require_has_symbols = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/has-symbols@1.0.3/node_modules/has-symbols/index.js"(exports2, module2) {
+    "use strict";
+    var origSymbol = typeof Symbol !== "undefined" && Symbol;
+    var hasSymbolSham = require_shams();
+    module2.exports = function hasNativeSymbols() {
+      if (typeof origSymbol !== "function") {
+        return false;
+      }
+      if (typeof Symbol !== "function") {
+        return false;
+      }
+      if (typeof origSymbol("foo") !== "symbol") {
+        return false;
+      }
+      if (typeof Symbol("bar") !== "symbol") {
+        return false;
+      }
+      return hasSymbolSham();
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js
+var require_implementation = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/implementation.js"(exports2, module2) {
+    "use strict";
+    var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
+    var slice = Array.prototype.slice;
+    var toStr = Object.prototype.toString;
+    var funcType = "[object Function]";
+    module2.exports = function bind(that) {
+      var target = this;
+      if (typeof target !== "function" || toStr.call(target) !== funcType) {
+        throw new TypeError(ERROR_MESSAGE + target);
+      }
+      var args = slice.call(arguments, 1);
+      var bound;
+      var binder = function() {
+        if (this instanceof bound) {
+          var result = target.apply(this, args.concat(slice.call(arguments)));
+          if (Object(result) === result) {
+            return result;
+          }
+          return this;
+        } else {
+          return target.apply(that, args.concat(slice.call(arguments)));
+        }
+      };
+      var boundLength = Math.max(0, target.length - args.length);
+      var boundArgs = [];
+      for (var i = 0; i < boundLength; i++) {
+        boundArgs.push("$" + i);
+      }
+      bound = Function("binder", "return function (" + boundArgs.join(",") + "){ return binder.apply(this,arguments); }")(binder);
+      if (target.prototype) {
+        var Empty = function Empty2() {
+        };
+        Empty.prototype = target.prototype;
+        bound.prototype = new Empty();
+        Empty.prototype = null;
+      }
+      return bound;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/index.js
+var require_function_bind = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/function-bind@1.1.1/node_modules/function-bind/index.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation();
+    module2.exports = Function.prototype.bind || implementation;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js
+var require_src = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/has@1.0.3/node_modules/has/src/index.js"(exports2, module2) {
+    "use strict";
+    var bind = require_function_bind();
+    module2.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/get-intrinsic@1.1.1/node_modules/get-intrinsic/index.js
+var require_get_intrinsic = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/get-intrinsic@1.1.1/node_modules/get-intrinsic/index.js"(exports2, module2) {
+    "use strict";
+    var undefined2;
+    var $SyntaxError = SyntaxError;
+    var $Function = Function;
+    var $TypeError = TypeError;
+    var getEvalledConstructor = function(expressionSyntax) {
+      try {
+        return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
+      } catch (e) {
+      }
+    };
+    var $gOPD = Object.getOwnPropertyDescriptor;
+    if ($gOPD) {
+      try {
+        $gOPD({}, "");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    var throwTypeError = function() {
+      throw new $TypeError();
+    };
+    var ThrowTypeError = $gOPD ? function() {
+      try {
+        arguments.callee;
+        return throwTypeError;
+      } catch (calleeThrows) {
+        try {
+          return $gOPD(arguments, "callee").get;
+        } catch (gOPDthrows) {
+          return throwTypeError;
+        }
+      }
+    }() : throwTypeError;
+    var hasSymbols = require_has_symbols()();
+    var getProto = Object.getPrototypeOf || function(x) {
+      return x.__proto__;
+    };
+    var needsEval = {};
+    var TypedArray = typeof Uint8Array === "undefined" ? undefined2 : getProto(Uint8Array);
+    var INTRINSICS = {
+      "%AggregateError%": typeof AggregateError === "undefined" ? undefined2 : AggregateError,
+      "%Array%": Array,
+      "%ArrayBuffer%": typeof ArrayBuffer === "undefined" ? undefined2 : ArrayBuffer,
+      "%ArrayIteratorPrototype%": hasSymbols ? getProto([][Symbol.iterator]()) : undefined2,
+      "%AsyncFromSyncIteratorPrototype%": undefined2,
+      "%AsyncFunction%": needsEval,
+      "%AsyncGenerator%": needsEval,
+      "%AsyncGeneratorFunction%": needsEval,
+      "%AsyncIteratorPrototype%": needsEval,
+      "%Atomics%": typeof Atomics === "undefined" ? undefined2 : Atomics,
+      "%BigInt%": typeof BigInt === "undefined" ? undefined2 : BigInt,
+      "%Boolean%": Boolean,
+      "%DataView%": typeof DataView === "undefined" ? undefined2 : DataView,
+      "%Date%": Date,
+      "%decodeURI%": decodeURI,
+      "%decodeURIComponent%": decodeURIComponent,
+      "%encodeURI%": encodeURI,
+      "%encodeURIComponent%": encodeURIComponent,
+      "%Error%": Error,
+      "%eval%": eval,
+      "%EvalError%": EvalError,
+      "%Float32Array%": typeof Float32Array === "undefined" ? undefined2 : Float32Array,
+      "%Float64Array%": typeof Float64Array === "undefined" ? undefined2 : Float64Array,
+      "%FinalizationRegistry%": typeof FinalizationRegistry === "undefined" ? undefined2 : FinalizationRegistry,
+      "%Function%": $Function,
+      "%GeneratorFunction%": needsEval,
+      "%Int8Array%": typeof Int8Array === "undefined" ? undefined2 : Int8Array,
+      "%Int16Array%": typeof Int16Array === "undefined" ? undefined2 : Int16Array,
+      "%Int32Array%": typeof Int32Array === "undefined" ? undefined2 : Int32Array,
+      "%isFinite%": isFinite,
+      "%isNaN%": isNaN,
+      "%IteratorPrototype%": hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined2,
+      "%JSON%": typeof JSON === "object" ? JSON : undefined2,
+      "%Map%": typeof Map === "undefined" ? undefined2 : Map,
+      "%MapIteratorPrototype%": typeof Map === "undefined" || !hasSymbols ? undefined2 : getProto((/* @__PURE__ */ new Map())[Symbol.iterator]()),
+      "%Math%": Math,
+      "%Number%": Number,
+      "%Object%": Object,
+      "%parseFloat%": parseFloat,
+      "%parseInt%": parseInt,
+      "%Promise%": typeof Promise === "undefined" ? undefined2 : Promise,
+      "%Proxy%": typeof Proxy === "undefined" ? undefined2 : Proxy,
+      "%RangeError%": RangeError,
+      "%ReferenceError%": ReferenceError,
+      "%Reflect%": typeof Reflect === "undefined" ? undefined2 : Reflect,
+      "%RegExp%": RegExp,
+      "%Set%": typeof Set === "undefined" ? undefined2 : Set,
+      "%SetIteratorPrototype%": typeof Set === "undefined" || !hasSymbols ? undefined2 : getProto((/* @__PURE__ */ new Set())[Symbol.iterator]()),
+      "%SharedArrayBuffer%": typeof SharedArrayBuffer === "undefined" ? undefined2 : SharedArrayBuffer,
+      "%String%": String,
+      "%StringIteratorPrototype%": hasSymbols ? getProto(""[Symbol.iterator]()) : undefined2,
+      "%Symbol%": hasSymbols ? Symbol : undefined2,
+      "%SyntaxError%": $SyntaxError,
+      "%ThrowTypeError%": ThrowTypeError,
+      "%TypedArray%": TypedArray,
+      "%TypeError%": $TypeError,
+      "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined2 : Uint8Array,
+      "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined2 : Uint8ClampedArray,
+      "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined2 : Uint16Array,
+      "%Uint32Array%": typeof Uint32Array === "undefined" ? undefined2 : Uint32Array,
+      "%URIError%": URIError,
+      "%WeakMap%": typeof WeakMap === "undefined" ? undefined2 : WeakMap,
+      "%WeakRef%": typeof WeakRef === "undefined" ? undefined2 : WeakRef,
+      "%WeakSet%": typeof WeakSet === "undefined" ? undefined2 : WeakSet
+    };
+    var doEval = function doEval2(name) {
+      var value;
+      if (name === "%AsyncFunction%") {
+        value = getEvalledConstructor("async function () {}");
+      } else if (name === "%GeneratorFunction%") {
+        value = getEvalledConstructor("function* () {}");
+      } else if (name === "%AsyncGeneratorFunction%") {
+        value = getEvalledConstructor("async function* () {}");
+      } else if (name === "%AsyncGenerator%") {
+        var fn = doEval2("%AsyncGeneratorFunction%");
+        if (fn) {
+          value = fn.prototype;
+        }
+      } else if (name === "%AsyncIteratorPrototype%") {
+        var gen = doEval2("%AsyncGenerator%");
+        if (gen) {
+          value = getProto(gen.prototype);
+        }
+      }
+      INTRINSICS[name] = value;
+      return value;
+    };
+    var LEGACY_ALIASES = {
+      "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"],
+      "%ArrayPrototype%": ["Array", "prototype"],
+      "%ArrayProto_entries%": ["Array", "prototype", "entries"],
+      "%ArrayProto_forEach%": ["Array", "prototype", "forEach"],
+      "%ArrayProto_keys%": ["Array", "prototype", "keys"],
+      "%ArrayProto_values%": ["Array", "prototype", "values"],
+      "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"],
+      "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"],
+      "%AsyncGeneratorPrototype%": ["AsyncGeneratorFunction", "prototype", "prototype"],
+      "%BooleanPrototype%": ["Boolean", "prototype"],
+      "%DataViewPrototype%": ["DataView", "prototype"],
+      "%DatePrototype%": ["Date", "prototype"],
+      "%ErrorPrototype%": ["Error", "prototype"],
+      "%EvalErrorPrototype%": ["EvalError", "prototype"],
+      "%Float32ArrayPrototype%": ["Float32Array", "prototype"],
+      "%Float64ArrayPrototype%": ["Float64Array", "prototype"],
+      "%FunctionPrototype%": ["Function", "prototype"],
+      "%Generator%": ["GeneratorFunction", "prototype"],
+      "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"],
+      "%Int8ArrayPrototype%": ["Int8Array", "prototype"],
+      "%Int16ArrayPrototype%": ["Int16Array", "prototype"],
+      "%Int32ArrayPrototype%": ["Int32Array", "prototype"],
+      "%JSONParse%": ["JSON", "parse"],
+      "%JSONStringify%": ["JSON", "stringify"],
+      "%MapPrototype%": ["Map", "prototype"],
+      "%NumberPrototype%": ["Number", "prototype"],
+      "%ObjectPrototype%": ["Object", "prototype"],
+      "%ObjProto_toString%": ["Object", "prototype", "toString"],
+      "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"],
+      "%PromisePrototype%": ["Promise", "prototype"],
+      "%PromiseProto_then%": ["Promise", "prototype", "then"],
+      "%Promise_all%": ["Promise", "all"],
+      "%Promise_reject%": ["Promise", "reject"],
+      "%Promise_resolve%": ["Promise", "resolve"],
+      "%RangeErrorPrototype%": ["RangeError", "prototype"],
+      "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"],
+      "%RegExpPrototype%": ["RegExp", "prototype"],
+      "%SetPrototype%": ["Set", "prototype"],
+      "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"],
+      "%StringPrototype%": ["String", "prototype"],
+      "%SymbolPrototype%": ["Symbol", "prototype"],
+      "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"],
+      "%TypedArrayPrototype%": ["TypedArray", "prototype"],
+      "%TypeErrorPrototype%": ["TypeError", "prototype"],
+      "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"],
+      "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"],
+      "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"],
+      "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"],
+      "%URIErrorPrototype%": ["URIError", "prototype"],
+      "%WeakMapPrototype%": ["WeakMap", "prototype"],
+      "%WeakSetPrototype%": ["WeakSet", "prototype"]
+    };
+    var bind = require_function_bind();
+    var hasOwn = require_src();
+    var $concat = bind.call(Function.call, Array.prototype.concat);
+    var $spliceApply = bind.call(Function.apply, Array.prototype.splice);
+    var $replace = bind.call(Function.call, String.prototype.replace);
+    var $strSlice = bind.call(Function.call, String.prototype.slice);
+    var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
+    var reEscapeChar = /\\(\\)?/g;
+    var stringToPath = function stringToPath2(string) {
+      var first = $strSlice(string, 0, 1);
+      var last = $strSlice(string, -1);
+      if (first === "%" && last !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected closing `%`");
+      } else if (last === "%" && first !== "%") {
+        throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
+      }
+      var result = [];
+      $replace(string, rePropName, function(match, number, quote, subString) {
+        result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number || match;
+      });
+      return result;
+    };
+    var getBaseIntrinsic = function getBaseIntrinsic2(name, allowMissing) {
+      var intrinsicName = name;
+      var alias;
+      if (hasOwn(LEGACY_ALIASES, intrinsicName)) {
+        alias = LEGACY_ALIASES[intrinsicName];
+        intrinsicName = "%" + alias[0] + "%";
+      }
+      if (hasOwn(INTRINSICS, intrinsicName)) {
+        var value = INTRINSICS[intrinsicName];
+        if (value === needsEval) {
+          value = doEval(intrinsicName);
+        }
+        if (typeof value === "undefined" && !allowMissing) {
+          throw new $TypeError("intrinsic " + name + " exists, but is not available. Please file an issue!");
+        }
+        return {
+          alias,
+          name: intrinsicName,
+          value
+        };
+      }
+      throw new $SyntaxError("intrinsic " + name + " does not exist!");
+    };
+    module2.exports = function GetIntrinsic(name, allowMissing) {
+      if (typeof name !== "string" || name.length === 0) {
+        throw new $TypeError("intrinsic name must be a non-empty string");
+      }
+      if (arguments.length > 1 && typeof allowMissing !== "boolean") {
+        throw new $TypeError('"allowMissing" argument must be a boolean');
+      }
+      var parts = stringToPath(name);
+      var intrinsicBaseName = parts.length > 0 ? parts[0] : "";
+      var intrinsic = getBaseIntrinsic("%" + intrinsicBaseName + "%", allowMissing);
+      var intrinsicRealName = intrinsic.name;
+      var value = intrinsic.value;
+      var skipFurtherCaching = false;
+      var alias = intrinsic.alias;
+      if (alias) {
+        intrinsicBaseName = alias[0];
+        $spliceApply(parts, $concat([0, 1], alias));
+      }
+      for (var i = 1, isOwn = true; i < parts.length; i += 1) {
+        var part = parts[i];
+        var first = $strSlice(part, 0, 1);
+        var last = $strSlice(part, -1);
+        if ((first === '"' || first === "'" || first === "`" || (last === '"' || last === "'" || last === "`")) && first !== last) {
+          throw new $SyntaxError("property names with quotes must have matching quotes");
+        }
+        if (part === "constructor" || !isOwn) {
+          skipFurtherCaching = true;
+        }
+        intrinsicBaseName += "." + part;
+        intrinsicRealName = "%" + intrinsicBaseName + "%";
+        if (hasOwn(INTRINSICS, intrinsicRealName)) {
+          value = INTRINSICS[intrinsicRealName];
+        } else if (value != null) {
+          if (!(part in value)) {
+            if (!allowMissing) {
+              throw new $TypeError("base intrinsic for " + name + " exists, but the property is not available.");
+            }
+            return void 0;
+          }
+          if ($gOPD && i + 1 >= parts.length) {
+            var desc = $gOPD(value, part);
+            isOwn = !!desc;
+            if (isOwn && "get" in desc && !("originalValue" in desc.get)) {
+              value = desc.get;
+            } else {
+              value = value[part];
+            }
+          } else {
+            isOwn = hasOwn(value, part);
+            value = value[part];
+          }
+          if (isOwn && !skipFurtherCaching) {
+            INTRINSICS[intrinsicRealName] = value;
+          }
+        }
+      }
+      return value;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js
+var require_call_bind = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/index.js"(exports2, module2) {
+    "use strict";
+    var bind = require_function_bind();
+    var GetIntrinsic = require_get_intrinsic();
+    var $apply = GetIntrinsic("%Function.prototype.apply%");
+    var $call = GetIntrinsic("%Function.prototype.call%");
+    var $reflectApply = GetIntrinsic("%Reflect.apply%", true) || bind.call($call, $apply);
+    var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
+    var $defineProperty = GetIntrinsic("%Object.defineProperty%", true);
+    var $max = GetIntrinsic("%Math.max%");
+    if ($defineProperty) {
+      try {
+        $defineProperty({}, "a", { value: 1 });
+      } catch (e) {
+        $defineProperty = null;
+      }
+    }
+    module2.exports = function callBind(originalFunction) {
+      var func = $reflectApply(bind, $call, arguments);
+      if ($gOPD && $defineProperty) {
+        var desc = $gOPD(func, "length");
+        if (desc.configurable) {
+          $defineProperty(func, "length", { value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) });
+        }
+      }
+      return func;
+    };
+    var applyBind = function applyBind2() {
+      return $reflectApply(bind, $apply, arguments);
+    };
+    if ($defineProperty) {
+      $defineProperty(module2.exports, "apply", { value: applyBind });
+    } else {
+      module2.exports.apply = applyBind;
+    }
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js
+var require_callBound = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/call-bind@1.0.2/node_modules/call-bind/callBound.js"(exports2, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var callBind = require_call_bind();
+    var $indexOf = callBind(GetIntrinsic("String.prototype.indexOf"));
+    module2.exports = function callBoundIntrinsic(name, allowMissing) {
+      var intrinsic = GetIntrinsic(name, !!allowMissing);
+      if (typeof intrinsic === "function" && $indexOf(name, ".prototype.") > -1) {
+        return callBind(intrinsic);
+      }
+      return intrinsic;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js
+var require_is_arguments = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-arguments@1.1.1/node_modules/is-arguments/index.js"(exports2, module2) {
+    "use strict";
+    var hasToStringTag = require_shams2()();
+    var callBound = require_callBound();
+    var $toString = callBound("Object.prototype.toString");
+    var isStandardArguments = function isArguments(value) {
+      if (hasToStringTag && value && typeof value === "object" && Symbol.toStringTag in value) {
+        return false;
+      }
+      return $toString(value) === "[object Arguments]";
+    };
+    var isLegacyArguments = function isArguments(value) {
+      if (isStandardArguments(value)) {
+        return true;
+      }
+      return value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && $toString(value) !== "[object Array]" && $toString(value.callee) === "[object Function]";
+    };
+    var supportsStandardArguments = function() {
+      return isStandardArguments(arguments);
+    }();
+    isStandardArguments.isLegacyArguments = isLegacyArguments;
+    module2.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js
+var require_is_generator_function = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-generator-function@1.0.10/node_modules/is-generator-function/index.js"(exports2, module2) {
+    "use strict";
+    var toStr = Object.prototype.toString;
+    var fnToStr = Function.prototype.toString;
+    var isFnRegex = /^\s*(?:function)?\*/;
+    var hasToStringTag = require_shams2()();
+    var getProto = Object.getPrototypeOf;
+    var getGeneratorFunc = function() {
+      if (!hasToStringTag) {
+        return false;
+      }
+      try {
+        return Function("return function*() {}")();
+      } catch (e) {
+      }
+    };
+    var GeneratorFunction;
+    module2.exports = function isGeneratorFunction(fn) {
+      if (typeof fn !== "function") {
+        return false;
+      }
+      if (isFnRegex.test(fnToStr.call(fn))) {
+        return true;
+      }
+      if (!hasToStringTag) {
+        var str = toStr.call(fn);
+        return str === "[object GeneratorFunction]";
+      }
+      if (!getProto) {
+        return false;
+      }
+      if (typeof GeneratorFunction === "undefined") {
+        var generatorFunc = getGeneratorFunc();
+        GeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;
+      }
+      return getProto(fn) === GeneratorFunction;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/foreach@2.0.5/node_modules/foreach/index.js
+var require_foreach = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/foreach@2.0.5/node_modules/foreach/index.js"(exports2, module2) {
+    var hasOwn = Object.prototype.hasOwnProperty;
+    var toString = Object.prototype.toString;
+    module2.exports = function forEach(obj, fn, ctx) {
+      if (toString.call(fn) !== "[object Function]") {
+        throw new TypeError("iterator must be a function");
+      }
+      var l = obj.length;
+      if (l === +l) {
+        for (var i = 0; i < l; i++) {
+          fn.call(ctx, obj[i], i, obj);
+        }
+      } else {
+        for (var k in obj) {
+          if (hasOwn.call(obj, k)) {
+            fn.call(ctx, obj[k], k, obj);
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/available-typed-arrays@1.0.5/node_modules/available-typed-arrays/index.js
+var require_available_typed_arrays = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/available-typed-arrays@1.0.5/node_modules/available-typed-arrays/index.js"(exports2, module2) {
+    "use strict";
+    var possibleNames = [
+      "BigInt64Array",
+      "BigUint64Array",
+      "Float32Array",
+      "Float64Array",
+      "Int16Array",
+      "Int32Array",
+      "Int8Array",
+      "Uint16Array",
+      "Uint32Array",
+      "Uint8Array",
+      "Uint8ClampedArray"
+    ];
+    var g = typeof globalThis === "undefined" ? global : globalThis;
+    module2.exports = function availableTypedArrays() {
+      var out = [];
+      for (var i = 0; i < possibleNames.length; i++) {
+        if (typeof g[possibleNames[i]] === "function") {
+          out[out.length] = possibleNames[i];
+        }
+      }
+      return out;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/es-abstract@1.20.1/node_modules/es-abstract/helpers/getOwnPropertyDescriptor.js
+var require_getOwnPropertyDescriptor = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/es-abstract@1.20.1/node_modules/es-abstract/helpers/getOwnPropertyDescriptor.js"(exports2, module2) {
+    "use strict";
+    var GetIntrinsic = require_get_intrinsic();
+    var $gOPD = GetIntrinsic("%Object.getOwnPropertyDescriptor%", true);
+    if ($gOPD) {
+      try {
+        $gOPD([], "length");
+      } catch (e) {
+        $gOPD = null;
+      }
+    }
+    module2.exports = $gOPD;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-typed-array@1.1.8/node_modules/is-typed-array/index.js
+var require_is_typed_array = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-typed-array@1.1.8/node_modules/is-typed-array/index.js"(exports2, module2) {
+    "use strict";
+    var forEach = require_foreach();
+    var availableTypedArrays = require_available_typed_arrays();
+    var callBound = require_callBound();
+    var $toString = callBound("Object.prototype.toString");
+    var hasToStringTag = require_shams2()();
+    var g = typeof globalThis === "undefined" ? global : globalThis;
+    var typedArrays = availableTypedArrays();
+    var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
+      for (var i = 0; i < array.length; i += 1) {
+        if (array[i] === value) {
+          return i;
+        }
+      }
+      return -1;
+    };
+    var $slice = callBound("String.prototype.slice");
+    var toStrTags = {};
+    var gOPD = require_getOwnPropertyDescriptor();
+    var getPrototypeOf = Object.getPrototypeOf;
+    if (hasToStringTag && gOPD && getPrototypeOf) {
+      forEach(typedArrays, function(typedArray) {
+        var arr = new g[typedArray]();
+        if (Symbol.toStringTag in arr) {
+          var proto = getPrototypeOf(arr);
+          var descriptor = gOPD(proto, Symbol.toStringTag);
+          if (!descriptor) {
+            var superProto = getPrototypeOf(proto);
+            descriptor = gOPD(superProto, Symbol.toStringTag);
+          }
+          toStrTags[typedArray] = descriptor.get;
+        }
+      });
+    }
+    var tryTypedArrays = function tryAllTypedArrays(value) {
+      var anyTrue = false;
+      forEach(toStrTags, function(getter, typedArray) {
+        if (!anyTrue) {
+          try {
+            anyTrue = getter.call(value) === typedArray;
+          } catch (e) {
+          }
+        }
+      });
+      return anyTrue;
+    };
+    module2.exports = function isTypedArray(value) {
+      if (!value || typeof value !== "object") {
+        return false;
+      }
+      if (!hasToStringTag || !(Symbol.toStringTag in value)) {
+        var tag = $slice($toString(value), 8, -1);
+        return $indexOf(typedArrays, tag) > -1;
+      }
+      if (!gOPD) {
+        return false;
+      }
+      return tryTypedArrays(value);
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/which-typed-array@1.1.7/node_modules/which-typed-array/index.js
+var require_which_typed_array = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/which-typed-array@1.1.7/node_modules/which-typed-array/index.js"(exports2, module2) {
+    "use strict";
+    var forEach = require_foreach();
+    var availableTypedArrays = require_available_typed_arrays();
+    var callBound = require_callBound();
+    var $toString = callBound("Object.prototype.toString");
+    var hasToStringTag = require_shams2()();
+    var g = typeof globalThis === "undefined" ? global : globalThis;
+    var typedArrays = availableTypedArrays();
+    var $slice = callBound("String.prototype.slice");
+    var toStrTags = {};
+    var gOPD = require_getOwnPropertyDescriptor();
+    var getPrototypeOf = Object.getPrototypeOf;
+    if (hasToStringTag && gOPD && getPrototypeOf) {
+      forEach(typedArrays, function(typedArray) {
+        if (typeof g[typedArray] === "function") {
+          var arr = new g[typedArray]();
+          if (Symbol.toStringTag in arr) {
+            var proto = getPrototypeOf(arr);
+            var descriptor = gOPD(proto, Symbol.toStringTag);
+            if (!descriptor) {
+              var superProto = getPrototypeOf(proto);
+              descriptor = gOPD(superProto, Symbol.toStringTag);
+            }
+            toStrTags[typedArray] = descriptor.get;
+          }
+        }
+      });
+    }
+    var tryTypedArrays = function tryAllTypedArrays(value) {
+      var foundName = false;
+      forEach(toStrTags, function(getter, typedArray) {
+        if (!foundName) {
+          try {
+            var name = getter.call(value);
+            if (name === typedArray) {
+              foundName = name;
+            }
+          } catch (e) {
+          }
+        }
+      });
+      return foundName;
+    };
+    var isTypedArray = require_is_typed_array();
+    module2.exports = function whichTypedArray(value) {
+      if (!isTypedArray(value)) {
+        return false;
+      }
+      if (!hasToStringTag || !(Symbol.toStringTag in value)) {
+        return $slice($toString(value), 8, -1);
+      }
+      return tryTypedArrays(value);
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/util@0.12.4/node_modules/util/support/types.js
+var require_types = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/util@0.12.4/node_modules/util/support/types.js"(exports2) {
+    "use strict";
+    var isArgumentsObject = require_is_arguments();
+    var isGeneratorFunction = require_is_generator_function();
+    var whichTypedArray = require_which_typed_array();
+    var isTypedArray = require_is_typed_array();
+    function uncurryThis(f) {
+      return f.call.bind(f);
+    }
+    var BigIntSupported = typeof BigInt !== "undefined";
+    var SymbolSupported = typeof Symbol !== "undefined";
+    var ObjectToString = uncurryThis(Object.prototype.toString);
+    var numberValue = uncurryThis(Number.prototype.valueOf);
+    var stringValue = uncurryThis(String.prototype.valueOf);
+    var booleanValue = uncurryThis(Boolean.prototype.valueOf);
+    if (BigIntSupported) {
+      bigIntValue = uncurryThis(BigInt.prototype.valueOf);
+    }
+    var bigIntValue;
+    if (SymbolSupported) {
+      symbolValue = uncurryThis(Symbol.prototype.valueOf);
+    }
+    var symbolValue;
+    function checkBoxedPrimitive(value, prototypeValueOf) {
+      if (typeof value !== "object") {
+        return false;
+      }
+      try {
+        prototypeValueOf(value);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    exports2.isArgumentsObject = isArgumentsObject;
+    exports2.isGeneratorFunction = isGeneratorFunction;
+    exports2.isTypedArray = isTypedArray;
+    function isPromise(input) {
+      return typeof Promise !== "undefined" && input instanceof Promise || input !== null && typeof input === "object" && typeof input.then === "function" && typeof input.catch === "function";
+    }
+    exports2.isPromise = isPromise;
+    function isArrayBufferView(value) {
+      if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+        return ArrayBuffer.isView(value);
+      }
+      return isTypedArray(value) || isDataView(value);
+    }
+    exports2.isArrayBufferView = isArrayBufferView;
+    function isUint8Array(value) {
+      return whichTypedArray(value) === "Uint8Array";
+    }
+    exports2.isUint8Array = isUint8Array;
+    function isUint8ClampedArray(value) {
+      return whichTypedArray(value) === "Uint8ClampedArray";
+    }
+    exports2.isUint8ClampedArray = isUint8ClampedArray;
+    function isUint16Array(value) {
+      return whichTypedArray(value) === "Uint16Array";
+    }
+    exports2.isUint16Array = isUint16Array;
+    function isUint32Array(value) {
+      return whichTypedArray(value) === "Uint32Array";
+    }
+    exports2.isUint32Array = isUint32Array;
+    function isInt8Array(value) {
+      return whichTypedArray(value) === "Int8Array";
+    }
+    exports2.isInt8Array = isInt8Array;
+    function isInt16Array(value) {
+      return whichTypedArray(value) === "Int16Array";
+    }
+    exports2.isInt16Array = isInt16Array;
+    function isInt32Array(value) {
+      return whichTypedArray(value) === "Int32Array";
+    }
+    exports2.isInt32Array = isInt32Array;
+    function isFloat32Array(value) {
+      return whichTypedArray(value) === "Float32Array";
+    }
+    exports2.isFloat32Array = isFloat32Array;
+    function isFloat64Array(value) {
+      return whichTypedArray(value) === "Float64Array";
+    }
+    exports2.isFloat64Array = isFloat64Array;
+    function isBigInt64Array(value) {
+      return whichTypedArray(value) === "BigInt64Array";
+    }
+    exports2.isBigInt64Array = isBigInt64Array;
+    function isBigUint64Array(value) {
+      return whichTypedArray(value) === "BigUint64Array";
+    }
+    exports2.isBigUint64Array = isBigUint64Array;
+    function isMapToString(value) {
+      return ObjectToString(value) === "[object Map]";
+    }
+    isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
+    function isMap(value) {
+      if (typeof Map === "undefined") {
+        return false;
+      }
+      return isMapToString.working ? isMapToString(value) : value instanceof Map;
+    }
+    exports2.isMap = isMap;
+    function isSetToString(value) {
+      return ObjectToString(value) === "[object Set]";
+    }
+    isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
+    function isSet(value) {
+      if (typeof Set === "undefined") {
+        return false;
+      }
+      return isSetToString.working ? isSetToString(value) : value instanceof Set;
+    }
+    exports2.isSet = isSet;
+    function isWeakMapToString(value) {
+      return ObjectToString(value) === "[object WeakMap]";
+    }
+    isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap());
+    function isWeakMap(value) {
+      if (typeof WeakMap === "undefined") {
+        return false;
+      }
+      return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;
+    }
+    exports2.isWeakMap = isWeakMap;
+    function isWeakSetToString(value) {
+      return ObjectToString(value) === "[object WeakSet]";
+    }
+    isWeakSetToString.working = typeof WeakSet !== "undefined" && isWeakSetToString(/* @__PURE__ */ new WeakSet());
+    function isWeakSet(value) {
+      return isWeakSetToString(value);
+    }
+    exports2.isWeakSet = isWeakSet;
+    function isArrayBufferToString(value) {
+      return ObjectToString(value) === "[object ArrayBuffer]";
+    }
+    isArrayBufferToString.working = typeof ArrayBuffer !== "undefined" && isArrayBufferToString(new ArrayBuffer());
+    function isArrayBuffer(value) {
+      if (typeof ArrayBuffer === "undefined") {
+        return false;
+      }
+      return isArrayBufferToString.working ? isArrayBufferToString(value) : value instanceof ArrayBuffer;
+    }
+    exports2.isArrayBuffer = isArrayBuffer;
+    function isDataViewToString(value) {
+      return ObjectToString(value) === "[object DataView]";
+    }
+    isDataViewToString.working = typeof ArrayBuffer !== "undefined" && typeof DataView !== "undefined" && isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1));
+    function isDataView(value) {
+      if (typeof DataView === "undefined") {
+        return false;
+      }
+      return isDataViewToString.working ? isDataViewToString(value) : value instanceof DataView;
+    }
+    exports2.isDataView = isDataView;
+    var SharedArrayBufferCopy = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : void 0;
+    function isSharedArrayBufferToString(value) {
+      return ObjectToString(value) === "[object SharedArrayBuffer]";
+    }
+    function isSharedArrayBuffer(value) {
+      if (typeof SharedArrayBufferCopy === "undefined") {
+        return false;
+      }
+      if (typeof isSharedArrayBufferToString.working === "undefined") {
+        isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());
+      }
+      return isSharedArrayBufferToString.working ? isSharedArrayBufferToString(value) : value instanceof SharedArrayBufferCopy;
+    }
+    exports2.isSharedArrayBuffer = isSharedArrayBuffer;
+    function isAsyncFunction(value) {
+      return ObjectToString(value) === "[object AsyncFunction]";
+    }
+    exports2.isAsyncFunction = isAsyncFunction;
+    function isMapIterator(value) {
+      return ObjectToString(value) === "[object Map Iterator]";
+    }
+    exports2.isMapIterator = isMapIterator;
+    function isSetIterator(value) {
+      return ObjectToString(value) === "[object Set Iterator]";
+    }
+    exports2.isSetIterator = isSetIterator;
+    function isGeneratorObject(value) {
+      return ObjectToString(value) === "[object Generator]";
+    }
+    exports2.isGeneratorObject = isGeneratorObject;
+    function isWebAssemblyCompiledModule(value) {
+      return ObjectToString(value) === "[object WebAssembly.Module]";
+    }
+    exports2.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;
+    function isNumberObject(value) {
+      return checkBoxedPrimitive(value, numberValue);
+    }
+    exports2.isNumberObject = isNumberObject;
+    function isStringObject(value) {
+      return checkBoxedPrimitive(value, stringValue);
+    }
+    exports2.isStringObject = isStringObject;
+    function isBooleanObject(value) {
+      return checkBoxedPrimitive(value, booleanValue);
+    }
+    exports2.isBooleanObject = isBooleanObject;
+    function isBigIntObject(value) {
+      return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);
+    }
+    exports2.isBigIntObject = isBigIntObject;
+    function isSymbolObject(value) {
+      return SymbolSupported && checkBoxedPrimitive(value, symbolValue);
+    }
+    exports2.isSymbolObject = isSymbolObject;
+    function isBoxedPrimitive(value) {
+      return isNumberObject(value) || isStringObject(value) || isBooleanObject(value) || isBigIntObject(value) || isSymbolObject(value);
+    }
+    exports2.isBoxedPrimitive = isBoxedPrimitive;
+    function isAnyArrayBuffer(value) {
+      return typeof Uint8Array !== "undefined" && (isArrayBuffer(value) || isSharedArrayBuffer(value));
+    }
+    exports2.isAnyArrayBuffer = isAnyArrayBuffer;
+    ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(method) {
+      Object.defineProperty(exports2, method, {
+        enumerable: false,
+        value: function() {
+          throw new Error(method + " is not supported in userland");
+        }
+      });
+    });
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/util@0.12.4/node_modules/util/support/isBufferBrowser.js
+var require_isBufferBrowser = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/util@0.12.4/node_modules/util/support/isBufferBrowser.js"(exports2, module2) {
+    module2.exports = function isBuffer(arg) {
+      return arg && typeof arg === "object" && typeof arg.copy === "function" && typeof arg.fill === "function" && typeof arg.readUInt8 === "function";
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports2, module2) {
+    if (typeof Object.create === "function") {
+      module2.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
+      };
+    } else {
+      module2.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/util@0.12.4/node_modules/util/util.js
+var require_util = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/util@0.12.4/node_modules/util/util.js"(exports2) {
+    var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors2(obj) {
+      var keys = Object.keys(obj);
+      var descriptors = {};
+      for (var i = 0; i < keys.length; i++) {
+        descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+      }
+      return descriptors;
+    };
+    var formatRegExp = /%[sdj%]/g;
+    exports2.format = function(f) {
+      if (!isString(f)) {
+        var objects = [];
+        for (var i = 0; i < arguments.length; i++) {
+          objects.push(inspect(arguments[i]));
+        }
+        return objects.join(" ");
+      }
+      var i = 1;
+      var args = arguments;
+      var len = args.length;
+      var str = String(f).replace(formatRegExp, function(x2) {
+        if (x2 === "%%")
+          return "%";
+        if (i >= len)
+          return x2;
+        switch (x2) {
+          case "%s":
+            return String(args[i++]);
+          case "%d":
+            return Number(args[i++]);
+          case "%j":
+            try {
+              return JSON.stringify(args[i++]);
+            } catch (_) {
+              return "[Circular]";
+            }
+          default:
+            return x2;
+        }
+      });
+      for (var x = args[i]; i < len; x = args[++i]) {
+        if (isNull(x) || !isObject(x)) {
+          str += " " + x;
+        } else {
+          str += " " + inspect(x);
+        }
+      }
+      return str;
+    };
+    exports2.deprecate = function(fn, msg) {
+      if (typeof process !== "undefined" && process.noDeprecation === true) {
+        return fn;
+      }
+      if (typeof process === "undefined") {
+        return function() {
+          return exports2.deprecate(fn, msg).apply(this, arguments);
+        };
+      }
+      var warned = false;
+      function deprecated() {
+        if (!warned) {
+          if (process.throwDeprecation) {
+            throw new Error(msg);
+          } else if (process.traceDeprecation) {
+            console.trace(msg);
+          } else {
+            console.error(msg);
+          }
+          warned = true;
+        }
+        return fn.apply(this, arguments);
+      }
+      return deprecated;
+    };
+    var debugs = {};
+    var debugEnvRegex = /^$/;
+    if (process.env.NODE_DEBUG) {
+      debugEnv = process.env.NODE_DEBUG;
+      debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase();
+      debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
+    }
+    var debugEnv;
+    exports2.debuglog = function(set) {
+      set = set.toUpperCase();
+      if (!debugs[set]) {
+        if (debugEnvRegex.test(set)) {
+          var pid = process.pid;
+          debugs[set] = function() {
+            var msg = exports2.format.apply(exports2, arguments);
+            console.error("%s %d: %s", set, pid, msg);
+          };
+        } else {
+          debugs[set] = function() {
+          };
+        }
+      }
+      return debugs[set];
+    };
+    function inspect(obj, opts) {
+      var ctx = {
+        seen: [],
+        stylize: stylizeNoColor
+      };
+      if (arguments.length >= 3)
+        ctx.depth = arguments[2];
+      if (arguments.length >= 4)
+        ctx.colors = arguments[3];
+      if (isBoolean(opts)) {
+        ctx.showHidden = opts;
+      } else if (opts) {
+        exports2._extend(ctx, opts);
+      }
+      if (isUndefined(ctx.showHidden))
+        ctx.showHidden = false;
+      if (isUndefined(ctx.depth))
+        ctx.depth = 2;
+      if (isUndefined(ctx.colors))
+        ctx.colors = false;
+      if (isUndefined(ctx.customInspect))
+        ctx.customInspect = true;
+      if (ctx.colors)
+        ctx.stylize = stylizeWithColor;
+      return formatValue(ctx, obj, ctx.depth);
+    }
+    exports2.inspect = inspect;
+    inspect.colors = {
+      "bold": [1, 22],
+      "italic": [3, 23],
+      "underline": [4, 24],
+      "inverse": [7, 27],
+      "white": [37, 39],
+      "grey": [90, 39],
+      "black": [30, 39],
+      "blue": [34, 39],
+      "cyan": [36, 39],
+      "green": [32, 39],
+      "magenta": [35, 39],
+      "red": [31, 39],
+      "yellow": [33, 39]
+    };
+    inspect.styles = {
+      "special": "cyan",
+      "number": "yellow",
+      "boolean": "yellow",
+      "undefined": "grey",
+      "null": "bold",
+      "string": "green",
+      "date": "magenta",
+      "regexp": "red"
+    };
+    function stylizeWithColor(str, styleType) {
+      var style = inspect.styles[styleType];
+      if (style) {
+        return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+      } else {
+        return str;
+      }
+    }
+    function stylizeNoColor(str, styleType) {
+      return str;
+    }
+    function arrayToHash(array) {
+      var hash = {};
+      array.forEach(function(val, idx) {
+        hash[val] = true;
+      });
+      return hash;
+    }
+    function formatValue(ctx, value, recurseTimes) {
+      if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== exports2.inspect && !(value.constructor && value.constructor.prototype === value)) {
+        var ret = value.inspect(recurseTimes, ctx);
+        if (!isString(ret)) {
+          ret = formatValue(ctx, ret, recurseTimes);
+        }
+        return ret;
+      }
+      var primitive = formatPrimitive(ctx, value);
+      if (primitive) {
+        return primitive;
+      }
+      var keys = Object.keys(value);
+      var visibleKeys = arrayToHash(keys);
+      if (ctx.showHidden) {
+        keys = Object.getOwnPropertyNames(value);
+      }
+      if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) {
+        return formatError(value);
+      }
+      if (keys.length === 0) {
+        if (isFunction(value)) {
+          var name = value.name ? ": " + value.name : "";
+          return ctx.stylize("[Function" + name + "]", "special");
+        }
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+        }
+        if (isDate(value)) {
+          return ctx.stylize(Date.prototype.toString.call(value), "date");
+        }
+        if (isError(value)) {
+          return formatError(value);
+        }
+      }
+      var base = "", array = false, braces = ["{", "}"];
+      if (isArray(value)) {
+        array = true;
+        braces = ["[", "]"];
+      }
+      if (isFunction(value)) {
+        var n = value.name ? ": " + value.name : "";
+        base = " [Function" + n + "]";
+      }
+      if (isRegExp(value)) {
+        base = " " + RegExp.prototype.toString.call(value);
+      }
+      if (isDate(value)) {
+        base = " " + Date.prototype.toUTCString.call(value);
+      }
+      if (isError(value)) {
+        base = " " + formatError(value);
+      }
+      if (keys.length === 0 && (!array || value.length == 0)) {
+        return braces[0] + base + braces[1];
+      }
+      if (recurseTimes < 0) {
+        if (isRegExp(value)) {
+          return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+        } else {
+          return ctx.stylize("[Object]", "special");
+        }
+      }
+      ctx.seen.push(value);
+      var output;
+      if (array) {
+        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+      } else {
+        output = keys.map(function(key) {
+          return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+        });
+      }
+      ctx.seen.pop();
+      return reduceToSingleString(output, base, braces);
+    }
+    function formatPrimitive(ctx, value) {
+      if (isUndefined(value))
+        return ctx.stylize("undefined", "undefined");
+      if (isString(value)) {
+        var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+        return ctx.stylize(simple, "string");
+      }
+      if (isNumber(value))
+        return ctx.stylize("" + value, "number");
+      if (isBoolean(value))
+        return ctx.stylize("" + value, "boolean");
+      if (isNull(value))
+        return ctx.stylize("null", "null");
+    }
+    function formatError(value) {
+      return "[" + Error.prototype.toString.call(value) + "]";
+    }
+    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+      var output = [];
+      for (var i = 0, l = value.length; i < l; ++i) {
+        if (hasOwnProperty(value, String(i))) {
+          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+        } else {
+          output.push("");
+        }
+      }
+      keys.forEach(function(key) {
+        if (!key.match(/^\d+$/)) {
+          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+        }
+      });
+      return output;
+    }
+    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+      var name, str, desc;
+      desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+      if (desc.get) {
+        if (desc.set) {
+          str = ctx.stylize("[Getter/Setter]", "special");
+        } else {
+          str = ctx.stylize("[Getter]", "special");
+        }
+      } else {
+        if (desc.set) {
+          str = ctx.stylize("[Setter]", "special");
+        }
+      }
+      if (!hasOwnProperty(visibleKeys, key)) {
+        name = "[" + key + "]";
+      }
+      if (!str) {
+        if (ctx.seen.indexOf(desc.value) < 0) {
+          if (isNull(recurseTimes)) {
+            str = formatValue(ctx, desc.value, null);
+          } else {
+            str = formatValue(ctx, desc.value, recurseTimes - 1);
+          }
+          if (str.indexOf("\n") > -1) {
+            if (array) {
+              str = str.split("\n").map(function(line) {
+                return "  " + line;
+              }).join("\n").substr(2);
+            } else {
+              str = "\n" + str.split("\n").map(function(line) {
+                return "   " + line;
+              }).join("\n");
+            }
+          }
+        } else {
+          str = ctx.stylize("[Circular]", "special");
+        }
+      }
+      if (isUndefined(name)) {
+        if (array && key.match(/^\d+$/)) {
+          return str;
+        }
+        name = JSON.stringify("" + key);
+        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+          name = name.substr(1, name.length - 2);
+          name = ctx.stylize(name, "name");
+        } else {
+          name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
+          name = ctx.stylize(name, "string");
+        }
+      }
+      return name + ": " + str;
+    }
+    function reduceToSingleString(output, base, braces) {
+      var numLinesEst = 0;
+      var length = output.reduce(function(prev, cur) {
+        numLinesEst++;
+        if (cur.indexOf("\n") >= 0)
+          numLinesEst++;
+        return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+      }, 0);
+      if (length > 60) {
+        return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
+      }
+      return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+    }
+    exports2.types = require_types();
+    function isArray(ar) {
+      return Array.isArray(ar);
+    }
+    exports2.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports2.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports2.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports2.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports2.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports2.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports2.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports2.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return isObject(re) && objectToString(re) === "[object RegExp]";
+    }
+    exports2.isRegExp = isRegExp;
+    exports2.types.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports2.isObject = isObject;
+    function isDate(d) {
+      return isObject(d) && objectToString(d) === "[object Date]";
+    }
+    exports2.isDate = isDate;
+    exports2.types.isDate = isDate;
+    function isError(e) {
+      return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+    }
+    exports2.isError = isError;
+    exports2.types.isNativeError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports2.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg === "undefined";
+    }
+    exports2.isPrimitive = isPrimitive;
+    exports2.isBuffer = require_isBufferBrowser();
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+    function pad(n) {
+      return n < 10 ? "0" + n.toString(10) : n.toString(10);
+    }
+    var months = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ];
+    function timestamp() {
+      var d = new Date();
+      var time = [
+        pad(d.getHours()),
+        pad(d.getMinutes()),
+        pad(d.getSeconds())
+      ].join(":");
+      return [d.getDate(), months[d.getMonth()], time].join(" ");
+    }
+    exports2.log = function() {
+      console.log("%s - %s", timestamp(), exports2.format.apply(exports2, arguments));
+    };
+    exports2.inherits = require_inherits_browser();
+    exports2._extend = function(origin, add) {
+      if (!add || !isObject(add))
+        return origin;
+      var keys = Object.keys(add);
+      var i = keys.length;
+      while (i--) {
+        origin[keys[i]] = add[keys[i]];
+      }
+      return origin;
+    };
+    function hasOwnProperty(obj, prop) {
+      return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+    var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+    exports2.promisify = function promisify(original) {
+      if (typeof original !== "function")
+        throw new TypeError('The "original" argument must be of type Function');
+      if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+        var fn = original[kCustomPromisifiedSymbol];
+        if (typeof fn !== "function") {
+          throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+        }
+        Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+          value: fn,
+          enumerable: false,
+          writable: false,
+          configurable: true
+        });
+        return fn;
+      }
+      function fn() {
+        var promiseResolve, promiseReject;
+        var promise = new Promise(function(resolve, reject) {
+          promiseResolve = resolve;
+          promiseReject = reject;
+        });
+        var args = [];
+        for (var i = 0; i < arguments.length; i++) {
+          args.push(arguments[i]);
+        }
+        args.push(function(err, value) {
+          if (err) {
+            promiseReject(err);
+          } else {
+            promiseResolve(value);
+          }
+        });
+        try {
+          original.apply(this, args);
+        } catch (err) {
+          promiseReject(err);
+        }
+        return promise;
+      }
+      Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+      if (kCustomPromisifiedSymbol)
+        Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+          value: fn,
+          enumerable: false,
+          writable: false,
+          configurable: true
+        });
+      return Object.defineProperties(fn, getOwnPropertyDescriptors(original));
+    };
+    exports2.promisify.custom = kCustomPromisifiedSymbol;
+    function callbackifyOnRejected(reason, cb) {
+      if (!reason) {
+        var newReason = new Error("Promise was rejected with a falsy value");
+        newReason.reason = reason;
+        reason = newReason;
+      }
+      return cb(reason);
+    }
+    function callbackify(original) {
+      if (typeof original !== "function") {
+        throw new TypeError('The "original" argument must be of type Function');
+      }
+      function callbackified() {
+        var args = [];
+        for (var i = 0; i < arguments.length; i++) {
+          args.push(arguments[i]);
+        }
+        var maybeCb = args.pop();
+        if (typeof maybeCb !== "function") {
+          throw new TypeError("The last argument must be of type Function");
+        }
+        var self2 = this;
+        var cb = function() {
+          return maybeCb.apply(self2, arguments);
+        };
+        original.apply(this, args).then(function(ret) {
+          process.nextTick(cb.bind(null, null, ret));
+        }, function(rej) {
+          process.nextTick(callbackifyOnRejected.bind(null, rej, cb));
+        });
+      }
+      Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+      Object.defineProperties(callbackified, getOwnPropertyDescriptors(original));
+      return callbackified;
+    }
+    exports2.callbackify = callbackify;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js
+var require_errors = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js"(exports2, module2) {
+    "use strict";
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      }
+      return _assertThisInitialized(self2);
+    }
+    function _assertThisInitialized(self2) {
+      if (self2 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self2;
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      };
+      return _getPrototypeOf(o);
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      if (superClass)
+        _setPrototypeOf(subClass, superClass);
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    var codes = {};
+    var assert5;
+    var util;
+    function createErrorType(code, message, Base) {
+      if (!Base) {
+        Base = Error;
+      }
+      function getMessage(arg1, arg2, arg3) {
+        if (typeof message === "string") {
+          return message;
+        } else {
+          return message(arg1, arg2, arg3);
+        }
+      }
+      var NodeError = /* @__PURE__ */ function(_Base) {
+        _inherits(NodeError2, _Base);
+        function NodeError2(arg1, arg2, arg3) {
+          var _this;
+          _classCallCheck(this, NodeError2);
+          _this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError2).call(this, getMessage(arg1, arg2, arg3)));
+          _this.code = code;
+          return _this;
+        }
+        return NodeError2;
+      }(Base);
+      codes[code] = NodeError;
+    }
+    function oneOf(expected, thing) {
+      if (Array.isArray(expected)) {
+        var len = expected.length;
+        expected = expected.map(function(i) {
+          return String(i);
+        });
+        if (len > 2) {
+          return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
+        } else if (len === 2) {
+          return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+        } else {
+          return "of ".concat(thing, " ").concat(expected[0]);
+        }
+      } else {
+        return "of ".concat(thing, " ").concat(String(expected));
+      }
+    }
+    function startsWith(str, search, pos) {
+      return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+    }
+    function endsWith(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function includes(str, search, start) {
+      if (typeof start !== "number") {
+        start = 0;
+      }
+      if (start + search.length > str.length) {
+        return false;
+      } else {
+        return str.indexOf(search, start) !== -1;
+      }
+    }
+    createErrorType("ERR_AMBIGUOUS_ARGUMENT", 'The "%s" argument is ambiguous. %s', TypeError);
+    createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
+      if (assert5 === void 0)
+        assert5 = require_assert();
+      assert5(typeof name === "string", "'name' must be a string");
+      var determiner;
+      if (typeof expected === "string" && startsWith(expected, "not ")) {
+        determiner = "must not be";
+        expected = expected.replace(/^not /, "");
+      } else {
+        determiner = "must be";
+      }
+      var msg;
+      if (endsWith(name, " argument")) {
+        msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+      } else {
+        var type = includes(name, ".") ? "property" : "argument";
+        msg = 'The "'.concat(name, '" ').concat(type, " ").concat(determiner, " ").concat(oneOf(expected, "type"));
+      }
+      msg += ". Received type ".concat(_typeof(actual));
+      return msg;
+    }, TypeError);
+    createErrorType("ERR_INVALID_ARG_VALUE", function(name, value) {
+      var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
+      if (util === void 0)
+        util = require_util();
+      var inspected = util.inspect(value);
+      if (inspected.length > 128) {
+        inspected = "".concat(inspected.slice(0, 128), "...");
+      }
+      return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
+    }, TypeError, RangeError);
+    createErrorType("ERR_INVALID_RETURN_VALUE", function(input, name, value) {
+      var type;
+      if (value && value.constructor && value.constructor.name) {
+        type = "instance of ".concat(value.constructor.name);
+      } else {
+        type = "type ".concat(_typeof(value));
+      }
+      return "Expected ".concat(input, ' to be returned from the "').concat(name, '"') + " function but got ".concat(type, ".");
+    }, TypeError);
+    createErrorType("ERR_MISSING_ARGS", function() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (assert5 === void 0)
+        assert5 = require_assert();
+      assert5(args.length > 0, "At least one arg needs to be specified");
+      var msg = "The ";
+      var len = args.length;
+      args = args.map(function(a) {
+        return '"'.concat(a, '"');
+      });
+      switch (len) {
+        case 1:
+          msg += "".concat(args[0], " argument");
+          break;
+        case 2:
+          msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+          break;
+        default:
+          msg += args.slice(0, len - 1).join(", ");
+          msg += ", and ".concat(args[len - 1], " arguments");
+          break;
+      }
+      return "".concat(msg, " must be specified");
+    }, TypeError);
+    module2.exports.codes = codes;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js
+var require_assertion_error = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js"(exports2, module2) {
+    "use strict";
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+          ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+          }));
+        }
+        ownKeys.forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        });
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor)
+          descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps)
+        _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps)
+        _defineProperties(Constructor, staticProps);
+      return Constructor;
+    }
+    function _possibleConstructorReturn(self2, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      }
+      return _assertThisInitialized(self2);
+    }
+    function _assertThisInitialized(self2) {
+      if (self2 === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self2;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      if (superClass)
+        _setPrototypeOf(subClass, superClass);
+    }
+    function _wrapNativeSuper(Class) {
+      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
+        if (Class2 === null || !_isNativeFunction(Class2))
+          return Class2;
+        if (typeof Class2 !== "function") {
+          throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+          if (_cache.has(Class2))
+            return _cache.get(Class2);
+          _cache.set(Class2, Wrapper);
+        }
+        function Wrapper() {
+          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+        return _setPrototypeOf(Wrapper, Class2);
+      };
+      return _wrapNativeSuper(Class);
+    }
+    function isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct)
+        return false;
+      if (Reflect.construct.sham)
+        return false;
+      if (typeof Proxy === "function")
+        return true;
+      try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    function _construct(Parent, args, Class) {
+      if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+      } else {
+        _construct = function _construct2(Parent2, args2, Class2) {
+          var a = [null];
+          a.push.apply(a, args2);
+          var Constructor = Function.bind.apply(Parent2, a);
+          var instance = new Constructor();
+          if (Class2)
+            _setPrototypeOf(instance, Class2.prototype);
+          return instance;
+        };
+      }
+      return _construct.apply(null, arguments);
+    }
+    function _isNativeFunction(fn) {
+      return Function.toString.call(fn).indexOf("[native code]") !== -1;
+    }
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      };
+      return _setPrototypeOf(o, p);
+    }
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      };
+      return _getPrototypeOf(o);
+    }
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    var _require = require_util();
+    var inspect = _require.inspect;
+    var _require2 = require_errors();
+    var ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
+    function endsWith(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function repeat(str, count) {
+      count = Math.floor(count);
+      if (str.length == 0 || count == 0)
+        return "";
+      var maxCount = str.length * count;
+      count = Math.floor(Math.log(count) / Math.log(2));
+      while (count) {
+        str += str;
+        count--;
+      }
+      str += str.substring(0, maxCount - str.length);
+      return str;
+    }
+    var blue = "";
+    var green = "";
+    var red = "";
+    var white = "";
+    var kReadableOperator = {
+      deepStrictEqual: "Expected values to be strictly deep-equal:",
+      strictEqual: "Expected values to be strictly equal:",
+      strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
+      deepEqual: "Expected values to be loosely deep-equal:",
+      equal: "Expected values to be loosely equal:",
+      notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
+      notStrictEqual: 'Expected "actual" to be strictly unequal to:',
+      notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
+      notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
+      notEqual: 'Expected "actual" to be loosely unequal to:',
+      notIdentical: "Values identical but not reference-equal:"
+    };
+    var kMaxShortLength = 10;
+    function copyError(source) {
+      var keys = Object.keys(source);
+      var target = Object.create(Object.getPrototypeOf(source));
+      keys.forEach(function(key) {
+        target[key] = source[key];
+      });
+      Object.defineProperty(target, "message", {
+        value: source.message
+      });
+      return target;
+    }
+    function inspectValue(val) {
+      return inspect(val, {
+        compact: false,
+        customInspect: false,
+        depth: 1e3,
+        maxArrayLength: Infinity,
+        showHidden: false,
+        breakLength: Infinity,
+        showProxy: false,
+        sorted: true,
+        getters: true
+      });
+    }
+    function createErrDiff(actual, expected, operator) {
+      var other = "";
+      var res = "";
+      var lastPos = 0;
+      var end = "";
+      var skipped = false;
+      var actualInspected = inspectValue(actual);
+      var actualLines = actualInspected.split("\n");
+      var expectedLines = inspectValue(expected).split("\n");
+      var i = 0;
+      var indicator = "";
+      if (operator === "strictEqual" && _typeof(actual) === "object" && _typeof(expected) === "object" && actual !== null && expected !== null) {
+        operator = "strictEqualObject";
+      }
+      if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
+        var inputLength = actualLines[0].length + expectedLines[0].length;
+        if (inputLength <= kMaxShortLength) {
+          if ((_typeof(actual) !== "object" || actual === null) && (_typeof(expected) !== "object" || expected === null) && (actual !== 0 || expected !== 0)) {
+            return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
+          }
+        } else if (operator !== "strictEqualObject") {
+          var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
+          if (inputLength < maxLength) {
+            while (actualLines[0][i] === expectedLines[0][i]) {
+              i++;
+            }
+            if (i > 2) {
+              indicator = "\n  ".concat(repeat(" ", i), "^");
+              i = 0;
+            }
+          }
+        }
+      }
+      var a = actualLines[actualLines.length - 1];
+      var b = expectedLines[expectedLines.length - 1];
+      while (a === b) {
+        if (i++ < 2) {
+          end = "\n  ".concat(a).concat(end);
+        } else {
+          other = a;
+        }
+        actualLines.pop();
+        expectedLines.pop();
+        if (actualLines.length === 0 || expectedLines.length === 0)
+          break;
+        a = actualLines[actualLines.length - 1];
+        b = expectedLines[expectedLines.length - 1];
+      }
+      var maxLines = Math.max(actualLines.length, expectedLines.length);
+      if (maxLines === 0) {
+        var _actualLines = actualInspected.split("\n");
+        if (_actualLines.length > 30) {
+          _actualLines[26] = "".concat(blue, "...").concat(white);
+          while (_actualLines.length > 27) {
+            _actualLines.pop();
+          }
+        }
+        return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join("\n"), "\n");
+      }
+      if (i > 3) {
+        end = "\n".concat(blue, "...").concat(white).concat(end);
+        skipped = true;
+      }
+      if (other !== "") {
+        end = "\n  ".concat(other).concat(end);
+        other = "";
+      }
+      var printedLines = 0;
+      var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
+      var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
+      for (i = 0; i < maxLines; i++) {
+        var cur = i - lastPos;
+        if (actualLines.length < i + 1) {
+          if (cur > 1 && i > 2) {
+            if (cur > 4) {
+              res += "\n".concat(blue, "...").concat(white);
+              skipped = true;
+            } else if (cur > 3) {
+              res += "\n  ".concat(expectedLines[i - 2]);
+              printedLines++;
+            }
+            res += "\n  ".concat(expectedLines[i - 1]);
+            printedLines++;
+          }
+          lastPos = i;
+          other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]);
+          printedLines++;
+        } else if (expectedLines.length < i + 1) {
+          if (cur > 1 && i > 2) {
+            if (cur > 4) {
+              res += "\n".concat(blue, "...").concat(white);
+              skipped = true;
+            } else if (cur > 3) {
+              res += "\n  ".concat(actualLines[i - 2]);
+              printedLines++;
+            }
+            res += "\n  ".concat(actualLines[i - 1]);
+            printedLines++;
+          }
+          lastPos = i;
+          res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]);
+          printedLines++;
+        } else {
+          var expectedLine = expectedLines[i];
+          var actualLine = actualLines[i];
+          var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ",") || actualLine.slice(0, -1) !== expectedLine);
+          if (divergingLines && endsWith(expectedLine, ",") && expectedLine.slice(0, -1) === actualLine) {
+            divergingLines = false;
+            actualLine += ",";
+          }
+          if (divergingLines) {
+            if (cur > 1 && i > 2) {
+              if (cur > 4) {
+                res += "\n".concat(blue, "...").concat(white);
+                skipped = true;
+              } else if (cur > 3) {
+                res += "\n  ".concat(actualLines[i - 2]);
+                printedLines++;
+              }
+              res += "\n  ".concat(actualLines[i - 1]);
+              printedLines++;
+            }
+            lastPos = i;
+            res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
+            other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
+            printedLines += 2;
+          } else {
+            res += other;
+            other = "";
+            if (cur === 1 || i === 0) {
+              res += "\n  ".concat(actualLine);
+              printedLines++;
+            }
+          }
+        }
+        if (printedLines > 20 && i < maxLines - 2) {
+          return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
+        }
+      }
+      return "".concat(msg).concat(skipped ? skippedMsg : "", "\n").concat(res).concat(other).concat(end).concat(indicator);
+    }
+    var AssertionError = /* @__PURE__ */ function(_Error) {
+      _inherits(AssertionError2, _Error);
+      function AssertionError2(options) {
+        var _this;
+        _classCallCheck(this, AssertionError2);
+        if (_typeof(options) !== "object" || options === null) {
+          throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+        }
+        var message = options.message, operator = options.operator, stackStartFn = options.stackStartFn;
+        var actual = options.actual, expected = options.expected;
+        var limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 0;
+        if (message != null) {
+          _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, String(message)));
+        } else {
+          if (process.stderr && process.stderr.isTTY) {
+            if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {
+              blue = "\x1B[34m";
+              green = "\x1B[32m";
+              white = "\x1B[39m";
+              red = "\x1B[31m";
+            } else {
+              blue = "";
+              green = "";
+              white = "";
+              red = "";
+            }
+          }
+          if (_typeof(actual) === "object" && actual !== null && _typeof(expected) === "object" && expected !== null && "stack" in actual && actual instanceof Error && "stack" in expected && expected instanceof Error) {
+            actual = copyError(actual);
+            expected = copyError(expected);
+          }
+          if (operator === "deepStrictEqual" || operator === "strictEqual") {
+            _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, createErrDiff(actual, expected, operator)));
+          } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
+            var base = kReadableOperator[operator];
+            var res = inspectValue(actual).split("\n");
+            if (operator === "notStrictEqual" && _typeof(actual) === "object" && actual !== null) {
+              base = kReadableOperator.notStrictEqualObject;
+            }
+            if (res.length > 30) {
+              res[26] = "".concat(blue, "...").concat(white);
+              while (res.length > 27) {
+                res.pop();
+              }
+            }
+            if (res.length === 1) {
+              _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, "".concat(base, " ").concat(res[0])));
+            } else {
+              _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, "".concat(base, "\n\n").concat(res.join("\n"), "\n")));
+            }
+          } else {
+            var _res = inspectValue(actual);
+            var other = "";
+            var knownOperators = kReadableOperator[operator];
+            if (operator === "notDeepEqual" || operator === "notEqual") {
+              _res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
+              if (_res.length > 1024) {
+                _res = "".concat(_res.slice(0, 1021), "...");
+              }
+            } else {
+              other = "".concat(inspectValue(expected));
+              if (_res.length > 512) {
+                _res = "".concat(_res.slice(0, 509), "...");
+              }
+              if (other.length > 512) {
+                other = "".concat(other.slice(0, 509), "...");
+              }
+              if (operator === "deepEqual" || operator === "equal") {
+                _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
+              } else {
+                other = " ".concat(operator, " ").concat(other);
+              }
+            }
+            _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, "".concat(_res).concat(other)));
+          }
+        }
+        Error.stackTraceLimit = limit;
+        _this.generatedMessage = !message;
+        Object.defineProperty(_assertThisInitialized(_this), "name", {
+          value: "AssertionError [ERR_ASSERTION]",
+          enumerable: false,
+          writable: true,
+          configurable: true
+        });
+        _this.code = "ERR_ASSERTION";
+        _this.actual = actual;
+        _this.expected = expected;
+        _this.operator = operator;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
+        }
+        _this.stack;
+        _this.name = "AssertionError";
+        return _possibleConstructorReturn(_this);
+      }
+      _createClass(AssertionError2, [{
+        key: "toString",
+        value: function toString() {
+          return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
+        }
+      }, {
+        key: inspect.custom,
+        value: function value(recurseTimes, ctx) {
+          return inspect(this, _objectSpread({}, ctx, {
+            customInspect: false,
+            depth: 0
+          }));
+        }
+      }]);
+      return AssertionError2;
+    }(_wrapNativeSuper(Error));
+    module2.exports = AssertionError;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js
+var require_es6_object_assign = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js"(exports2, module2) {
+    "use strict";
+    function assign(target, firstSource) {
+      if (target === void 0 || target === null) {
+        throw new TypeError("Cannot convert first argument to object");
+      }
+      var to = Object(target);
+      for (var i = 1; i < arguments.length; i++) {
+        var nextSource = arguments[i];
+        if (nextSource === void 0 || nextSource === null) {
+          continue;
+        }
+        var keysArray = Object.keys(Object(nextSource));
+        for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
+          var nextKey = keysArray[nextIndex];
+          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+          if (desc !== void 0 && desc.enumerable) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+      return to;
+    }
+    function polyfill() {
+      if (!Object.assign) {
+        Object.defineProperty(Object, "assign", {
+          enumerable: false,
+          configurable: true,
+          writable: true,
+          value: assign
+        });
+      }
+    }
+    module2.exports = {
+      assign,
+      polyfill
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
+var require_isArguments = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js"(exports2, module2) {
+    "use strict";
+    var toStr = Object.prototype.toString;
+    module2.exports = function isArguments(value) {
+      var str = toStr.call(value);
+      var isArgs = str === "[object Arguments]";
+      if (!isArgs) {
+        isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+      }
+      return isArgs;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
+var require_implementation2 = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js"(exports2, module2) {
+    "use strict";
+    var keysShim;
+    if (!Object.keys) {
+      has = Object.prototype.hasOwnProperty;
+      toStr = Object.prototype.toString;
+      isArgs = require_isArguments();
+      isEnumerable = Object.prototype.propertyIsEnumerable;
+      hasDontEnumBug = !isEnumerable.call({ toString: null }, "toString");
+      hasProtoEnumBug = isEnumerable.call(function() {
+      }, "prototype");
+      dontEnums = [
+        "toString",
+        "toLocaleString",
+        "valueOf",
+        "hasOwnProperty",
+        "isPrototypeOf",
+        "propertyIsEnumerable",
+        "constructor"
+      ];
+      equalsConstructorPrototype = function(o) {
+        var ctor = o.constructor;
+        return ctor && ctor.prototype === o;
+      };
+      excludedKeys = {
+        $applicationCache: true,
+        $console: true,
+        $external: true,
+        $frame: true,
+        $frameElement: true,
+        $frames: true,
+        $innerHeight: true,
+        $innerWidth: true,
+        $onmozfullscreenchange: true,
+        $onmozfullscreenerror: true,
+        $outerHeight: true,
+        $outerWidth: true,
+        $pageXOffset: true,
+        $pageYOffset: true,
+        $parent: true,
+        $scrollLeft: true,
+        $scrollTop: true,
+        $scrollX: true,
+        $scrollY: true,
+        $self: true,
+        $webkitIndexedDB: true,
+        $webkitStorageInfo: true,
+        $window: true
+      };
+      hasAutomationEqualityBug = function() {
+        if (typeof window === "undefined") {
+          return false;
+        }
+        for (var k in window) {
+          try {
+            if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
+              try {
+                equalsConstructorPrototype(window[k]);
+              } catch (e) {
+                return true;
+              }
+            }
+          } catch (e) {
+            return true;
+          }
+        }
+        return false;
+      }();
+      equalsConstructorPrototypeIfNotBuggy = function(o) {
+        if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+          return equalsConstructorPrototype(o);
+        }
+        try {
+          return equalsConstructorPrototype(o);
+        } catch (e) {
+          return false;
+        }
+      };
+      keysShim = function keys(object) {
+        var isObject = object !== null && typeof object === "object";
+        var isFunction = toStr.call(object) === "[object Function]";
+        var isArguments = isArgs(object);
+        var isString = isObject && toStr.call(object) === "[object String]";
+        var theKeys = [];
+        if (!isObject && !isFunction && !isArguments) {
+          throw new TypeError("Object.keys called on a non-object");
+        }
+        var skipProto = hasProtoEnumBug && isFunction;
+        if (isString && object.length > 0 && !has.call(object, 0)) {
+          for (var i = 0; i < object.length; ++i) {
+            theKeys.push(String(i));
+          }
+        }
+        if (isArguments && object.length > 0) {
+          for (var j = 0; j < object.length; ++j) {
+            theKeys.push(String(j));
+          }
+        } else {
+          for (var name in object) {
+            if (!(skipProto && name === "prototype") && has.call(object, name)) {
+              theKeys.push(String(name));
+            }
+          }
+        }
+        if (hasDontEnumBug) {
+          var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+          for (var k = 0; k < dontEnums.length; ++k) {
+            if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
+              theKeys.push(dontEnums[k]);
+            }
+          }
+        }
+        return theKeys;
+      };
+    }
+    var has;
+    var toStr;
+    var isArgs;
+    var isEnumerable;
+    var hasDontEnumBug;
+    var hasProtoEnumBug;
+    var dontEnums;
+    var equalsConstructorPrototype;
+    var excludedKeys;
+    var hasAutomationEqualityBug;
+    var equalsConstructorPrototypeIfNotBuggy;
+    module2.exports = keysShim;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js
+var require_object_keys = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js"(exports2, module2) {
+    "use strict";
+    var slice = Array.prototype.slice;
+    var isArgs = require_isArguments();
+    var origKeys = Object.keys;
+    var keysShim = origKeys ? function keys(o) {
+      return origKeys(o);
+    } : require_implementation2();
+    var originalKeys = Object.keys;
+    keysShim.shim = function shimObjectKeys() {
+      if (Object.keys) {
+        var keysWorksWithArguments = function() {
+          var args = Object.keys(arguments);
+          return args && args.length === arguments.length;
+        }(1, 2);
+        if (!keysWorksWithArguments) {
+          Object.keys = function keys(object) {
+            if (isArgs(object)) {
+              return originalKeys(slice.call(object));
+            }
+            return originalKeys(object);
+          };
+        }
+      } else {
+        Object.keys = keysShim;
+      }
+      return Object.keys || keysShim;
+    };
+    module2.exports = keysShim;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/define-properties@1.1.3/node_modules/define-properties/index.js
+var require_define_properties = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/define-properties@1.1.3/node_modules/define-properties/index.js"(exports2, module2) {
+    "use strict";
+    var keys = require_object_keys();
+    var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+    var toStr = Object.prototype.toString;
+    var concat = Array.prototype.concat;
+    var origDefineProperty = Object.defineProperty;
+    var isFunction = function(fn) {
+      return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+    };
+    var arePropertyDescriptorsSupported = function() {
+      var obj = {};
+      try {
+        origDefineProperty(obj, "x", { enumerable: false, value: obj });
+        for (var _ in obj) {
+          return false;
+        }
+        return obj.x === obj;
+      } catch (e) {
+        return false;
+      }
+    };
+    var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
+    var defineProperty = function(object, name, value, predicate) {
+      if (name in object && (!isFunction(predicate) || !predicate())) {
+        return;
+      }
+      if (supportsDescriptors) {
+        origDefineProperty(object, name, {
+          configurable: true,
+          enumerable: false,
+          value,
+          writable: true
+        });
+      } else {
+        object[name] = value;
+      }
+    };
+    var defineProperties = function(object, map) {
+      var predicates = arguments.length > 2 ? arguments[2] : {};
+      var props = keys(map);
+      if (hasSymbols) {
+        props = concat.call(props, Object.getOwnPropertySymbols(map));
+      }
+      for (var i = 0; i < props.length; i += 1) {
+        defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+      }
+    };
+    defineProperties.supportsDescriptors = !!supportsDescriptors;
+    module2.exports = defineProperties;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js
+var require_implementation3 = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js"(exports2, module2) {
+    "use strict";
+    var numberIsNaN = function(value) {
+      return value !== value;
+    };
+    module2.exports = function is(a, b) {
+      if (a === 0 && b === 0) {
+        return 1 / a === 1 / b;
+      }
+      if (a === b) {
+        return true;
+      }
+      if (numberIsNaN(a) && numberIsNaN(b)) {
+        return true;
+      }
+      return false;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js
+var require_polyfill = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation3();
+    module2.exports = function getPolyfill() {
+      return typeof Object.is === "function" ? Object.is : implementation;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js
+var require_shim = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js"(exports2, module2) {
+    "use strict";
+    var getPolyfill = require_polyfill();
+    var define = require_define_properties();
+    module2.exports = function shimObjectIs() {
+      var polyfill = getPolyfill();
+      define(Object, { is: polyfill }, {
+        is: function testObjectIs() {
+          return Object.is !== polyfill;
+        }
+      });
+      return polyfill;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js
+var require_object_is = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js"(exports2, module2) {
+    "use strict";
+    var define = require_define_properties();
+    var callBind = require_call_bind();
+    var implementation = require_implementation3();
+    var getPolyfill = require_polyfill();
+    var shim = require_shim();
+    var polyfill = callBind(getPolyfill(), Object);
+    define(polyfill, {
+      getPolyfill,
+      implementation,
+      shim
+    });
+    module2.exports = polyfill;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js
+var require_implementation4 = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function isNaN2(value) {
+      return value !== value;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js
+var require_polyfill2 = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js"(exports2, module2) {
+    "use strict";
+    var implementation = require_implementation4();
+    module2.exports = function getPolyfill() {
+      if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a")) {
+        return Number.isNaN;
+      }
+      return implementation;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js
+var require_shim2 = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js"(exports2, module2) {
+    "use strict";
+    var define = require_define_properties();
+    var getPolyfill = require_polyfill2();
+    module2.exports = function shimNumberIsNaN() {
+      var polyfill = getPolyfill();
+      define(Number, { isNaN: polyfill }, {
+        isNaN: function testIsNaN() {
+          return Number.isNaN !== polyfill;
+        }
+      });
+      return polyfill;
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js
+var require_is_nan = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js"(exports2, module2) {
+    "use strict";
+    var callBind = require_call_bind();
+    var define = require_define_properties();
+    var implementation = require_implementation4();
+    var getPolyfill = require_polyfill2();
+    var shim = require_shim2();
+    var polyfill = callBind(getPolyfill(), Number);
+    define(polyfill, {
+      getPolyfill,
+      implementation,
+      shim
+    });
+    module2.exports = polyfill;
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js
+var require_comparisons = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js"(exports2, module2) {
+    "use strict";
+    function _slicedToArray(arr, i) {
+      return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+    }
+    function _nonIterableRest() {
+      throw new TypeError("Invalid attempt to destructure non-iterable instance");
+    }
+    function _iterableToArrayLimit(arr, i) {
+      var _arr = [];
+      var _n = true;
+      var _d = false;
+      var _e = void 0;
+      try {
+        for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+          _arr.push(_s.value);
+          if (i && _arr.length === i)
+            break;
+        }
+      } catch (err) {
+        _d = true;
+        _e = err;
+      } finally {
+        try {
+          if (!_n && _i["return"] != null)
+            _i["return"]();
+        } finally {
+          if (_d)
+            throw _e;
+        }
+      }
+      return _arr;
+    }
+    function _arrayWithHoles(arr) {
+      if (Array.isArray(arr))
+        return arr;
+    }
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    var regexFlagsSupported = /a/g.flags !== void 0;
+    var arrayFromSet = function arrayFromSet2(set) {
+      var array = [];
+      set.forEach(function(value) {
+        return array.push(value);
+      });
+      return array;
+    };
+    var arrayFromMap = function arrayFromMap2(map) {
+      var array = [];
+      map.forEach(function(value, key) {
+        return array.push([key, value]);
+      });
+      return array;
+    };
+    var objectIs = Object.is ? Object.is : require_object_is();
+    var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
+      return [];
+    };
+    var numberIsNaN = Number.isNaN ? Number.isNaN : require_is_nan();
+    function uncurryThis(f) {
+      return f.call.bind(f);
+    }
+    var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+    var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
+    var objectToString = uncurryThis(Object.prototype.toString);
+    var _require$types = require_util().types;
+    var isAnyArrayBuffer = _require$types.isAnyArrayBuffer;
+    var isArrayBufferView = _require$types.isArrayBufferView;
+    var isDate = _require$types.isDate;
+    var isMap = _require$types.isMap;
+    var isRegExp = _require$types.isRegExp;
+    var isSet = _require$types.isSet;
+    var isNativeError = _require$types.isNativeError;
+    var isBoxedPrimitive = _require$types.isBoxedPrimitive;
+    var isNumberObject = _require$types.isNumberObject;
+    var isStringObject = _require$types.isStringObject;
+    var isBooleanObject = _require$types.isBooleanObject;
+    var isBigIntObject = _require$types.isBigIntObject;
+    var isSymbolObject = _require$types.isSymbolObject;
+    var isFloat32Array = _require$types.isFloat32Array;
+    var isFloat64Array = _require$types.isFloat64Array;
+    function isNonIndex(key) {
+      if (key.length === 0 || key.length > 10)
+        return true;
+      for (var i = 0; i < key.length; i++) {
+        var code = key.charCodeAt(i);
+        if (code < 48 || code > 57)
+          return true;
+      }
+      return key.length === 10 && key >= Math.pow(2, 32);
+    }
+    function getOwnNonIndexProperties(value) {
+      return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
+    }
+    function compare(a, b) {
+      if (a === b) {
+        return 0;
+      }
+      var x = a.length;
+      var y = b.length;
+      for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+        if (a[i] !== b[i]) {
+          x = a[i];
+          y = b[i];
+          break;
+        }
+      }
+      if (x < y) {
+        return -1;
+      }
+      if (y < x) {
+        return 1;
+      }
+      return 0;
+    }
+    var ONLY_ENUMERABLE = void 0;
+    var kStrict = true;
+    var kLoose = false;
+    var kNoIterator = 0;
+    var kIsArray = 1;
+    var kIsSet = 2;
+    var kIsMap = 3;
+    function areSimilarRegExps(a, b) {
+      return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);
+    }
+    function areSimilarFloatArrays(a, b) {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      for (var offset = 0; offset < a.byteLength; offset++) {
+        if (a[offset] !== b[offset]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function areSimilarTypedArrays(a, b) {
+      if (a.byteLength !== b.byteLength) {
+        return false;
+      }
+      return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
+    }
+    function areEqualArrayBuffers(buf1, buf2) {
+      return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
+    }
+    function isEqualBoxedPrimitive(val1, val2) {
+      if (isNumberObject(val1)) {
+        return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));
+      }
+      if (isStringObject(val1)) {
+        return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);
+      }
+      if (isBooleanObject(val1)) {
+        return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);
+      }
+      if (isBigIntObject(val1)) {
+        return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);
+      }
+      return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
+    }
+    function innerDeepEqual(val1, val2, strict, memos) {
+      if (val1 === val2) {
+        if (val1 !== 0)
+          return true;
+        return strict ? objectIs(val1, val2) : true;
+      }
+      if (strict) {
+        if (_typeof(val1) !== "object") {
+          return typeof val1 === "number" && numberIsNaN(val1) && numberIsNaN(val2);
+        }
+        if (_typeof(val2) !== "object" || val1 === null || val2 === null) {
+          return false;
+        }
+        if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+          return false;
+        }
+      } else {
+        if (val1 === null || _typeof(val1) !== "object") {
+          if (val2 === null || _typeof(val2) !== "object") {
+            return val1 == val2;
+          }
+          return false;
+        }
+        if (val2 === null || _typeof(val2) !== "object") {
+          return false;
+        }
+      }
+      var val1Tag = objectToString(val1);
+      var val2Tag = objectToString(val2);
+      if (val1Tag !== val2Tag) {
+        return false;
+      }
+      if (Array.isArray(val1)) {
+        if (val1.length !== val2.length) {
+          return false;
+        }
+        var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+        var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+        if (keys1.length !== keys2.length) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
+      }
+      if (val1Tag === "[object Object]") {
+        if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {
+          return false;
+        }
+      }
+      if (isDate(val1)) {
+        if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {
+          return false;
+        }
+      } else if (isRegExp(val1)) {
+        if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
+          return false;
+        }
+      } else if (isNativeError(val1) || val1 instanceof Error) {
+        if (val1.message !== val2.message || val1.name !== val2.name) {
+          return false;
+        }
+      } else if (isArrayBufferView(val1)) {
+        if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
+          if (!areSimilarFloatArrays(val1, val2)) {
+            return false;
+          }
+        } else if (!areSimilarTypedArrays(val1, val2)) {
+          return false;
+        }
+        var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+        var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+        if (_keys.length !== _keys2.length) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
+      } else if (isSet(val1)) {
+        if (!isSet(val2) || val1.size !== val2.size) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsSet);
+      } else if (isMap(val1)) {
+        if (!isMap(val2) || val1.size !== val2.size) {
+          return false;
+        }
+        return keyCheck(val1, val2, strict, memos, kIsMap);
+      } else if (isAnyArrayBuffer(val1)) {
+        if (!areEqualArrayBuffers(val1, val2)) {
+          return false;
+        }
+      } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
+        return false;
+      }
+      return keyCheck(val1, val2, strict, memos, kNoIterator);
+    }
+    function getEnumerables(val, keys) {
+      return keys.filter(function(k) {
+        return propertyIsEnumerable(val, k);
+      });
+    }
+    function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
+      if (arguments.length === 5) {
+        aKeys = Object.keys(val1);
+        var bKeys = Object.keys(val2);
+        if (aKeys.length !== bKeys.length) {
+          return false;
+        }
+      }
+      var i = 0;
+      for (; i < aKeys.length; i++) {
+        if (!hasOwnProperty(val2, aKeys[i])) {
+          return false;
+        }
+      }
+      if (strict && arguments.length === 5) {
+        var symbolKeysA = objectGetOwnPropertySymbols(val1);
+        if (symbolKeysA.length !== 0) {
+          var count = 0;
+          for (i = 0; i < symbolKeysA.length; i++) {
+            var key = symbolKeysA[i];
+            if (propertyIsEnumerable(val1, key)) {
+              if (!propertyIsEnumerable(val2, key)) {
+                return false;
+              }
+              aKeys.push(key);
+              count++;
+            } else if (propertyIsEnumerable(val2, key)) {
+              return false;
+            }
+          }
+          var symbolKeysB = objectGetOwnPropertySymbols(val2);
+          if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {
+            return false;
+          }
+        } else {
+          var _symbolKeysB = objectGetOwnPropertySymbols(val2);
+          if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {
+            return false;
+          }
+        }
+      }
+      if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {
+        return true;
+      }
+      if (memos === void 0) {
+        memos = {
+          val1: /* @__PURE__ */ new Map(),
+          val2: /* @__PURE__ */ new Map(),
+          position: 0
+        };
+      } else {
+        var val2MemoA = memos.val1.get(val1);
+        if (val2MemoA !== void 0) {
+          var val2MemoB = memos.val2.get(val2);
+          if (val2MemoB !== void 0) {
+            return val2MemoA === val2MemoB;
+          }
+        }
+        memos.position++;
+      }
+      memos.val1.set(val1, memos.position);
+      memos.val2.set(val2, memos.position);
+      var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
+      memos.val1.delete(val1);
+      memos.val2.delete(val2);
+      return areEq;
+    }
+    function setHasEqualElement(set, val1, strict, memo) {
+      var setValues = arrayFromSet(set);
+      for (var i = 0; i < setValues.length; i++) {
+        var val2 = setValues[i];
+        if (innerDeepEqual(val1, val2, strict, memo)) {
+          set.delete(val2);
+          return true;
+        }
+      }
+      return false;
+    }
+    function findLooseMatchingPrimitives(prim) {
+      switch (_typeof(prim)) {
+        case "undefined":
+          return null;
+        case "object":
+          return void 0;
+        case "symbol":
+          return false;
+        case "string":
+          prim = +prim;
+        case "number":
+          if (numberIsNaN(prim)) {
+            return false;
+          }
+      }
+      return true;
+    }
+    function setMightHaveLoosePrim(a, b, prim) {
+      var altValue = findLooseMatchingPrimitives(prim);
+      if (altValue != null)
+        return altValue;
+      return b.has(altValue) && !a.has(altValue);
+    }
+    function mapMightHaveLoosePrim(a, b, prim, item, memo) {
+      var altValue = findLooseMatchingPrimitives(prim);
+      if (altValue != null) {
+        return altValue;
+      }
+      var curB = b.get(altValue);
+      if (curB === void 0 && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {
+        return false;
+      }
+      return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
+    }
+    function setEquiv(a, b, strict, memo) {
+      var set = null;
+      var aValues = arrayFromSet(a);
+      for (var i = 0; i < aValues.length; i++) {
+        var val = aValues[i];
+        if (_typeof(val) === "object" && val !== null) {
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(val);
+        } else if (!b.has(val)) {
+          if (strict)
+            return false;
+          if (!setMightHaveLoosePrim(a, b, val)) {
+            return false;
+          }
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(val);
+        }
+      }
+      if (set !== null) {
+        var bValues = arrayFromSet(b);
+        for (var _i = 0; _i < bValues.length; _i++) {
+          var _val = bValues[_i];
+          if (_typeof(_val) === "object" && _val !== null) {
+            if (!setHasEqualElement(set, _val, strict, memo))
+              return false;
+          } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {
+            return false;
+          }
+        }
+        return set.size === 0;
+      }
+      return true;
+    }
+    function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
+      var setValues = arrayFromSet(set);
+      for (var i = 0; i < setValues.length; i++) {
+        var key2 = setValues[i];
+        if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {
+          set.delete(key2);
+          return true;
+        }
+      }
+      return false;
+    }
+    function mapEquiv(a, b, strict, memo) {
+      var set = null;
+      var aEntries = arrayFromMap(a);
+      for (var i = 0; i < aEntries.length; i++) {
+        var _aEntries$i = _slicedToArray(aEntries[i], 2), key = _aEntries$i[0], item1 = _aEntries$i[1];
+        if (_typeof(key) === "object" && key !== null) {
+          if (set === null) {
+            set = /* @__PURE__ */ new Set();
+          }
+          set.add(key);
+        } else {
+          var item2 = b.get(key);
+          if (item2 === void 0 && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {
+            if (strict)
+              return false;
+            if (!mapMightHaveLoosePrim(a, b, key, item1, memo))
+              return false;
+            if (set === null) {
+              set = /* @__PURE__ */ new Set();
+            }
+            set.add(key);
+          }
+        }
+      }
+      if (set !== null) {
+        var bEntries = arrayFromMap(b);
+        for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
+          var _bEntries$_i = _slicedToArray(bEntries[_i2], 2), key = _bEntries$_i[0], item = _bEntries$_i[1];
+          if (_typeof(key) === "object" && key !== null) {
+            if (!mapHasEqualEntry(set, a, key, item, strict, memo))
+              return false;
+          } else if (!strict && (!a.has(key) || !innerDeepEqual(a.get(key), item, false, memo)) && !mapHasEqualEntry(set, a, key, item, false, memo)) {
+            return false;
+          }
+        }
+        return set.size === 0;
+      }
+      return true;
+    }
+    function objEquiv(a, b, strict, keys, memos, iterationType) {
+      var i = 0;
+      if (iterationType === kIsSet) {
+        if (!setEquiv(a, b, strict, memos)) {
+          return false;
+        }
+      } else if (iterationType === kIsMap) {
+        if (!mapEquiv(a, b, strict, memos)) {
+          return false;
+        }
+      } else if (iterationType === kIsArray) {
+        for (; i < a.length; i++) {
+          if (hasOwnProperty(a, i)) {
+            if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {
+              return false;
+            }
+          } else if (hasOwnProperty(b, i)) {
+            return false;
+          } else {
+            var keysA = Object.keys(a);
+            for (; i < keysA.length; i++) {
+              var key = keysA[i];
+              if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {
+                return false;
+              }
+            }
+            if (keysA.length !== Object.keys(b).length) {
+              return false;
+            }
+            return true;
+          }
+        }
+      }
+      for (i = 0; i < keys.length; i++) {
+        var _key = keys[i];
+        if (!innerDeepEqual(a[_key], b[_key], strict, memos)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function isDeepEqual(val1, val2) {
+      return innerDeepEqual(val1, val2, kLoose);
+    }
+    function isDeepStrictEqual(val1, val2) {
+      return innerDeepEqual(val1, val2, kStrict);
+    }
+    module2.exports = {
+      isDeepEqual,
+      isDeepStrictEqual
+    };
+  }
+});
+
+// ../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js
+var require_assert = __commonJS({
+  "../../../common/temp/node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js"(exports2, module2) {
+    "use strict";
+    function _typeof(obj) {
+      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+        _typeof = function _typeof2(obj2) {
+          return typeof obj2;
+        };
+      } else {
+        _typeof = function _typeof2(obj2) {
+          return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+        };
+      }
+      return _typeof(obj);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    var _require = require_errors();
+    var _require$codes = _require.codes;
+    var ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT;
+    var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+    var ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE;
+    var ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE;
+    var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+    var AssertionError = require_assertion_error();
+    var _require2 = require_util();
+    var inspect = _require2.inspect;
+    var _require$types = require_util().types;
+    var isPromise = _require$types.isPromise;
+    var isRegExp = _require$types.isRegExp;
+    var objectAssign = Object.assign ? Object.assign : require_es6_object_assign().assign;
+    var objectIs = Object.is ? Object.is : require_object_is();
+    var isDeepEqual;
+    var isDeepStrictEqual;
+    function lazyLoadComparison() {
+      var comparison = require_comparisons();
+      isDeepEqual = comparison.isDeepEqual;
+      isDeepStrictEqual = comparison.isDeepStrictEqual;
+    }
+    var warned = false;
+    var assert5 = module2.exports = ok;
+    var NO_EXCEPTION_SENTINEL = {};
+    function innerFail(obj) {
+      if (obj.message instanceof Error)
+        throw obj.message;
+      throw new AssertionError(obj);
+    }
+    function fail(actual, expected, message, operator, stackStartFn) {
+      var argsLen = arguments.length;
+      var internalMessage;
+      if (argsLen === 0) {
+        internalMessage = "Failed";
+      } else if (argsLen === 1) {
+        message = actual;
+        actual = void 0;
+      } else {
+        if (warned === false) {
+          warned = true;
+          var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);
+          warn("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+        }
+        if (argsLen === 2)
+          operator = "!=";
+      }
+      if (message instanceof Error)
+        throw message;
+      var errArgs = {
+        actual,
+        expected,
+        operator: operator === void 0 ? "fail" : operator,
+        stackStartFn: stackStartFn || fail
+      };
+      if (message !== void 0) {
+        errArgs.message = message;
+      }
+      var err = new AssertionError(errArgs);
+      if (internalMessage) {
+        err.message = internalMessage;
+        err.generatedMessage = true;
+      }
+      throw err;
+    }
+    assert5.fail = fail;
+    assert5.AssertionError = AssertionError;
+    function innerOk(fn, argLen, value, message) {
+      if (!value) {
+        var generatedMessage = false;
+        if (argLen === 0) {
+          generatedMessage = true;
+          message = "No value argument passed to `assert.ok()`";
+        } else if (message instanceof Error) {
+          throw message;
+        }
+        var err = new AssertionError({
+          actual: value,
+          expected: true,
+          message,
+          operator: "==",
+          stackStartFn: fn
+        });
+        err.generatedMessage = generatedMessage;
+        throw err;
+      }
+    }
+    function ok() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      innerOk.apply(void 0, [ok, args.length].concat(args));
+    }
+    assert5.ok = ok;
+    assert5.equal = function equal(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (actual != expected) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "==",
+          stackStartFn: equal
+        });
+      }
+    };
+    assert5.notEqual = function notEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (actual == expected) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "!=",
+          stackStartFn: notEqual
+        });
+      }
+    };
+    assert5.deepEqual = function deepEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0)
+        lazyLoadComparison();
+      if (!isDeepEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "deepEqual",
+          stackStartFn: deepEqual
+        });
+      }
+    };
+    assert5.notDeepEqual = function notDeepEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0)
+        lazyLoadComparison();
+      if (isDeepEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notDeepEqual",
+          stackStartFn: notDeepEqual
+        });
+      }
+    };
+    assert5.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0)
+        lazyLoadComparison();
+      if (!isDeepStrictEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "deepStrictEqual",
+          stackStartFn: deepStrictEqual
+        });
+      }
+    };
+    assert5.notDeepStrictEqual = notDeepStrictEqual;
+    function notDeepStrictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (isDeepEqual === void 0)
+        lazyLoadComparison();
+      if (isDeepStrictEqual(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notDeepStrictEqual",
+          stackStartFn: notDeepStrictEqual
+        });
+      }
+    }
+    assert5.strictEqual = function strictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (!objectIs(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "strictEqual",
+          stackStartFn: strictEqual
+        });
+      }
+    };
+    assert5.notStrictEqual = function notStrictEqual(actual, expected, message) {
+      if (arguments.length < 2) {
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      }
+      if (objectIs(actual, expected)) {
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: "notStrictEqual",
+          stackStartFn: notStrictEqual
+        });
+      }
+    };
+    var Comparison = function Comparison2(obj, keys, actual) {
+      var _this = this;
+      _classCallCheck(this, Comparison2);
+      keys.forEach(function(key) {
+        if (key in obj) {
+          if (actual !== void 0 && typeof actual[key] === "string" && isRegExp(obj[key]) && obj[key].test(actual[key])) {
+            _this[key] = actual[key];
+          } else {
+            _this[key] = obj[key];
+          }
+        }
+      });
+    };
+    function compareExceptionKey(actual, expected, key, message, keys, fn) {
+      if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+        if (!message) {
+          var a = new Comparison(actual, keys);
+          var b = new Comparison(expected, keys, actual);
+          var err = new AssertionError({
+            actual: a,
+            expected: b,
+            operator: "deepStrictEqual",
+            stackStartFn: fn
+          });
+          err.actual = actual;
+          err.expected = expected;
+          err.operator = fn.name;
+          throw err;
+        }
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: fn.name,
+          stackStartFn: fn
+        });
+      }
+    }
+    function expectedException(actual, expected, msg, fn) {
+      if (typeof expected !== "function") {
+        if (isRegExp(expected))
+          return expected.test(actual);
+        if (arguments.length === 2) {
+          throw new ERR_INVALID_ARG_TYPE("expected", ["Function", "RegExp"], expected);
+        }
+        if (_typeof(actual) !== "object" || actual === null) {
+          var err = new AssertionError({
+            actual,
+            expected,
+            message: msg,
+            operator: "deepStrictEqual",
+            stackStartFn: fn
+          });
+          err.operator = fn.name;
+          throw err;
+        }
+        var keys = Object.keys(expected);
+        if (expected instanceof Error) {
+          keys.push("name", "message");
+        } else if (keys.length === 0) {
+          throw new ERR_INVALID_ARG_VALUE("error", expected, "may not be an empty object");
+        }
+        if (isDeepEqual === void 0)
+          lazyLoadComparison();
+        keys.forEach(function(key) {
+          if (typeof actual[key] === "string" && isRegExp(expected[key]) && expected[key].test(actual[key])) {
+            return;
+          }
+          compareExceptionKey(actual, expected, key, msg, keys, fn);
+        });
+        return true;
+      }
+      if (expected.prototype !== void 0 && actual instanceof expected) {
+        return true;
+      }
+      if (Error.isPrototypeOf(expected)) {
+        return false;
+      }
+      return expected.call({}, actual) === true;
+    }
+    function getActual(fn) {
+      if (typeof fn !== "function") {
+        throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
+      }
+      try {
+        fn();
+      } catch (e) {
+        return e;
+      }
+      return NO_EXCEPTION_SENTINEL;
+    }
+    function checkIsPromise(obj) {
+      return isPromise(obj) || obj !== null && _typeof(obj) === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
+    }
+    function waitForActual(promiseFn) {
+      return Promise.resolve().then(function() {
+        var resultPromise;
+        if (typeof promiseFn === "function") {
+          resultPromise = promiseFn();
+          if (!checkIsPromise(resultPromise)) {
+            throw new ERR_INVALID_RETURN_VALUE("instance of Promise", "promiseFn", resultPromise);
+          }
+        } else if (checkIsPromise(promiseFn)) {
+          resultPromise = promiseFn;
+        } else {
+          throw new ERR_INVALID_ARG_TYPE("promiseFn", ["Function", "Promise"], promiseFn);
+        }
+        return Promise.resolve().then(function() {
+          return resultPromise;
+        }).then(function() {
+          return NO_EXCEPTION_SENTINEL;
+        }).catch(function(e) {
+          return e;
+        });
+      });
+    }
+    function expectsError(stackStartFn, actual, error, message) {
+      if (typeof error === "string") {
+        if (arguments.length === 4) {
+          throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+        }
+        if (_typeof(actual) === "object" && actual !== null) {
+          if (actual.message === error) {
+            throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error message "'.concat(actual.message, '" is identical to the message.'));
+          }
+        } else if (actual === error) {
+          throw new ERR_AMBIGUOUS_ARGUMENT("error/message", 'The error "'.concat(actual, '" is identical to the message.'));
+        }
+        message = error;
+        error = void 0;
+      } else if (error != null && _typeof(error) !== "object" && typeof error !== "function") {
+        throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+      }
+      if (actual === NO_EXCEPTION_SENTINEL) {
+        var details = "";
+        if (error && error.name) {
+          details += " (".concat(error.name, ")");
+        }
+        details += message ? ": ".concat(message) : ".";
+        var fnType = stackStartFn.name === "rejects" ? "rejection" : "exception";
+        innerFail({
+          actual: void 0,
+          expected: error,
+          operator: stackStartFn.name,
+          message: "Missing expected ".concat(fnType).concat(details),
+          stackStartFn
+        });
+      }
+      if (error && !expectedException(actual, error, message, stackStartFn)) {
+        throw actual;
+      }
+    }
+    function expectsNoError(stackStartFn, actual, error, message) {
+      if (actual === NO_EXCEPTION_SENTINEL)
+        return;
+      if (typeof error === "string") {
+        message = error;
+        error = void 0;
+      }
+      if (!error || expectedException(actual, error)) {
+        var details = message ? ": ".concat(message) : ".";
+        var fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+        innerFail({
+          actual,
+          expected: error,
+          operator: stackStartFn.name,
+          message: "Got unwanted ".concat(fnType).concat(details, "\n") + 'Actual message: "'.concat(actual && actual.message, '"'),
+          stackStartFn
+        });
+      }
+      throw actual;
+    }
+    assert5.throws = function throws(promiseFn) {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+      expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
+    };
+    assert5.rejects = function rejects(promiseFn) {
+      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+        args[_key3 - 1] = arguments[_key3];
+      }
+      return waitForActual(promiseFn).then(function(result) {
+        return expectsError.apply(void 0, [rejects, result].concat(args));
+      });
+    };
+    assert5.doesNotThrow = function doesNotThrow(fn) {
+      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+        args[_key4 - 1] = arguments[_key4];
+      }
+      expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
+    };
+    assert5.doesNotReject = function doesNotReject(fn) {
+      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+        args[_key5 - 1] = arguments[_key5];
+      }
+      return waitForActual(fn).then(function(result) {
+        return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));
+      });
+    };
+    assert5.ifError = function ifError(err) {
+      if (err !== null && err !== void 0) {
+        var message = "ifError got unwanted exception: ";
+        if (_typeof(err) === "object" && typeof err.message === "string") {
+          if (err.message.length === 0 && err.constructor) {
+            message += err.constructor.name;
+          } else {
+            message += err.message;
+          }
+        } else {
+          message += inspect(err);
+        }
+        var newErr = new AssertionError({
+          actual: err,
+          expected: null,
+          operator: "ifError",
+          message,
+          stackStartFn: ifError
+        });
+        var origStack = err.stack;
+        if (typeof origStack === "string") {
+          var tmp2 = origStack.split("\n");
+          tmp2.shift();
+          var tmp1 = newErr.stack.split("\n");
+          for (var i = 0; i < tmp2.length; i++) {
+            var pos = tmp1.indexOf(tmp2[i]);
+            if (pos !== -1) {
+              tmp1 = tmp1.slice(0, pos);
+              break;
+            }
+          }
+          newErr.stack = "".concat(tmp1.join("\n"), "\n").concat(tmp2.join("\n"));
+        }
+        throw newErr;
+      }
+    };
+    function strict() {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+      innerOk.apply(void 0, [strict, args.length].concat(args));
+    }
+    assert5.strict = objectAssign(strict, assert5, {
+      equal: assert5.strictEqual,
+      deepEqual: assert5.deepStrictEqual,
+      notEqual: assert5.notStrictEqual,
+      notDeepEqual: assert5.notDeepStrictEqual
+    });
+    assert5.strict.strict = assert5.strict;
+  }
+});
+
 // ../../../common/temp/node_modules/.pnpm/@protobufjs+aspromise@1.1.2/node_modules/@protobufjs/aspromise/index.js
 var require_aspromise = __commonJS({
   "../../../common/temp/node_modules/.pnpm/@protobufjs+aspromise@1.1.2/node_modules/@protobufjs/aspromise/index.js"(exports2, module2) {
@@ -1305,20 +4961,20 @@ var require_roots = __commonJS({
 var require_index_minimal = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/index-minimal.js"(exports2) {
     "use strict";
-    var protobuf = exports2;
-    protobuf.build = "minimal";
-    protobuf.Writer = require_writer();
-    protobuf.BufferWriter = require_writer_buffer();
-    protobuf.Reader = require_reader();
-    protobuf.BufferReader = require_reader_buffer();
-    protobuf.util = require_minimal();
-    protobuf.rpc = require_rpc();
-    protobuf.roots = require_roots();
-    protobuf.configure = configure;
+    var protobuf2 = exports2;
+    protobuf2.build = "minimal";
+    protobuf2.Writer = require_writer();
+    protobuf2.BufferWriter = require_writer_buffer();
+    protobuf2.Reader = require_reader();
+    protobuf2.BufferReader = require_reader_buffer();
+    protobuf2.util = require_minimal();
+    protobuf2.rpc = require_rpc();
+    protobuf2.roots = require_roots();
+    protobuf2.configure = configure;
     function configure() {
-      protobuf.util._configure();
-      protobuf.Writer._configure(protobuf.BufferWriter);
-      protobuf.Reader._configure(protobuf.BufferReader);
+      protobuf2.util._configure();
+      protobuf2.Writer._configure(protobuf2.BufferWriter);
+      protobuf2.Reader._configure(protobuf2.BufferReader);
     }
     configure();
   }
@@ -1478,11 +5134,11 @@ var require_path = __commonJS({
 });
 
 // ../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/types.js
-var require_types = __commonJS({
+var require_types2 = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/types.js"(exports2) {
     "use strict";
     var types = exports2;
-    var util = require_util();
+    var util = require_util2();
     var s = [
       "double",
       "float",
@@ -1589,8 +5245,8 @@ var require_field = __commonJS({
     var ReflectionObject = require_object();
     ((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = "Field";
     var Enum2 = require_enum();
-    var types = require_types();
-    var util = require_util();
+    var types = require_types2();
+    var util = require_util2();
     var Type3;
     var ruleRe = /^required|optional|repeated$/;
     Field.fromJSON = function fromJSON(name, json) {
@@ -1733,7 +5389,7 @@ var require_oneof = __commonJS({
     var ReflectionObject = require_object();
     ((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = "OneOf";
     var Field = require_field();
-    var util = require_util();
+    var util = require_util2();
     function OneOf(name, fieldNames, options, comment) {
       if (!Array.isArray(fieldNames)) {
         options = fieldNames;
@@ -1833,7 +5489,7 @@ var require_namespace = __commonJS({
     ((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = "Namespace";
     var Field = require_field();
     var OneOf = require_oneof();
-    var util = require_util();
+    var util = require_util2();
     var Type3;
     var Service2;
     var Enum2;
@@ -2038,8 +5694,8 @@ var require_mapfield = __commonJS({
     module2.exports = MapField2;
     var Field = require_field();
     ((MapField2.prototype = Object.create(Field.prototype)).constructor = MapField2).className = "MapField";
-    var types = require_types();
-    var util = require_util();
+    var types = require_types2();
+    var util = require_util2();
     function MapField2(name, id, keyType, type, options, comment) {
       Field.call(this, name, id, type, void 0, void 0, options, comment);
       if (!util.isString(keyType))
@@ -2094,7 +5750,7 @@ var require_method = __commonJS({
     module2.exports = Method;
     var ReflectionObject = require_object();
     ((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = "Method";
-    var util = require_util();
+    var util = require_util2();
     function Method(name, type, requestType, responseType, requestStream, responseStream, options, comment, parsedOptions) {
       if (util.isObject(requestStream)) {
         options = requestStream;
@@ -2162,7 +5818,7 @@ var require_service2 = __commonJS({
     var Namespace = require_namespace();
     ((Service2.prototype = Object.create(Namespace.prototype)).constructor = Service2).className = "Service";
     var Method = require_method();
-    var util = require_util();
+    var util = require_util2();
     var rpc = require_rpc();
     function Service2(name, options) {
       Namespace.call(this, name, options);
@@ -2293,8 +5949,8 @@ var require_decoder = __commonJS({
     "use strict";
     module2.exports = decoder;
     var Enum2 = require_enum();
-    var types = require_types();
-    var util = require_util();
+    var types = require_types2();
+    var util = require_util2();
     function missing(field) {
       return "missing required '" + field.name + "'";
     }
@@ -2360,7 +6016,7 @@ var require_verifier = __commonJS({
     "use strict";
     module2.exports = verifier;
     var Enum2 = require_enum();
-    var util = require_util();
+    var util = require_util2();
     function invalid(field, expected) {
       return field.name + ": " + expected + (field.repeated && expected !== "array" ? "[]" : field.map && expected !== "object" ? "{k:" + field.keyType + "}" : "") + " expected";
     }
@@ -2469,7 +6125,7 @@ var require_converter = __commonJS({
     "use strict";
     var converter = exports2;
     var Enum2 = require_enum();
-    var util = require_util();
+    var util = require_util2();
     function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
       if (field.resolvedType) {
         if (field.resolvedType instanceof Enum2) {
@@ -2703,7 +6359,7 @@ var require_type = __commonJS({
     var Message = require_message();
     var Reader = require_reader();
     var Writer = require_writer();
-    var util = require_util();
+    var util = require_util2();
     var encoder = require_encoder();
     var decoder = require_decoder();
     var verifier = require_verifier();
@@ -2976,33 +6632,33 @@ var require_type = __commonJS({
 var require_root = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/root.js"(exports2, module2) {
     "use strict";
-    module2.exports = Root2;
+    module2.exports = Root3;
     var Namespace = require_namespace();
-    ((Root2.prototype = Object.create(Namespace.prototype)).constructor = Root2).className = "Root";
+    ((Root3.prototype = Object.create(Namespace.prototype)).constructor = Root3).className = "Root";
     var Field = require_field();
     var Enum2 = require_enum();
     var OneOf = require_oneof();
-    var util = require_util();
+    var util = require_util2();
     var Type3;
     var parse;
     var common;
-    function Root2(options) {
+    function Root3(options) {
       Namespace.call(this, "", options);
       this.deferred = [];
       this.files = [];
     }
-    Root2.fromJSON = function fromJSON(json, root) {
+    Root3.fromJSON = function fromJSON(json, root) {
       if (!root)
-        root = new Root2();
+        root = new Root3();
       if (json.options)
         root.setOptions(json.options);
       return root.addJSON(json.nested);
     };
-    Root2.prototype.resolvePath = util.path.resolve;
-    Root2.prototype.fetch = util.fetch;
+    Root3.prototype.resolvePath = util.path.resolve;
+    Root3.prototype.fetch = util.fetch;
     function SYNC() {
     }
-    Root2.prototype.load = function load(filename, options, callback) {
+    Root3.prototype.load = function load(filename, options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = void 0;
@@ -3029,7 +6685,7 @@ var require_root = __commonJS({
         }
         return null;
       }
-      function process(filename2, source) {
+      function process2(filename2, source) {
         try {
           if (util.isString(source) && source.charAt(0) === "{")
             source = JSON.parse(source);
@@ -3061,12 +6717,12 @@ var require_root = __commonJS({
         self2.files.push(filename2);
         if (filename2 in common) {
           if (sync)
-            process(filename2, common[filename2]);
+            process2(filename2, common[filename2]);
           else {
             ++queued;
             setTimeout(function() {
               --queued;
-              process(filename2, common[filename2]);
+              process2(filename2, common[filename2]);
             });
           }
           return;
@@ -3080,7 +6736,7 @@ var require_root = __commonJS({
               finish(err);
             return;
           }
-          process(filename2, source);
+          process2(filename2, source);
         } else {
           ++queued;
           self2.fetch(filename2, function(err, source2) {
@@ -3094,7 +6750,7 @@ var require_root = __commonJS({
                 finish(null, self2);
               return;
             }
-            process(filename2, source2);
+            process2(filename2, source2);
           });
         }
       }
@@ -3110,12 +6766,12 @@ var require_root = __commonJS({
         finish(null, self2);
       return void 0;
     };
-    Root2.prototype.loadSync = function loadSync(filename, options) {
+    Root3.prototype.loadSync = function loadSync(filename, options) {
       if (!util.isNode)
         throw Error("not supported");
       return this.load(filename, options, SYNC);
     };
-    Root2.prototype.resolveAll = function resolveAll() {
+    Root3.prototype.resolveAll = function resolveAll() {
       if (this.deferred.length)
         throw Error("unresolvable extensions: " + this.deferred.map(function(field) {
           return "'extend " + field.extend + "' in " + field.parent.fullName;
@@ -3134,7 +6790,7 @@ var require_root = __commonJS({
       }
       return false;
     }
-    Root2.prototype._handleAdd = function _handleAdd(object) {
+    Root3.prototype._handleAdd = function _handleAdd(object) {
       if (object instanceof Field) {
         if (object.extend !== void 0 && !object.extensionField) {
           if (!tryHandleExtension(this, object))
@@ -3156,7 +6812,7 @@ var require_root = __commonJS({
           object.parent[object.name] = object;
       }
     };
-    Root2.prototype._handleRemove = function _handleRemove(object) {
+    Root3.prototype._handleRemove = function _handleRemove(object) {
       if (object instanceof Field) {
         if (object.extend !== void 0) {
           if (object.extensionField) {
@@ -3178,7 +6834,7 @@ var require_root = __commonJS({
           delete object.parent[object.name];
       }
     };
-    Root2._configure = function(Type_, parse_, common_) {
+    Root3._configure = function(Type_, parse_, common_) {
       Type3 = Type_;
       parse = parse_;
       common = common_;
@@ -3187,7 +6843,7 @@ var require_root = __commonJS({
 });
 
 // ../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/util.js
-var require_util = __commonJS({
+var require_util2 = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/util.js"(exports2, module2) {
     "use strict";
     var util = module2.exports = require_minimal();
@@ -3301,8 +6957,8 @@ var require_object = __commonJS({
     "use strict";
     module2.exports = ReflectionObject;
     ReflectionObject.className = "ReflectionObject";
-    var util = require_util();
-    var Root2;
+    var util = require_util2();
+    var Root3;
     function ReflectionObject(name, options) {
       if (!util.isString(name))
         throw TypeError("name must be a string");
@@ -3345,12 +7001,12 @@ var require_object = __commonJS({
       this.parent = parent;
       this.resolved = false;
       var root = parent.root;
-      if (root instanceof Root2)
+      if (root instanceof Root3)
         root._handleAdd(this);
     };
     ReflectionObject.prototype.onRemove = function onRemove(parent) {
       var root = parent.root;
-      if (root instanceof Root2)
+      if (root instanceof Root3)
         root._handleRemove(this);
       this.parent = null;
       this.resolved = false;
@@ -3358,7 +7014,7 @@ var require_object = __commonJS({
     ReflectionObject.prototype.resolve = function resolve() {
       if (this.resolved)
         return this;
-      if (this.root instanceof Root2)
+      if (this.root instanceof Root3)
         this.resolved = true;
       return this;
     };
@@ -3409,7 +7065,7 @@ var require_object = __commonJS({
       return className;
     };
     ReflectionObject._configure = function(Root_) {
-      Root2 = Root_;
+      Root3 = Root_;
     };
   }
 });
@@ -3422,7 +7078,7 @@ var require_enum = __commonJS({
     var ReflectionObject = require_object();
     ((Enum2.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum2).className = "Enum";
     var Namespace = require_namespace();
-    var util = require_util();
+    var util = require_util2();
     function Enum2(name, values, options, comment, comments) {
       ReflectionObject.call(this, name, options);
       if (values && typeof values !== "object")
@@ -3504,8 +7160,8 @@ var require_encoder = __commonJS({
     "use strict";
     module2.exports = encoder;
     var Enum2 = require_enum();
-    var types = require_types();
-    var util = require_util();
+    var types = require_types2();
+    var util = require_util2();
     function genTypePartial(gen, field, fieldIndex, ref2) {
       return field.resolvedType.group ? gen("types[%i].encode(%s,w.uint32(%i)).uint32(%i)", fieldIndex, ref2, (field.id << 3 | 3) >>> 0, (field.id << 3 | 4) >>> 0) : gen("types[%i].encode(%s,w.uint32(%i).fork()).ldelim()", fieldIndex, ref2, (field.id << 3 | 2) >>> 0);
     }
@@ -3553,45 +7209,45 @@ var require_encoder = __commonJS({
 var require_index_light = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/index-light.js"(exports2, module2) {
     "use strict";
-    var protobuf = module2.exports = require_index_minimal();
-    protobuf.build = "light";
+    var protobuf2 = module2.exports = require_index_minimal();
+    protobuf2.build = "light";
     function load(filename, root, callback) {
       if (typeof root === "function") {
         callback = root;
-        root = new protobuf.Root();
+        root = new protobuf2.Root();
       } else if (!root)
-        root = new protobuf.Root();
+        root = new protobuf2.Root();
       return root.load(filename, callback);
     }
-    protobuf.load = load;
+    protobuf2.load = load;
     function loadSync(filename, root) {
       if (!root)
-        root = new protobuf.Root();
+        root = new protobuf2.Root();
       return root.loadSync(filename);
     }
-    protobuf.loadSync = loadSync;
-    protobuf.encoder = require_encoder();
-    protobuf.decoder = require_decoder();
-    protobuf.verifier = require_verifier();
-    protobuf.converter = require_converter();
-    protobuf.ReflectionObject = require_object();
-    protobuf.Namespace = require_namespace();
-    protobuf.Root = require_root();
-    protobuf.Enum = require_enum();
-    protobuf.Type = require_type();
-    protobuf.Field = require_field();
-    protobuf.OneOf = require_oneof();
-    protobuf.MapField = require_mapfield();
-    protobuf.Service = require_service2();
-    protobuf.Method = require_method();
-    protobuf.Message = require_message();
-    protobuf.wrappers = require_wrappers();
-    protobuf.types = require_types();
-    protobuf.util = require_util();
-    protobuf.ReflectionObject._configure(protobuf.Root);
-    protobuf.Namespace._configure(protobuf.Type, protobuf.Service, protobuf.Enum);
-    protobuf.Root._configure(protobuf.Type);
-    protobuf.Field._configure(protobuf.Type);
+    protobuf2.loadSync = loadSync;
+    protobuf2.encoder = require_encoder();
+    protobuf2.decoder = require_decoder();
+    protobuf2.verifier = require_verifier();
+    protobuf2.converter = require_converter();
+    protobuf2.ReflectionObject = require_object();
+    protobuf2.Namespace = require_namespace();
+    protobuf2.Root = require_root();
+    protobuf2.Enum = require_enum();
+    protobuf2.Type = require_type();
+    protobuf2.Field = require_field();
+    protobuf2.OneOf = require_oneof();
+    protobuf2.MapField = require_mapfield();
+    protobuf2.Service = require_service2();
+    protobuf2.Method = require_method();
+    protobuf2.Message = require_message();
+    protobuf2.wrappers = require_wrappers();
+    protobuf2.types = require_types2();
+    protobuf2.util = require_util2();
+    protobuf2.ReflectionObject._configure(protobuf2.Root);
+    protobuf2.Namespace._configure(protobuf2.Type, protobuf2.Service, protobuf2.Enum);
+    protobuf2.Root._configure(protobuf2.Type);
+    protobuf2.Field._configure(protobuf2.Type);
   }
 });
 
@@ -3836,7 +7492,7 @@ var require_parse = __commonJS({
     parse.filename = null;
     parse.defaults = { keepCase: false };
     var tokenize = require_tokenize();
-    var Root2 = require_root();
+    var Root3 = require_root();
     var Type3 = require_type();
     var Field = require_field();
     var MapField2 = require_mapfield();
@@ -3844,8 +7500,8 @@ var require_parse = __commonJS({
     var Enum2 = require_enum();
     var Service2 = require_service2();
     var Method = require_method();
-    var types = require_types();
-    var util = require_util();
+    var types = require_types2();
+    var util = require_util2();
     var base10Re = /^[1-9][0-9]*$/;
     var base10NegRe = /^-?[1-9][0-9]*$/;
     var base16Re = /^0[x][0-9a-fA-F]+$/;
@@ -3857,9 +7513,9 @@ var require_parse = __commonJS({
     var typeRefRe = /^(?:\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\.[a-zA-Z_][a-zA-Z_0-9]*)*$/;
     var fqTypeRefRe = /^(?:\.[a-zA-Z_][a-zA-Z_0-9]*)+$/;
     function parse(source, root, options) {
-      if (!(root instanceof Root2)) {
+      if (!(root instanceof Root3)) {
         options = root;
-        root = new Root2();
+        root = new Root3();
       }
       if (!options)
         options = parse.defaults;
@@ -4622,15 +8278,15 @@ var require_common = __commonJS({
 });
 
 // ../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/index.js
-var require_src = __commonJS({
+var require_src2 = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/src/index.js"(exports2, module2) {
     "use strict";
-    var protobuf = module2.exports = require_index_light();
-    protobuf.build = "full";
-    protobuf.tokenize = require_tokenize();
-    protobuf.parse = require_parse();
-    protobuf.common = require_common();
-    protobuf.Root._configure(protobuf.Type, protobuf.parse, protobuf.common);
+    var protobuf2 = module2.exports = require_index_light();
+    protobuf2.build = "full";
+    protobuf2.tokenize = require_tokenize();
+    protobuf2.parse = require_parse();
+    protobuf2.common = require_common();
+    protobuf2.Root._configure(protobuf2.Type, protobuf2.parse, protobuf2.common);
   }
 });
 
@@ -4638,7 +8294,7 @@ var require_src = __commonJS({
 var require_protobufjs = __commonJS({
   "../../../common/temp/node_modules/.pnpm/protobufjs@6.11.2/node_modules/protobufjs/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = require_src();
+    module2.exports = require_src2();
   }
 });
 
@@ -4654,6 +8310,10 @@ __export(src_exports, {
   ServiceHandler: () => ServiceHandler,
   Stream: () => Stream,
   anySubstitutions: () => anySubstitutions,
+  createMappingDescriptors: () => createMappingDescriptors,
+  decodeProtobuf: () => decodeProtobuf,
+  encodeProtobuf: () => encodeProtobuf,
+  mapMessage: () => mapMessage,
   patchBufferCodec: () => patchBufferCodec,
   sanitize: () => sanitize,
   timestampSubstitutions: () => timestampSubstitutions
@@ -4667,7 +8327,7 @@ var patchBufferCodec = (codec) => ({
 });
 
 // src/precompiled-mapping/create-message-mapper.ts
-var import_assert = __toESM(require("assert"));
+var import_node_assert = __toESM(require_assert());
 var pb = __toESM(require_protobufjs());
 
 // src/precompiled-mapping/codegen.ts
@@ -4726,7 +8386,7 @@ var createMessageMapperCached = (type, substitutions, cache) => {
             genMapScalar("item");
             c`);`;
           } else if (field.map) {
-            (0, import_assert.default)(field instanceof pb.MapField);
+            (0, import_node_assert.default)(field instanceof pb.MapField);
             c`res.${field.name} = {};`;
             c`for(const key of Object.keys(obj.${field.name})) {`;
             {
@@ -4784,14 +8444,78 @@ var ProtoCodec = class {
   }
 };
 
+// src/encoding.ts
+var protobuf = __toESM(require_protobufjs());
+var encodeProtobuf = (root) => JSON.stringify(root.toJSON());
+var decodeProtobuf = (json) => protobuf.Root.fromJSON(JSON.parse(json));
+
 // src/interface.ts
 var NOOP_CODEC = {
   encode: (value) => value,
   decode: (data) => data
 };
 
-// src/sanitizer.ts
+// src/mapping.ts
+var import_node_assert2 = __toESM(require_assert());
 var import_protobufjs = __toESM(require_protobufjs());
+var createMappingDescriptors = (substitutions) => {
+  const encode = {};
+  const decode = {};
+  for (const type of Object.keys(substitutions)) {
+    encode[type] = substitutions[type].encode;
+    decode[type] = substitutions[type].decode;
+  }
+  return {
+    encode,
+    decode
+  };
+};
+var mapMessage = async (type, mapper, obj) => {
+  const res = {};
+  for (const field of type.fieldsArray) {
+    if (!(field.name in obj)) {
+      continue;
+    }
+    res[field.name] = await mapField(field, mapper, obj[field.name]);
+  }
+  return res;
+};
+var mapField = async (field, mapper, value) => {
+  if (!field.required && (value === null || value === void 0)) {
+    return value;
+  } else if (field.repeated) {
+    return await Promise.all(value.map((value2) => mapScalarField(field, mapper, value2)));
+  } else if (field.map) {
+    (0, import_node_assert2.default)(field instanceof import_protobufjs.default.MapField);
+    return await asyncObjectMap((value2) => mapScalarField(field, mapper, value2), value);
+  } else {
+    return mapScalarField(field, mapper, value);
+  }
+};
+var mapScalarField = async (field, mapper, value) => {
+  var _a;
+  if (!field.resolved) {
+    field.resolve();
+  }
+  const typeName = (_a = field.resolvedType) == null ? void 0 : _a.fullName.slice(1);
+  if (typeName) {
+    return await mapper(value, typeName);
+  }
+  if (field.resolvedType && field.resolvedType instanceof import_protobufjs.default.Type) {
+    return await mapMessage(field.resolvedType, mapper, value);
+  }
+  return value;
+};
+var asyncObjectMap = async (map, record) => {
+  const res = {};
+  await Promise.all(Object.entries(record).map(async ([key, value]) => {
+    res[key] = await map(value, key);
+  }));
+  return res;
+};
+
+// src/sanitizer.ts
+var import_protobufjs2 = __toESM(require_protobufjs());
 var sanitize = (type, value, path, context) => {
   for (const key of Object.keys(value)) {
     if (!type.fields[key]) {
@@ -4806,9 +8530,9 @@ var sanitize = (type, value, path, context) => {
     if (!field.resolvedType) {
       continue;
     }
-    if (field.resolvedType instanceof import_protobufjs.Type) {
+    if (field.resolvedType instanceof import_protobufjs2.Type) {
       sanitize(field.resolvedType, value[key], `${path}.${key}`, context);
-    } else if (field.resolvedType instanceof import_protobufjs.Enum) {
+    } else if (field.resolvedType instanceof import_protobufjs2.Enum) {
       value[key] = sanitizeEnum(field.resolvedType, value[key], `${path}.${key}`, context);
     }
   }
@@ -4831,28 +8555,14 @@ var sanitizeEnum = (type, value, path, context) => {
 
 // src/schema.ts
 var import_lodash = __toESM(require("lodash.merge"));
-var import_protobufjs2 = __toESM(require_protobufjs());
-
-// src/mapping.ts
-var createMappingDescriptors = (substitutions) => {
-  const encode = {};
-  const decode = {};
-  for (const type of Object.keys(substitutions)) {
-    encode[type] = substitutions[type].encode;
-    decode[type] = substitutions[type].decode;
-  }
-  return {
-    encode,
-    decode
-  };
-};
+var import_protobufjs3 = __toESM(require_protobufjs());
 
 // src/service.ts
-var import_assert3 = __toESM(require("assert"));
+var import_node_assert4 = __toESM(require_assert());
 
 // src/stream.ts
-var import_assert2 = __toESM(require("assert"));
 var import_debug = __toESM(require("debug"));
+var import_node_assert3 = __toESM(require_assert());
 var log = (0, import_debug.default)("dxos:codec-protobuf:stream");
 var Stream = class {
   constructor(producer) {
@@ -4871,7 +8581,7 @@ var Stream = class {
             throwUnhandledRejection(error);
           }
         } else {
-          (0, import_assert2.default)(this._buffer);
+          (0, import_node_assert3.default)(this._buffer);
           this._buffer.push(msg);
         }
       },
@@ -4910,9 +8620,9 @@ var Stream = class {
     });
   }
   subscribe(onMessage, onClose) {
-    (0, import_assert2.default)(!this._messageHandler, "Stream is already subscribed to.");
-    (0, import_assert2.default)(!this._closeHandler, "Stream is already subscribed to.");
-    (0, import_assert2.default)(this._buffer);
+    (0, import_node_assert3.default)(!this._messageHandler, "Stream is already subscribed to.");
+    (0, import_node_assert3.default)(!this._closeHandler, "Stream is already subscribed to.");
+    (0, import_node_assert3.default)(this._buffer);
     for (const message of this._buffer) {
       try {
         onMessage(message);
@@ -4967,9 +8677,9 @@ var Service = class {
   constructor(backend, service, schema) {
     for (const method of service.methodsArray) {
       method.resolve();
-      (0, import_assert3.default)(method.resolvedRequestType);
-      (0, import_assert3.default)(method.resolvedResponseType);
-      (0, import_assert3.default)(!method.requestStream, "Streaming RPC requests are not supported.");
+      (0, import_node_assert4.default)(method.resolvedRequestType);
+      (0, import_node_assert4.default)(method.resolvedResponseType);
+      (0, import_node_assert4.default)(!method.requestStream, "Streaming RPC requests are not supported.");
       const requestCodec = schema.tryGetCodecForType(method.resolvedRequestType.fullName);
       const responseCodec = schema.tryGetCodecForType(method.resolvedResponseType.fullName);
       const methodName = mapRpcMethodName(method.name);
@@ -5007,11 +8717,11 @@ var ServiceHandler = class {
   }
   async call(methodName, request) {
     const { method, requestCodec, responseCodec } = this._getMethodInfo(methodName);
-    (0, import_assert3.default)(!method.requestStream, "Invalid RPC method call: request streaming mismatch.");
-    (0, import_assert3.default)(!method.responseStream, `Invalid RPC method call: response streaming mismatch. ${methodName}`);
+    (0, import_node_assert4.default)(!method.requestStream, "Invalid RPC method call: request streaming mismatch.");
+    (0, import_node_assert4.default)(!method.responseStream, `Invalid RPC method call: response streaming mismatch. ${methodName}`);
     const mappedMethodName = mapRpcMethodName(methodName);
     const handler = this._handlers[mappedMethodName];
-    (0, import_assert3.default)(handler, `Handler is missing: ${mappedMethodName}`);
+    (0, import_node_assert4.default)(handler, `Handler is missing: ${mappedMethodName}`);
     const requestDecoded = requestCodec.decode(request.value);
     const response = await handler.bind(this._handlers)(requestDecoded);
     const responseEncoded = responseCodec.encode(response);
@@ -5022,11 +8732,11 @@ var ServiceHandler = class {
   }
   callStream(methodName, request) {
     const { method, requestCodec, responseCodec } = this._getMethodInfo(methodName);
-    (0, import_assert3.default)(!method.requestStream, "Invalid RPC method call: request streaming mismatch.");
-    (0, import_assert3.default)(method.responseStream, `Invalid RPC method call: response streaming mismatch., ${methodName}`);
+    (0, import_node_assert4.default)(!method.requestStream, "Invalid RPC method call: request streaming mismatch.");
+    (0, import_node_assert4.default)(method.responseStream, `Invalid RPC method call: response streaming mismatch., ${methodName}`);
     const mappedMethodName = mapRpcMethodName(methodName);
     const handler = this._handlers[mappedMethodName];
-    (0, import_assert3.default)(handler, `Handler is missing: ${mappedMethodName}`);
+    (0, import_node_assert4.default)(handler, `Handler is missing: ${mappedMethodName}`);
     const requestDecoded = requestCodec.decode(request.value);
     const responseStream = handler.bind(this._handlers)(requestDecoded);
     return new Stream(({ next, close }) => {
@@ -5039,10 +8749,10 @@ var ServiceHandler = class {
   }
   _getMethodInfo(methodName) {
     const method = this._service.methods[methodName];
-    (0, import_assert3.default)(!!method, `Method not found: ${methodName}`);
+    (0, import_node_assert4.default)(!!method, `Method not found: ${methodName}`);
     method.resolve();
-    (0, import_assert3.default)(method.resolvedRequestType);
-    (0, import_assert3.default)(method.resolvedResponseType);
+    (0, import_node_assert4.default)(method.resolvedRequestType);
+    (0, import_node_assert4.default)(method.resolvedResponseType);
     const requestCodec = this._schema.tryGetCodecForType(method.resolvedRequestType.fullName);
     const responseCodec = this._schema.tryGetCodecForType(method.resolvedResponseType.fullName);
     return { method, requestCodec, responseCodec };
@@ -5058,7 +8768,7 @@ var Schema = class {
     this._mapping = createMappingDescriptors(substitutions);
   }
   static fromJson(schema, substitutions = {}) {
-    const root = import_protobufjs2.default.Root.fromJSON(schema);
+    const root = import_protobufjs3.default.Root.fromJSON(schema);
     return new Schema(root, substitutions);
   }
   getCodecForType(typeName) {
@@ -5090,7 +8800,7 @@ var Schema = class {
     if (!schema.nested) {
       throw new Error("Invalid schema: missing nested object");
     }
-    this._typesRoot = import_protobufjs2.Root.fromJSON((0, import_lodash.default)(this._typesRoot.toJSON(), schema));
+    this._typesRoot = import_protobufjs3.Root.fromJSON((0, import_lodash.default)(this._typesRoot.toJSON(), schema));
   }
 };
 
@@ -5135,3 +8845,9 @@ var timestampSubstitutions = {
     }
   }
 };
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */