"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// node_modules/serde/dist/ser/interface.js
var require_interface = __commonJS({
  "node_modules/serde/dist/ser/interface.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Serializer = exports2.SerializeIterable = exports2.SerializeObject = void 0;
    var SerializeObject2 = class {
      serializeEntry(key, value) {
        this.serializeKey(key);
        this.serializeValue(value);
      }
    };
    exports2.SerializeObject = SerializeObject2;
    var SerializeIterable2 = class {
    };
    exports2.SerializeIterable = SerializeIterable2;
    var Serializer2 = class {
      serializeAny(_value) {
        throw new Error("Method not implemented.");
      }
      serializeBoolean(_value) {
        throw new Error("Method not implemented.");
      }
      serializeNumber(_value) {
        throw new Error("Method not implemented.");
      }
      serializeBigInt(_value) {
        throw new Error("Method not implemented.");
      }
      serializeString(_value) {
        throw new Error("Method not implemented.");
      }
      serializeSymbol(_value) {
        throw new Error("Method not implemented.");
      }
      serializeNull() {
        throw new Error("Method not implemented.");
      }
      serializeIterable(_len) {
        throw new Error("Method not implemented.");
      }
      serializeObject(_len) {
        throw new Error("Method not implemented.");
      }
      serializeClass(_name, _len) {
        throw new Error("Method not implemented.");
      }
    };
    exports2.Serializer = Serializer2;
  }
});

// node_modules/serde/dist/ser/identity.js
var require_identity = __commonJS({
  "node_modules/serde/dist/ser/identity.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.IdentitySerializer = void 0;
    var interface_1 = require_interface();
    var IdentityMap = class extends interface_1.SerializeObject {
      constructor() {
        super(...arguments);
        Object.defineProperty(this, "value", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: {}
        });
        Object.defineProperty(this, "currentKey", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
      }
      serializeKey(key) {
        this.currentKey = key;
      }
      serializeValue(value) {
        this.value[this.currentKey] = value;
      }
      end() {
        return this.value;
      }
    };
    var IdentityIterable = class extends interface_1.SerializeIterable {
      constructor() {
        super(...arguments);
        Object.defineProperty(this, "value", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: []
        });
      }
      serializeElement(value) {
        this.value.push(value);
      }
      end() {
        return this.value;
      }
    };
    var IdentitySerializer2 = class {
      serializeAny(value) {
        return value;
      }
      serializeBoolean(value) {
        return value;
      }
      serializeNumber(value) {
        return value;
      }
      serializeBigInt(value) {
        return value;
      }
      serializeString(value) {
        return value;
      }
      serializeSymbol(value) {
        return value;
      }
      serializeNull() {
        return null;
      }
      serializeIterable(_len) {
        return new IdentityIterable();
      }
      serializeObject(_len) {
        return new IdentityMap();
      }
      serializeClass(_name, _len) {
        return new IdentityMap();
      }
    };
    exports2.IdentitySerializer = IdentitySerializer2;
  }
});

// node_modules/serde/dist/utils.js
var require_utils = __commonJS({
  "node_modules/serde/dist/utils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PrimitivePrototype = exports2.IterResult = void 0;
    exports2.isObject = isObject;
    exports2.isPlainObject = isPlainObject;
    exports2.isFunction = isFunction;
    exports2.isIterable = isIterable;
    exports2.isString = isString;
    exports2.isNumber = isNumber;
    exports2.Null = Null;
    exports2.type = type;
    function isObject(value) {
      return typeof value === "object" && !Array.isArray(value);
    }
    function isPlainObject(value) {
      return Object.getPrototypeOf(value) === Object.prototype;
    }
    function isFunction(value) {
      return value != null && typeof value === "function";
    }
    function isIterable(value) {
      return isFunction(value[Symbol.iterator]);
    }
    function isString(value) {
      return typeof value === "string";
    }
    function isNumber(value) {
      return !isNaN(value);
    }
    var IterResult2 = class {
      static Next(value) {
        return { done: false, value };
      }
      static Done() {
        return { done: true, value: void 0 };
      }
    };
    exports2.IterResult = IterResult2;
    function Null(...args) {
      return null;
    }
    exports2.PrimitivePrototype = Object.freeze({
      undefined: Null,
      boolean: Boolean,
      number: Number,
      bigint: BigInt,
      string: String,
      symbol: Symbol,
      object: Object,
      function: Function
    });
    function type(value) {
      switch (true) {
        case Array.isArray(value):
          return Array;
        case isPlainObject(value):
          return Object;
        case isObject(value):
          return value.constructor;
        default:
          return exports2.PrimitivePrototype[typeof value];
      }
    }
  }
});

