"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 __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
  ));

  // ../serde-ts/dist/ser/interface.js
  var require_interface = __commonJS({
    "../serde-ts/dist/ser/interface.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Serializer = exports.SerializeIterable = exports.SerializeObject = void 0;
      var SerializeObject2 = class {
        serializeEntry(key, value) {
          this.serializeKey(key);
          this.serializeValue(value);
        }
      };
      exports.SerializeObject = SerializeObject2;
      var SerializeIterable2 = class {
      };
      exports.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.");
        }
      };
      exports.Serializer = Serializer2;
    }
  });

  // ../serde-ts/dist/ser/identity.js
  var require_identity = __commonJS({
    "../serde-ts/dist/ser/identity.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.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();
        }
      };
      exports.IdentitySerializer = IdentitySerializer2;
    }
  });

  // ../serde-ts/dist/utils.js
  var require_utils = __commonJS({
    "../serde-ts/dist/utils.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.PrimitivePrototype = exports.IterResult = void 0;
      exports.isObject = isObject;
      exports.isPlainObject = isPlainObject;
      exports.isFunction = isFunction;
      exports.isIterable = isIterable;
      exports.isString = isString;
      exports.isNumber = isNumber;
      exports.Null = Null;
      exports.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 };
        }
      };
      exports.IterResult = IterResult2;
      function Null(...args) {
        return null;
      }
      exports.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 exports.PrimitivePrototype[typeof value];
        }
      }
    }
  });

  // ../serde-ts/dist/registry.js
  var require_registry = __commonJS({
    "../serde-ts/dist/registry.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.registerDeserialize = exports.registerSerialize = exports.GlobalRegistry = exports.Registry = void 0;
      exports.getSerialize = getSerialize2;
      exports.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);
        }
      };
      exports.Registry = Registry3;
      exports.GlobalRegistry = new Registry3();
      exports.registerSerialize = exports.GlobalRegistry.registerSerialize.bind(exports.GlobalRegistry);
      exports.registerDeserialize = exports.GlobalRegistry.registerDeserialize.bind(exports.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, exports.registerSerialize)(Boolean, (ser, value) => ser.serializeBoolean(value));
      (0, exports.registerSerialize)(String, (ser, value) => ser.serializeString(value));
      (0, exports.registerSerialize)(Number, (ser, value) => ser.serializeNumber(value));
      (0, exports.registerSerialize)(BigInt, (ser, value) => ser.serializeBigInt(value));
      (0, exports.registerSerialize)(Symbol, (ser, value) => ser.serializeSymbol(value));
      (0, exports.registerSerialize)(utils_1.Null, (ser, _value) => ser.serializeNull());
      (0, exports.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, exports.registerSerialize)(Array, (ser, value) => {
        const arr = value;
        const iter = ser.serializeIterable(arr.length);
        arr.forEach((value2) => iter.serializeElement(value2));
        return iter.end();
      });
      (0, exports.registerDeserialize)(Boolean, (de) => de.deserializeBoolean({
        visitBoolean(value) {
          return value;
        }
      }));
      (0, exports.registerDeserialize)(String, (de) => de.deserializeString({
        visitString(value) {
          return value;
        }
      }));
      (0, exports.registerDeserialize)(Number, (de) => de.deserializeNumber({
        visitNumber(value) {
          return value;
        }
      }));
      (0, exports.registerDeserialize)(BigInt, (de) => de.deserializeBigInt({
        visitBigInt(value) {
          return value;
        }
      }));
      (0, exports.registerDeserialize)(Symbol, (de) => de.deserializeSymbol({
        visitSymbol(value) {
          return value;
        }
      }));
      (0, exports.registerDeserialize)(Object, (de) => de.deserializeObject({
        visitObject(access) {
          let result = {};
          for (const [key, value] of access) {
            result[key] = value;
          }
          return result;
        }
      }));
      (0, exports.registerDeserialize)(Array, (de) => de.deserializeIterable({
        visitIterable(access) {
          let result = [];
          for (const value of access) {
            result.push(value);
          }
          return result;
        }
      }));
    }
  });

  // ../serde-ts/dist/ser/impl.js
  var require_impl = __commonJS({
    "../serde-ts/dist/ser/impl.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.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);
      }
    }
  });

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

  // ../serde-ts/dist/de/impl.js
  var require_impl2 = __commonJS({
    "../serde-ts/dist/de/impl.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.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);
        }
      }
    }
  });

  // ../serde-ts/dist/de/interface.js
  var require_interface2 = __commonJS({
    "../serde-ts/dist/de/interface.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.IterableAccess = exports.MapAccess = void 0;
      exports.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();
        }
      };
      exports.MapAccess = MapAccess2;
      var IterableAccess2 = class {
        [Symbol.iterator]() {
          return {
            next: this.nextElement.bind(this)
          };
        }
      };
      exports.IterableAccess = IterableAccess2;
      var VisitorMethods = Object.freeze([
        "visitBoolean",
        "visitNumber",
        "visitBigInt",
        "visitString",
        "visitSymbol",
        "visitNull",
        "visitObject",
        "visitIterable"
      ]);
      function isVisitor(visitor) {
        return VisitorMethods.every((method) => method in visitor);
      }
    }
  });

  // ../serde-ts/dist/de/forward.js
  var require_forward = __commonJS({
    "../serde-ts/dist/de/forward.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.Forwarder = void 0;
      exports.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.");
        }
      };
      exports.Forwarder = Forwarder2;
    }
  });

  // ../serde-ts/dist/de/generic.js
  var require_generic = __commonJS({
    "../serde-ts/dist/de/generic.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.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;
        }
      };
      exports.Visitor = Visitor2;
    }
  });

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

  // ../serde-ts/dist/index.js
  var require_dist = __commonJS({
    "../serde-ts/dist/index.js"(exports) {
      "use strict";
      var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
        if (k2 === void 0) k2 = k;
        var desc = Object.getOwnPropertyDescriptor(m, k);
        if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
          desc = { enumerable: true, get: function() {
            return m[k];
          } };
        }
        Object.defineProperty(o, k2, desc);
      } : function(o, m, k, k2) {
        if (k2 === void 0) k2 = k;
        o[k2] = m[k];
      });
      var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
        Object.defineProperty(o, "default", { enumerable: true, value: v });
      } : function(o, v) {
        o["default"] = v;
      });
      var __importStar = exports && exports.__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 = exports && exports.__exportStar || function(m, exports2) {
        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.de = exports.ser = void 0;
      exports.ser = __importStar(require_ser());
      exports.de = __importStar(require_de());
      __exportStar(require_registry(), exports);
      __exportStar(require_utils(), exports);
    }
  });

  // src/ser.ts
  var import_serde = __toESM(require_dist(), 1);
  var import_ser = __toESM(require_ser(), 1);
  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(), 1);

  // src/de.ts
  var import_serde2 = __toESM(require_dist(), 1);
  var import_de = __toESM(require_de(), 1);
  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(), 1);
  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);
  }
})();