// node_modules/serde/dist/registry.js
var require_registry = __commonJS({
  "node_modules/serde/dist/registry.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.registerDeserialize = exports2.registerSerialize = exports2.GlobalRegistry = exports2.Registry = void 0;
    exports2.getSerialize = getSerialize2;
    exports2.getDeserialize = getDeserialize2;
    var utils_1 = require_utils();
    var Registry3 = class {
      constructor() {
        Object.defineProperty(this, "serializers", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: /* @__PURE__ */ new Map()
        });
        Object.defineProperty(this, "deserializers", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: /* @__PURE__ */ new Map()
        });
      }
      registerSerialize(ctor, serialize3) {
        this.serializers.set(ctor, serialize3);
      }
      registerDeserialize(ctor, deserialize2) {
        this.deserializers.set(ctor, deserialize2);
      }
    };
    exports2.Registry = Registry3;
    exports2.GlobalRegistry = new Registry3();
    exports2.registerSerialize = exports2.GlobalRegistry.registerSerialize.bind(exports2.GlobalRegistry);
    exports2.registerDeserialize = exports2.GlobalRegistry.registerDeserialize.bind(exports2.GlobalRegistry);
    function getFrom(map, value) {
      return map.get((0, utils_1.type)(value));
    }
    function getSerialize2(value, fallback, registry) {
      return getFrom(registry.serializers, value) || fallback;
    }
    function getDeserialize2(value, fallback, registry) {
      return getFrom(registry.deserializers, value) || fallback;
    }
    (0, exports2.registerSerialize)(Boolean, (ser, value) => ser.serializeBoolean(value));
    (0, exports2.registerSerialize)(String, (ser, value) => ser.serializeString(value));
    (0, exports2.registerSerialize)(Number, (ser, value) => ser.serializeNumber(value));
    (0, exports2.registerSerialize)(BigInt, (ser, value) => ser.serializeBigInt(value));
    (0, exports2.registerSerialize)(Symbol, (ser, value) => ser.serializeSymbol(value));
    (0, exports2.registerSerialize)(utils_1.Null, (ser, _value) => ser.serializeNull());
    (0, exports2.registerSerialize)(Object, (ser, value) => {
      const obj = Object.entries(value);
      const serObj = ser.serializeObject(obj.length);
      obj.forEach(([key, value2]) => serObj.serializeEntry(key, value2));
      return serObj.end();
    });
    (0, exports2.registerSerialize)(Array, (ser, value) => {
      const arr = value;
      const iter = ser.serializeIterable(arr.length);
      arr.forEach((value2) => iter.serializeElement(value2));
      return iter.end();
    });
    (0, exports2.registerDeserialize)(Boolean, (de) => de.deserializeBoolean({
      visitBoolean(value) {
        return value;
      }
    }));
    (0, exports2.registerDeserialize)(String, (de) => de.deserializeString({
      visitString(value) {
        return value;
      }
    }));
    (0, exports2.registerDeserialize)(Number, (de) => de.deserializeNumber({
      visitNumber(value) {
        return value;
      }
    }));
    (0, exports2.registerDeserialize)(BigInt, (de) => de.deserializeBigInt({
      visitBigInt(value) {
        return value;
      }
    }));
    (0, exports2.registerDeserialize)(Symbol, (de) => de.deserializeSymbol({
      visitSymbol(value) {
        return value;
      }
    }));
    (0, exports2.registerDeserialize)(Object, (de) => de.deserializeObject({
      visitObject(access) {
        let result = {};
        for (const [key, value] of access) {
          result[key] = value;
        }
        return result;
      }
    }));
    (0, exports2.registerDeserialize)(Array, (de) => de.deserializeIterable({
      visitIterable(access) {
        let result = [];
        for (const value of access) {
          result.push(value);
        }
        return result;
      }
    }));
  }
});

// node_modules/serde/dist/ser/impl.js
var require_impl = __commonJS({
  "node_modules/serde/dist/ser/impl.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.serialize = serialize3;
    var utils_1 = require_utils();
    var registry_1 = require_registry();
    var UnhandledTypeError = class extends TypeError {
      constructor(serializer2, value) {
        super(`unhandled type: '${typeof value}' for serializer ${serializer2.constructor.name}`);
      }
    };
    function serializeObject(serializer2, obj) {
      for (const key in obj) {
        const value = obj[key];
        serializer2.serializeEntry(key, value);
      }
      return serializer2.end();
    }
    function serializeIterable(serializer2, iter) {
      for (const item of iter) {
        serializer2.serializeElement(item);
      }
      return serializer2.end();
    }
    function serializeClass(serializer2, value) {
      const name = value.constructor.name;
      const ser = serializer2.serializeClass(name);
      return serializeObject(ser, value);
    }
    function defaultSerialize(serializer2, value) {
      switch (typeof value) {
        case "string":
          return serializer2.serializeString(value);
        case "number":
          return serializer2.serializeNumber(value);
        case "bigint":
          return serializer2.serializeBigInt(value);
        case "boolean":
          return serializer2.serializeBoolean(value);
        case "symbol":
          return serializer2.serializeSymbol(value);
        case "undefined":
          return serializer2.serializeNull();
        case "object":
          switch (true) {
            case value == null:
              return serializer2.serializeNull();
            case Array.isArray(value):
              return serializeIterable(serializer2.serializeIterable(value.length), value);
            case !(0, utils_1.isPlainObject)(value):
              return serializeClass(serializer2, value);
            default:
              return serializeObject(serializer2.serializeObject(), value);
          }
        default:
          throw new UnhandledTypeError(serializer2, value);
      }
    }
    function serialize3(serializer2, value, registry = registry_1.GlobalRegistry) {
      const ser = (0, registry_1.getSerialize)(value, defaultSerialize, registry);
      return ser(serializer2, value);
    }
  }
});

// node_modules/serde/dist/ser/index.js
var require_ser = __commonJS({
  "node_modules/serde/dist/ser/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_identity(), exports2);
    __exportStar(require_impl(), exports2);
    __exportStar(require_interface(), exports2);
  }
});

// node_modules/serde/dist/de/impl.js
var require_impl2 = __commonJS({
  "node_modules/serde/dist/de/impl.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.deserialize = deserialize2;
    var registry_1 = require_registry();
    function deserialize2(deserializer2, into, registry = registry_1.GlobalRegistry) {
      const de = registry.deserializers.get(into);
      if (de == null) {
        throw new ReferenceError(`No deserializer for ${into.name}`);
      } else {
        return de(deserializer2);
      }
    }
  }
});

// node_modules/serde/dist/de/interface.js
var require_interface2 = __commonJS({
  "node_modules/serde/dist/de/interface.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.IterableAccess = exports2.MapAccess = void 0;
    exports2.isVisitor = isVisitor;
    var utils_1 = require_utils();
    var MapAccess2 = class {
      nextEntry(kseed, vseed) {
        const key = this.nextKey(kseed);
        if (!key.done) {
          const value = this.nextValue(vseed);
          if (!value.done) {
            return utils_1.IterResult.Next([key.value, value.value]);
          }
        }
        return utils_1.IterResult.Done();
      }
      *generate(next) {
        let item;
        while ((item = next()) && !item.done) {
          yield item.value;
        }
      }
      keys(seed) {
        return this.generate(this.nextKey.bind(this, seed));
      }
      values(seed) {
        return this.generate(this.nextValue.bind(this, seed));
      }
      entries(kseed, vseed) {
        return this.generate(this.nextEntry.bind(this, kseed, vseed));
      }
      [Symbol.iterator]() {
        return this.entries();
      }
    };
    exports2.MapAccess = MapAccess2;
    var IterableAccess2 = class {
      [Symbol.iterator]() {
        return {
          next: this.nextElement.bind(this)
        };
      }
    };
    exports2.IterableAccess = IterableAccess2;
    var VisitorMethods = Object.freeze([
      "visitBoolean",
      "visitNumber",
      "visitBigInt",
      "visitString",
      "visitSymbol",
      "visitNull",
      "visitObject",
      "visitIterable"
    ]);
    function isVisitor(visitor) {
      return VisitorMethods.every((method) => method in visitor);
    }
  }
});

// node_modules/serde/dist/de/forward.js
var require_forward = __commonJS({
  "node_modules/serde/dist/de/forward.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Forwarder = void 0;
    exports2.forward = forward;
    var impl_1 = require_impl2();
    var interface_1 = require_interface2();
    var registry_1 = require_registry();
    var utils_1 = require_utils();
    function forward(value, into, registry = registry_1.GlobalRegistry) {
      const forwarder = new Forwarder2(value);
      return (0, impl_1.deserialize)(forwarder, into, registry);
    }
    var ForwardMapAccess = class extends interface_1.MapAccess {
      constructor(entries) {
        super();
        Object.defineProperty(this, "_entries", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        Object.defineProperty(this, "index", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: -1
        });
        this._entries = entries;
      }
      static fromObject(value) {
        return new this(Object.entries(value));
      }
      nextKey(seed) {
        this.index += 1;
        if (this.index >= this._entries.length) {
          return utils_1.IterResult.Done();
        } else {
          const key = this._entries[this.index][0];
          const value = seed != null ? seed(new Forwarder2(key)) : key;
          return utils_1.IterResult.Next(value);
        }
      }
      nextValue(seed) {
        if (this.index >= this._entries.length) {
          return utils_1.IterResult.Done();
        } else {
          const value = this._entries[this.index][1];
          const deser = seed != null ? seed(value) : value;
          return utils_1.IterResult.Next(deser);
        }
      }
    };
    var ForwardIterableAccess = class extends interface_1.IterableAccess {
      constructor(elements) {
        super();
        Object.defineProperty(this, "elements", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        Object.defineProperty(this, "index", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: -1
        });
        this.elements = elements;
      }
      nextElement(seed) {
        this.index += 1;
        if (this.index >= this.elements.length) {
          return utils_1.IterResult.Done();
        } else {
          const element = this.elements[this.index];
          const deser = seed != null ? seed(new Forwarder2(element)) : element;
          return utils_1.IterResult.Next(deser);
        }
      }
    };
    var Forwarder2 = class {
      constructor(value) {
        Object.defineProperty(this, "value", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        this.value = value;
      }
      deserializeAny(visitor) {
        switch (typeof this.value) {
          case "string":
            return this.deserializeString(visitor);
          case "number":
            return this.deserializeNumber(visitor);
          case "bigint":
            return this.deserializeBigInt(visitor);
          case "boolean":
            return this.deserializeBoolean(visitor);
          case "symbol":
            return this.deserializeSymbol(visitor);
          case "undefined":
            return this.deserializeNull(visitor);
          case "object": {
            switch (true) {
              case Array.isArray(this.value):
                return this.deserializeIterable(visitor);
              default:
                return this.deserializeObject(visitor);
            }
          }
          case "function":
            return this.deserializeFunction(visitor);
        }
      }
      deserializeBoolean(visitor) {
        return visitor.visitBoolean(this.value);
      }
      deserializeNumber(visitor) {
        return visitor.visitNumber(this.value);
      }
      deserializeBigInt(visitor) {
        return visitor.visitBigInt(this.value);
      }
      deserializeString(visitor) {
        return visitor.visitString(this.value);
      }
      deserializeSymbol(visitor) {
        return visitor.visitSymbol(this.value);
      }
      deserializeNull(visitor) {
        return visitor.visitNull();
      }
      deserializeObject(visitor) {
        return visitor.visitObject(ForwardMapAccess.fromObject(this.value));
      }
      deserializeIterable(visitor) {
        return visitor.visitIterable(new ForwardIterableAccess(this.value));
      }
      deserializeFunction(_visitor) {
        throw new Error("Method not implemented.");
      }
    };
    exports2.Forwarder = Forwarder2;
  }
});

// node_modules/serde/dist/de/generic.js
var require_generic = __commonJS({
  "node_modules/serde/dist/de/generic.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Visitor = void 0;
    var utils_1 = require_utils();
    var interface_1 = require_interface2();
    var Visitor2 = class _Visitor {
      constructor(overrides) {
        Object.defineProperty(this, "overrides", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        this.overrides = overrides;
      }
      static from(visitor) {
        if (visitor instanceof _Visitor || (0, interface_1.isVisitor)(visitor)) {
          return visitor;
        }
        return new this(visitor);
      }
      visitBoolean(value) {
        var _a, _b, _c;
        return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitBoolean) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value;
      }
      visitNumber(value) {
        var _a, _b, _c;
        return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitNumber) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value;
      }
      visitBigInt(value) {
        var _a, _b, _c;
        return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitBigInt) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value;
      }
      visitString(value) {
        var _a, _b, _c;
        return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitString) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value;
      }
      visitSymbol(value) {
        var _a, _b, _c;
        return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value;
      }
      visitNull() {
        var _a, _b, _c;
        return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitNull) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null;
      }
      visitObject(access) {
        var _a, _b;
        if ((0, utils_1.isFunction)((_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitObject)) {
          return (_b = this.overrides) === null || _b === void 0 ? void 0 : _b.visitObject(access);
        }
        const result = [];
        for (const entry of access) {
          result.push(entry);
        }
        return Object.fromEntries(result);
      }
      visitIterable(access) {
        var _a, _b;
        if ((0, utils_1.isFunction)((_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitIterable)) {
          return (_b = this.overrides) === null || _b === void 0 ? void 0 : _b.visitIterable(access);
        }
        const result = [];
        for (const element of access) {
          result.push(element);
        }
        return result;
      }
    };
    exports2.Visitor = Visitor2;
  }
});

// node_modules/serde/dist/de/index.js
var require_de = __commonJS({
  "node_modules/serde/dist/de/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_forward(), exports2);
    __exportStar(require_generic(), exports2);
    __exportStar(require_impl2(), exports2);
    __exportStar(require_interface2(), exports2);
  }
});

// node_modules/serde/dist/index.js
var require_dist = __commonJS({
  "node_modules/serde/dist/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() {
          return m[k];
        } };
      }
      Object.defineProperty(o, k2, desc);
    } : function(o, m, k, k2) {
      if (k2 === void 0) k2 = k;
      o[k2] = m[k];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
    } : function(o, v) {
      o["default"] = v;
    });
    var __importStar = exports2 && exports2.__importStar || /* @__PURE__ */ function() {
      var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function(o2) {
          var ar = [];
          for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
          return ar;
        };
        return ownKeys(o);
      };
      return function(mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) {
          for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        }
        __setModuleDefault(result, mod);
        return result;
      };
    }();
    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.de = exports2.ser = void 0;
    exports2.ser = __importStar(require_ser());
    exports2.de = __importStar(require_de());
    __exportStar(require_registry(), exports2);
    __exportStar(require_utils(), exports2);
  }
});

// src/index.ts
var index_exports = {};
__export(index_exports, {
  fromString: () => fromString,
  toString: () => toString
});
module.exports = __toCommonJS(index_exports);

// src/ser.ts
var import_serde = __toESM(require_dist());
var import_ser = __toESM(require_ser());
var JSONSerializeObject = class extends import_ser.SerializeObject {
  stringify;
  value = {};
  currentKey;
  constructor(stringify2) {
    super();
    this.stringify = stringify2;
  }
  serializeKey(key) {
    this.currentKey = key;
  }
  serializeValue(value) {
    this.value[this.currentKey] = value;
    this.currentKey = void 0;
  }
  end() {
    return this.stringify(this.value);
  }
};
var JSONSerializeIterable = class extends import_ser.SerializeIterable {
  stringify;
  elements = [];
  constructor(stringify2) {
    super();
    this.stringify = stringify2;
  }
  serializeElement(value) {
    this.elements.push(value);
  }
  end() {
    return this.stringify(this.elements);
  }
};
var id = (_ser, value) => value;
var serializer = (registry) => (_key, value) => {
  const ser = (0, import_serde.getSerialize)(value, id, registry);
  return ser(new import_ser.IdentitySerializer(), value);
};
var stringify = (replacer) => (value) => JSON.stringify(value, replacer);
var JSONSerializer = class extends import_ser.Serializer {
  stringify;
  constructor(registry = import_serde.GlobalRegistry) {
    super();
    this.stringify = stringify(serializer(registry));
  }
  serializeAny(value) {
    return this.stringify(value);
  }
  serializeBoolean(value) {
    return JSON.stringify(value);
  }
  serializeNumber(value) {
    return JSON.stringify(value);
  }
  serializeBigInt(value) {
    return JSON.stringify(value);
  }
  serializeString(value) {
    return JSON.stringify(value);
  }
  serializeSymbol(value) {
    return JSON.stringify(value);
  }
  serializeNull() {
    return JSON.stringify(null);
  }
  serializeIterable(_len) {
    return new JSONSerializeIterable(this.stringify);
  }
  serializeObject(_len) {
    return new JSONSerializeObject(this.stringify);
  }
  serializeClass(_name, _len) {
    return new JSONSerializeObject(this.stringify);
  }
};

// src/index.ts
var import_de2 = __toESM(require_de());

// src/de.ts
var import_serde2 = __toESM(require_dist());
var import_de = __toESM(require_de());
var unwrap = (de) => de.deserializeAny(new import_de.Visitor());
var deserializer = (registry = import_serde2.GlobalRegistry) => (_key, value) => {
  const de = (0, import_serde2.getDeserialize)(value, unwrap, registry);
  return de(new import_de.Forwarder(value));
};
var parser = (reviver) => (value) => {
  return JSON.parse(value, reviver);
};
var JSONMapAccess = class extends import_de.MapAccess {
  _entries;
  index = -1;
  constructor(entries) {
    super();
    this._entries = entries;
  }
  static fromObject(value) {
    return new this(Object.entries(value));
  }
  nextKey(seed) {
    this.index += 1;
    if (this.index >= this._entries.length) {
      return import_serde2.IterResult.Done();
    } else {
      const key = this._entries[this.index][0];
      const deser = seed != null ? seed(key) : key;
      return import_serde2.IterResult.Next(deser);
    }
  }
  nextValue(seed) {
    if (this.index >= this._entries.length) {
      return import_serde2.IterResult.Done();
    } else {
      const value = this._entries[this.index][1];
      const deser = seed != null ? seed(value) : value;
      return import_serde2.IterResult.Next(deser);
    }
  }
};
var JSONIterableAccess = class extends import_de.IterableAccess {
  iterator;
  constructor(iterator) {
    super();
    this.iterator = iterator;
  }
  static fromIterable(iterable) {
    return new this(iterable[Symbol.iterator]());
  }
  nextElement(seed) {
    const result = this.iterator.next();
    if (result.done) {
      return import_serde2.IterResult.Done();
    } else {
      const value = seed != null ? seed(result.value) : result.value;
      return import_serde2.IterResult.Next(value);
    }
  }
};
var JSONDeserializer = class {
  input;
  parser;
  constructor(input, registry = import_serde2.GlobalRegistry) {
    this.input = input;
    this.parser = parser(deserializer(registry));
  }
  static fromString(value, registry) {
    return new this(value, registry);
  }
  deserializeAny(_visitor) {
    return this.parser(this.input);
  }
  deserializeBoolean(visitor) {
    return visitor.visitBoolean(this.parser(this.input));
  }
  deserializeNumber(visitor) {
    return visitor.visitNumber(this.parser(this.input));
  }
  deserializeBigInt(visitor) {
    return visitor.visitBigInt(this.parser(this.input));
  }
  deserializeString(visitor) {
    return visitor.visitString(this.parser(this.input));
  }
  deserializeSymbol(visitor) {
    return visitor.visitSymbol(this.parser(this.input));
  }
  deserializeNull(visitor) {
    return visitor.visitNull();
  }
  deserializeObject(visitor) {
    const value = this.parser(this.input);
    return visitor.visitObject(JSONMapAccess.fromObject(value));
  }
  deserializeIterable(visitor) {
    const value = this.parser(this.input);
    return visitor.visitIterable(JSONIterableAccess.fromIterable(value));
  }
  deserializeFunction(_visitor) {
    throw new Error("Method not implemented");
  }
};

// src/index.ts
var import_ser3 = __toESM(require_ser());
function toString(value) {
  const serializer2 = new JSONSerializer();
  return (0, import_ser3.serialize)(serializer2, value);
}
function fromString(value, into) {
  const deserializer2 = JSONDeserializer.fromString(value);
  return (0, import_de2.deserialize)(deserializer2, into);
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  fromString,
  toString
});