"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/node_modules/@tsmetadata/polyfill/lib/index.js
  var require_lib = __commonJS({
    "../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      Symbol.metadata ??= Symbol("Symbol.metadata");
    }
  });

  // ../serde-ts/dist/utils.js
  var require_utils = __commonJS({
    "../serde-ts/dist/utils.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.staticImplements = staticImplements;
      exports.isPlainObject = isPlainObject;
      exports.isFunction = isFunction;
      exports.isIterable = isIterable;
      exports.isString = isString;
      exports.isNumber = isNumber;
      exports.orElse = orElse;
      exports.ifNull = ifNull;
      exports.mixin = mixin2;
      exports.pipe = pipe;
      function staticImplements() {
        return (constructor) => {
          constructor;
        };
      }
      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);
      }
      function orElse(thisArg, a, b2) {
        return function(...args) {
          const fn = a != null ? a : b2;
          return fn.apply(thisArg, args);
        };
      }
      function ifNull(thisArg, b2, ...args) {
        return function(a) {
          return orElse(thisArg, a, b2).apply(thisArg, args);
        };
      }
      function applyMixins(derivedCtor, constructors) {
        constructors.forEach((baseCtor) => {
          Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null));
          });
        });
      }
      function mixin2(impl) {
        return function(constructor) {
          applyMixins(constructor, [impl]);
          return constructor;
        };
      }
      function pipe(arg, firstFn, ...fns) {
        return fns.reduce((acc, fn) => fn(acc), firstFn(arg));
      }
    }
  });

  // ../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.isGenericSerializer = isGenericSerializer;
      var utils_1 = require_utils();
      var TypeSerializerMethods = [
        "serializeString",
        "serializeNumber",
        "serializeBigInt",
        "serializeBoolean",
        "serializeSymbol",
        //'serializeMap',
        "serializeIterable",
        "serializeNull",
        "serializeObject",
        "serializeClass"
      ];
      var AnySerializerMethods = ["serializeAny"];
      function isGenericSerializer(value) {
        return AnySerializerMethods.every((k) => (0, utils_1.isFunction)(value[k])) && TypeSerializerMethods.every((k) => !(0, utils_1.isFunction)(value[k]));
      }
    }
  });

  // ../serde-ts/dist/case.js
  var require_case = __commonJS({
    "../serde-ts/dist/case.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.CaseConvention = void 0;
      exports.convertCase = convertCase;
      exports.CaseConvention = Object.freeze({
        Lowercase: 0,
        Uppercase: 1,
        PascalCase: 2,
        CamelCase: 3,
        SnakeCase: 4,
        ScreamingSnakeCase: 5,
        KebabCase: 6,
        ScreamingKebabCase: 7
      });
      var wordBoundaryRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
      function identifyWords(value) {
        return value && value.match(wordBoundaryRegex);
      }
      var lower = (ch) => ch.toLowerCase();
      var upper = (ch) => ch.toUpperCase();
      var first = (xs) => xs && xs[0];
      var tail = (xs) => xs && xs.slice(1);
      function upperFirst(xs) {
        return upper(first(xs)) + tail(xs);
      }
      function toPascalCase(words) {
        return words.map(lower).map(upperFirst).join("");
      }
      var joinMap = (fn, delim, xs) => {
        return xs.map(fn).join(delim);
      };
      function convertCase(value, convention) {
        const words = identifyWords(value);
        if (!words || words.length <= 0) {
          return "";
        }
        switch (convention) {
          case exports.CaseConvention.Lowercase:
            return words.join("").toLowerCase();
          case exports.CaseConvention.Uppercase:
            return words.join("").toUpperCase();
          case exports.CaseConvention.PascalCase:
            return toPascalCase(words);
          case exports.CaseConvention.CamelCase:
            const pascal = toPascalCase(words);
            return first(pascal).toLowerCase() + tail(pascal);
          case exports.CaseConvention.SnakeCase:
            return joinMap(lower, "_", words);
          case exports.CaseConvention.ScreamingSnakeCase:
            return joinMap(upper, "_", words);
          case exports.CaseConvention.KebabCase:
            return joinMap(lower, "-", words);
          case exports.CaseConvention.ScreamingKebabCase:
            return joinMap(upper, "-", words);
        }
      }
    }
  });

  // ../serde-ts/dist/registry.js
  var require_registry = __commonJS({
    "../serde-ts/dist/registry.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.GlobalRegistry = exports.Registry = void 0;
      var Registry = class {
        constructor() {
          Object.defineProperty(this, "registeredClasses", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: /* @__PURE__ */ new Map()
          });
        }
        add(ctor, key = ctor.name) {
          this.registeredClasses.set(key, ctor);
        }
        get(name) {
          return this.registeredClasses.get(name);
        }
      };
      exports.Registry = Registry;
      exports.GlobalRegistry = new Registry();
    }
  });

  // ../serde-ts/dist/options.js
  var require_options = __commonJS({
    "../serde-ts/dist/options.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.SerdeOptions = exports.Stage = void 0;
      var case_1 = require_case();
      var utils_1 = require_utils();
      var registry_1 = require_registry();
      exports.Stage = Object.freeze({
        Serialize: 0,
        Deserialize: 1
      });
      var SerdeOptions = class {
        get registry() {
          return this.options.registry || registry_1.GlobalRegistry;
        }
        constructor(options = {}, properties = /* @__PURE__ */ new Map()) {
          Object.defineProperty(this, "target", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "options", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          Object.defineProperty(this, "properties", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
          });
          this.options = options;
          this.properties = properties;
        }
        static from(target) {
          return new this(target);
        }
        getClassName(stage) {
          var _a, _b;
          if ((0, utils_1.isString)(this.options.rename)) {
            return this.options.rename;
          } else if (stage === exports.Stage.Serialize && (0, utils_1.isString)((_a = this.options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) {
            return this.options.rename.serialize;
          } else if (stage === exports.Stage.Deserialize && (0, utils_1.isString)((_b = this.options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) {
            return this.options.rename.deserialize;
          } else {
            return this.target.constructor.name;
          }
        }
        getPropertyRename(property, stage, options) {
          var _a, _b;
          if (options != null) {
            if ((0, utils_1.isString)(options.rename)) {
              return options.rename;
            } else if (stage === exports.Stage.Serialize && (0, utils_1.isString)((_a = options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) {
              return options.rename.serialize;
            } else if (stage === exports.Stage.Deserialize && (0, utils_1.isString)((_b = options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) {
              return options.rename.deserialize;
            }
          }
          return property;
        }
        getPropertyCase(name, stage) {
          var _a, _b;
          if ((0, utils_1.isNumber)(this.options.renameAll)) {
            return (0, case_1.convertCase)(name, this.options.renameAll);
          } else if (stage === exports.Stage.Serialize && (0, utils_1.isNumber)((_a = this.options.renameAll) === null || _a === void 0 ? void 0 : _a.serialize)) {
            return (0, case_1.convertCase)(name, this.options.renameAll.serialize);
          } else if (stage === exports.Stage.Deserialize && (0, utils_1.isNumber)((_b = this.options.renameAll) === null || _b === void 0 ? void 0 : _b.deserialize)) {
            return (0, case_1.convertCase)(name, this.options.renameAll.deserialize);
          } else {
            return name;
          }
        }
        getPropertyName(property, stage) {
          const options = this.properties.get(property);
          const name = options != null ? this.getPropertyRename(property, stage, options) : property;
          return this.getPropertyCase(name, stage);
        }
        getSerializationName(property) {
          return this.getPropertyName(property, exports.Stage.Serialize);
        }
        getDeserializationName(property) {
          return this.getPropertyName(property, exports.Stage.Deserialize);
        }
        getDefault(property) {
          const options = this.properties.get(property);
          if (options && (0, utils_1.isFunction)(options.default)) {
            return options.default();
          } else if ((0, utils_1.isFunction)(this.options.default)) {
            return this.options.default();
          }
        }
        //getCustomImpl(property: string, stage: Stage) {
        //  const options = this.properties.get(property)
        //  if (options != null) {
        //    if (stage === Stage.Serialize && isFunction(options.serializeWith)) {
        //      return options.serializeWith
        //    } else if (stage === Stage.Deserialize && isFunction(options.deserializeWith)) {
        //      return options.deserializeWith
        //    }
        //  }
        //}
        //getSerializer(property: string): Nullable<CustomSerializer> {
        //  return this.getCustomImpl(property, Stage.Serialize) as CustomSerializer
        //}
        //getDeserializer(property: string): Nullable<CustomDeserializer> {
        //  return this.getCustomImpl(property, Stage.Deserialize) as CustomDeserializer
        //}
        isConditionalSkip(skip) {
          return "if" in skip && (0, utils_1.isFunction)(skip.if);
        }
        shouldSkip(property, value, stage) {
          const options = this.properties.get(property);
          if (options != null && options.skip != null) {
            if (typeof options.skip === "boolean") {
              return options.skip;
            } else if (this.isConditionalSkip(options.skip)) {
              return options.skip.if(value);
            } else if (stage === exports.Stage.Serialize && typeof options.skip.serializing === "boolean") {
              return options.skip.serializing;
            } else if (stage === exports.Stage.Serialize && this.isConditionalSkip(options.skip.serializing)) {
              return options.skip.serializing.if(value);
            } else if (stage === exports.Stage.Deserialize && typeof options.skip.deserializing === "boolean") {
              return options.skip.deserializing;
            } else if (stage === exports.Stage.Deserialize && this.isConditionalSkip(options.skip.deserializing)) {
              return options.skip.deserializing.if(value);
            }
          }
          return false;
        }
        shouldSkipSerializing(property, value) {
          return this.shouldSkip(property, value, exports.Stage.Serialize);
        }
        shouldSkipDeserializing(property, value) {
          return this.shouldSkip(property, value, exports.Stage.Deserialize);
        }
      };
      exports.SerdeOptions = SerdeOptions;
    }
  });

  // ../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.serializeWith = serializeWith3;
      var options_1 = require_options();
      var utils_1 = require_utils();
      var unhandledType = (serializer, value) => new TypeError(`'${serializer.constructor.name}' has no method for value type '${typeof value}'`);
      function serializeEntries(serializer, value, options) {
        var _a;
        let state;
        for (const [key, val] of value) {
          if (options === null || options === void 0 ? void 0 : options.shouldSkipSerializing(key, val)) {
            continue;
          }
          const name = (_a = options === null || options === void 0 ? void 0 : options.getPropertyName(key, options_1.Stage.Serialize)) !== null && _a !== void 0 ? _a : key;
          state = serializer.serializeKey(name);
          state = serializer.serializeValue(val);
        }
        return serializer.end();
      }
      function serializeObject(serializer, value, options) {
        const ser = serializer.serializeClass(value.constructor.name);
        return serializeEntries(ser, Object.entries(value), options);
      }
      function serializeIter(serializer, value, options) {
        let state;
        for (const val of value) {
          state = serializer.serializeElement(val);
        }
        return serializer.end();
      }
      function defaultOptions(value) {
        return value.constructor[Symbol.metadata].serde;
      }
      function serializeWith3(serializer, value, optionsGetter = defaultOptions) {
        const serializeAny = (0, utils_1.orElse)(serializer, serializer.serializeAny, (value2) => unhandledType(serializer, value2));
        const serialize = (0, utils_1.ifNull)(serializer, serializeAny, value);
        switch (typeof value) {
          case "string":
            return serialize(serializer.serializeString);
          case "number":
            return serialize(serializer.serializeNumber);
          case "bigint":
            return serialize(serializer.serializeBigInt);
          case "boolean":
            return serialize(serializer.serializeBoolean);
          case "symbol":
            return serialize(serializer.serializeSymbol);
          case "undefined":
            return serialize(serializer.serializeNull);
          case "object":
            const options = optionsGetter(value);
            if ((0, utils_1.isIterable)(value) && (0, utils_1.isFunction)(serializer.serializeIterable)) {
              return serializeIter(serializer.serializeIterable(), value, options);
            } else if ((0, utils_1.isFunction)(serializer.serializeObject)) {
              return serializeObject(serializer, value, options);
            }
          // deliberate fallthrough when the above fail
          default:
            return serializeAny(value);
        }
      }
    }
  });

  // ../serde-ts/dist/ser/mixin.js
  var require_mixin = __commonJS({
    "../serde-ts/dist/ser/mixin.js"(exports) {
      "use strict";
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.serialize = serialize;
      var impl_1 = require_impl();
      var interface_1 = require_interface();
      function serialize(constructor) {
        class Serializable2 extends constructor {
          serialize(serializer) {
            if ((0, interface_1.isGenericSerializer)(serializer)) {
              return serializer.serializeAny(this);
            } else {
              return (0, impl_1.serializeWith)(serializer, this);
            }
          }
        }
        Object.defineProperty(Serializable2, "name", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: constructor.name
        });
        return Serializable2;
      }
    }
  });

  // ../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 });
      require_lib();
      __exportStar(require_interface(), exports);
      __exportStar(require_mixin(), exports);
      __exportStar(require_impl(), exports);
    }
  });

  // ../serde-ts/dist/de/generic.js
  var require_generic = __commonJS({
    "../serde-ts/dist/de/generic.js"(exports) {
      "use strict";
      var __esDecorate = exports && exports.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
        function accept(f) {
          if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
          return f;
        }
        var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
        var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
        var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
        var _, done = false;
        for (var i = decorators.length - 1; i >= 0; i--) {
          var context = {};
          for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
          for (var p in contextIn.access) context.access[p] = contextIn.access[p];
          context.addInitializer = function(f) {
            if (done) throw new TypeError("Cannot add initializers after decoration has completed");
            extraInitializers.push(accept(f || null));
          };
          var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
          if (kind === "accessor") {
            if (result === void 0) continue;
            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
            if (_ = accept(result.get)) descriptor.get = _;
            if (_ = accept(result.set)) descriptor.set = _;
            if (_ = accept(result.init)) initializers.unshift(_);
          } else if (_ = accept(result)) {
            if (kind === "field") initializers.unshift(_);
            else descriptor[key] = _;
          }
        }
        if (target) Object.defineProperty(target, contextIn.name, descriptor);
        done = true;
      };
      var __runInitializers = exports && exports.__runInitializers || function(thisArg, initializers, value) {
        var useValue = arguments.length > 2;
        for (var i = 0; i < initializers.length; i++) {
          value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
        }
        return useValue ? value : void 0;
      };
      var __setFunctionName = exports && exports.__setFunctionName || function(f, name, prefix) {
        if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
        return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.GenericVisitor = exports.GenericSeed = void 0;
      var utils_1 = require_utils();
      var GenericSeed = (() => {
        let _classDecorators = [(0, utils_1.staticImplements)()];
        let _classDescriptor;
        let _classExtraInitializers = [];
        let _classThis;
        var GenericSeed2 = _classThis = class {
          static deserialize(deserializer) {
            return deserializer.deserializeAny(new GenericVisitor2());
          }
          deserialize(deserializer) {
            return GenericSeed2.deserialize(deserializer);
          }
        };
        __setFunctionName(_classThis, "GenericSeed");
        (() => {
          const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
          __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
          GenericSeed2 = _classThis = _classDescriptor.value;
          if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
          __runInitializers(_classThis, _classExtraInitializers);
        })();
        return GenericSeed2 = _classThis;
      })();
      exports.GenericSeed = GenericSeed;
      var GenericVisitor2 = class {
        visitString(value) {
          return value;
        }
        visitNumber(value) {
          return value;
        }
        visitBigInt(value) {
          return value;
        }
        visitBoolean(value) {
          return value;
        }
        visitSymbol(value) {
          return value;
        }
        visitNull() {
          return null;
        }
        visitObject(access) {
          const result = {};
          let entry;
          while (entry = access.nextEntry()) {
            result[entry[0]] = entry[1];
          }
          return result;
        }
        visitIterable(access) {
          const result = new Array(access.sizeHint());
          let element;
          while (element = access.nextElement()) {
            result.push(element);
          }
          return result;
        }
      };
      exports.GenericVisitor = GenericVisitor2;
    }
  });

  // ../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.DefaultIterableAccessImpl = exports.DefaultMapAccessImpl = void 0;
      var generic_1 = require_generic();
      var DefaultMapAccessImpl2 = class {
        nextEntrySeed(kseed, vseed) {
          const key = this.nextKeySeed(kseed);
          if (key !== void 0) {
            const value = this.nextValueSeed(vseed);
            if (value !== void 0) {
              return [key, value];
            }
          }
        }
        nextKey() {
          return this.nextValueSeed(generic_1.GenericSeed);
        }
        nextValue() {
          return this.nextValueSeed(generic_1.GenericSeed);
        }
        nextEntry() {
          return this.nextEntrySeed(generic_1.GenericSeed, generic_1.GenericSeed);
        }
      };
      exports.DefaultMapAccessImpl = DefaultMapAccessImpl2;
      var DefaultIterableAccessImpl2 = class {
        nextElement() {
          return this.nextElementSeed(generic_1.GenericSeed);
        }
        sizeHint() {
          return 0;
        }
      };
      exports.DefaultIterableAccessImpl = DefaultIterableAccessImpl2;
    }
  });

  // ../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.deserializeWith = deserializeWith;
      var options_1 = require_options();
      var generic_1 = require_generic();
      function deserializeWith(deserializer, into, options) {
        const visitor = new generic_1.GenericVisitor();
        const target = new into();
        const obj = deserializer.deserializeObject(visitor);
        const newObject = {};
        for (const property in target) {
          const name = options.getPropertyName(property, options_1.Stage.Deserialize);
          const value = obj[name] || options.getDefault(property);
          newObject[property] = value;
          delete obj[name];
        }
        if (options.options.denyUnknownFields && Object.keys(obj).length > 0) {
          throw new TypeError(`Unexpected fields: ${Object.keys(obj).join(", ")}`);
        }
        return Object.assign(target, newObject);
      }
    }
  });

  // ../serde-ts/dist/de/mixin.js
  var require_mixin2 = __commonJS({
    "../serde-ts/dist/de/mixin.js"(exports) {
      "use strict";
      var __esDecorate = exports && exports.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
        function accept(f) {
          if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
          return f;
        }
        var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
        var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
        var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
        var _, done = false;
        for (var i = decorators.length - 1; i >= 0; i--) {
          var context = {};
          for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
          for (var p in contextIn.access) context.access[p] = contextIn.access[p];
          context.addInitializer = function(f) {
            if (done) throw new TypeError("Cannot add initializers after decoration has completed");
            extraInitializers.push(accept(f || null));
          };
          var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
          if (kind === "accessor") {
            if (result === void 0) continue;
            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
            if (_ = accept(result.get)) descriptor.get = _;
            if (_ = accept(result.set)) descriptor.set = _;
            if (_ = accept(result.init)) initializers.unshift(_);
          } else if (_ = accept(result)) {
            if (kind === "field") initializers.unshift(_);
            else descriptor[key] = _;
          }
        }
        if (target) Object.defineProperty(target, contextIn.name, descriptor);
        done = true;
      };
      var __runInitializers = exports && exports.__runInitializers || function(thisArg, initializers, value) {
        var useValue = arguments.length > 2;
        for (var i = 0; i < initializers.length; i++) {
          value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
        }
        return useValue ? value : void 0;
      };
      var __setFunctionName = exports && exports.__setFunctionName || function(f, name, prefix) {
        if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
        return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
      };
      Object.defineProperty(exports, "__esModule", { value: true });
      exports.deserialize = deserialize;
      var utils_1 = require_utils();
      var impl_1 = require_impl2();
      function deserialize(constructor) {
        let Deserializable = (() => {
          let _classDecorators = [(0, utils_1.staticImplements)()];
          let _classDescriptor;
          let _classExtraInitializers = [];
          let _classThis;
          let _classSuper = constructor;
          var Deserializable2 = _classThis = class extends _classSuper {
            static deserialize(deserializer) {
              return (0, impl_1.deserializeWith)(deserializer, this, this[Symbol.metadata].serde);
            }
          };
          __setFunctionName(_classThis, "Deserializable");
          (() => {
            var _a;
            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
            Deserializable2 = _classThis = _classDescriptor.value;
            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
          })();
          Object.defineProperty(_classThis, "name", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: constructor.name
          });
          (() => {
            __runInitializers(_classThis, _classExtraInitializers);
          })();
          return Deserializable2 = _classThis;
        })();
        return Deserializable;
      }
    }
  });

  // ../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_interface2(), exports);
      __exportStar(require_generic(), exports);
      __exportStar(require_mixin2(), exports);
    }
  });

  // src/index.ts
  var import_ser2 = __toESM(require_ser());

  // src/ser.ts
  var import_ser = __toESM(require_ser());
  var JSONObjectSerializer = class {
    ser;
    first = true;
    constructor(serializer) {
      this.ser = serializer;
      serializer.write("{");
    }
    serializeKey(key) {
      if (!this.first) {
        this.ser.write(",");
      } else {
        this.first = false;
      }
      (0, import_ser.serializeWith)(this.ser, key);
      this.ser.write(":");
    }
    serializeValue(value) {
      (0, import_ser.serializeWith)(this.ser, value);
    }
    end() {
      this.ser.write("}");
    }
  };
  var JSONIterableSerializer = class {
    ser;
    first = true;
    constructor(serializer) {
      this.ser = serializer;
      serializer.write("[");
    }
    serializeElement(element) {
      if (!this.first) {
        this.ser.write(",");
      } else {
        this.first = false;
      }
      (0, import_ser.serializeWith)(this.ser, element);
    }
    end() {
      this.ser.write("]");
    }
  };
  var JSONClassSerializer = class {
    outer;
    inner;
    constructor(serializer, name) {
      this.outer = new JSONObjectSerializer(serializer);
      this.serializeKey("type");
      this.serializeValue(name);
      this.serializeKey("object");
      console.log("what the fuckkkkkkkkk");
      this.inner = new JSONObjectSerializer(serializer);
      console.log(this.inner);
    }
    serializeKey(key) {
      console.log(this.inner);
      return this.inner.serializeKey(key);
    }
    serializeValue(value) {
      return this.inner.serializeValue(value);
    }
    end() {
      this.inner.end();
      this.outer.end();
    }
  };
  var JSONSerializer = class {
    output = "";
    write(value) {
      this.output += value;
    }
    serializeString(value) {
      this.write(`"${value}"`);
    }
    serializeBoolean(value) {
      this.write(value.toString());
    }
    serializeSymbol(value) {
      const key = Symbol.keyFor(value);
      if (key) {
        this.write(key);
      } else {
        return this.serializeString(value.toString());
      }
    }
    serializeObject() {
      return new JSONObjectSerializer(this);
    }
    serializeClass(name) {
      return new JSONClassSerializer(this, name);
    }
    serializeNumber(value) {
      this.write(value.toString());
    }
    serializeBigInt(value) {
      this.write(value.toString());
    }
    serializeIterable() {
      return new JSONIterableSerializer(this);
    }
    serializeNull() {
      return this.write("null");
    }
  };

  // src/de.ts
  var import_de = __toESM(require_de());
  var import_utils = __toESM(require_utils());

  // src/err.ts
  var unexpected = (expected, actual, position) => new SyntaxError(`Expected ${expected} at position ${position} (got '${actual}')`);

  // src/de.ts
  var clamp = (value, min, max) => {
    return Math.min(Math.max(value, min), max);
  };
  var isNumeric = (value) => {
    return !isNaN(value);
  };
  var isNumericToken = (value) => {
    return value === Token.Period || value === Token.Hyphen || Token.Digit.includes(value);
  };
  var encoder = new TextEncoder();
  var b = (strings) => encoder.encode(strings[0]);
  var char = (strings) => b(strings)[0];
  var Literal = Object.freeze({
    True: b`true`,
    False: b`false`
  });
  var Token = Object.freeze({
    Space: char` `,
    LeftCurly: char`{`,
    RightCurly: char`}`,
    LeftSquare: char`[`,
    RightSquare: char`]`,
    Quote: char`"`,
    ForwardSlash: char`\\`,
    Digit: b`0123456789`,
    Hyphen: char`-`,
    Period: char`.`,
    Comma: char`,`,
    Colon: char`:`
  });
  var CommaSeparated = @((0, import_utils.mixin)(import_de.DefaultMapAccessImpl)) @((0, import_utils.mixin)(import_de.DefaultIterableAccessImpl)) class {
    de;
    first = true;
    constructor(deserializer) {
      this.de = deserializer;
    }
    nextKeySeed(seed) {
      if (this.de.buffer.peek().next() === Token.RightCurly) {
        return;
      }
      if (!this.first) {
        const take = this.de.buffer.take();
        if (take.next() !== Token.Comma) {
          throw unexpected(",", take.toString(), this.de.buffer.position);
        }
      }
      this.first = false;
      return seed.deserialize(this.de);
    }
    nextValueSeed(seed) {
      const next = this.de.buffer.next();
      if (next !== Token.Colon) {
        console.log(this.de.buffer.toString());
        throw unexpected(":", next.toString(), this.de.buffer.position);
      }
      return seed.deserialize(this.de);
    }
    nextElementSeed(seed) {
      if (this.de.buffer.peek().next() === Token.RightSquare) {
        return;
      }
      if (!this.first) {
        const take = this.de.buffer.take();
        if (take.next() !== Token.Comma) {
          throw unexpected(",", take.toString(), this.de.buffer.position);
        }
      }
      this.first = false;
      return seed.deserialize(this.de);
    }
  };
  var StringBuffer = class _StringBuffer {
    view;
    index = 0;
    encoder;
    decoder;
    get position() {
      return this.index;
    }
    get length() {
      return this.view.byteLength;
    }
    constructor(view, encoder2 = new TextEncoder(), decoder = new TextDecoder()) {
      this.view = view;
      this.encoder = encoder2;
      this.decoder = decoder;
    }
    static fromArrayBuffer(value, encoder2, decoder) {
      return new this(new Uint8Array(value), encoder2, decoder);
    }
    static fromString(value, encoder2 = new TextEncoder(), decoder) {
      return this.fromArrayBuffer(
        encoder2.encode(value),
        encoder2,
        decoder
      );
    }
    next() {
      const value = this.view[this.index];
      this.index += 1;
      return value;
    }
    nextChar() {
      return this.take().toString();
    }
    done() {
      return this.index >= this.view.byteLength;
    }
    toBytes() {
      return this.view.slice(this.index);
    }
    toString() {
      return this.decoder.decode(this.toBytes());
    }
    take(limit = 1) {
      const bytes = this.peek(limit);
      this.index += limit;
      return bytes;
    }
    at(index) {
      return this.view[this.index + index];
    }
    takeWhile(fn) {
      let index = 0;
      while (!this.done() && fn(this.at(index))) {
        index += 1;
      }
      return this.take(index);
    }
    drop(limit) {
      this.index += limit;
      return this;
    }
    peek(limit = 1) {
      const index = this.index;
      return this.slice(index, index + limit);
    }
    startsWith(value) {
      if (typeof value === "string") {
        return this.startsWith(this.encoder.encode(value));
      }
      const length = value.byteLength;
      const bytes = new Uint8Array(value);
      return this.peek(length).toBytes().every((v, i) => v === bytes[i]);
    }
    slice(start, end) {
      return new _StringBuffer(
        this.view.subarray(start, end),
        this.encoder,
        this.decoder
      );
    }
    indexOf(value, start = 0) {
      const search = new Uint8Array(isNumeric(value) ? [value] : value);
      start = clamp(start, this.index, this.length);
      const bytes = this.slice(start);
      for (let i = 0, len = bytes.length; i < len; i++) {
        if (bytes.at(i) === search[0] && bytes.slice(i).startsWith(search)) {
          return i;
        }
      }
      return -1;
    }
  };
  var JSONDeserializer = class {
    buffer;
    constructor(buffer) {
      this.buffer = buffer;
    }
    static fromString(value) {
      return new this(StringBuffer.fromString(value));
    }
    deserializeAny(visitor) {
      const peek = this.buffer.peek();
      const nextByte = peek.take();
      const byte = nextByte.next();
      switch (true) {
        case b`n`.includes(byte):
          return this.deserializeNull(visitor);
        case b`tf`.includes(byte):
          return this.deserializeBoolean(visitor);
        case b`-0123456789`.includes(byte):
          return this.deserializeNumber(visitor);
        case Token.Quote === byte:
          return this.deserializeString(visitor);
        case Token.LeftSquare === byte:
          return this.deserializeIterable(visitor);
        case Token.LeftCurly === byte:
          return this.deserializeObject(visitor);
        default:
          throw new SyntaxError(`Invalid syntax at position ${this.buffer.position}: "${nextByte.toString()}"`);
      }
    }
    deserializeNull(visitor) {
      if (this.buffer.startsWith("null")) {
        this.buffer.take(4);
      }
      return visitor.visitNull();
    }
    _deserializeObject(fn) {
      let next = this.buffer.take();
      if (next.next() === Token.LeftCurly) {
        const value = fn(new CommaSeparated(this));
        next = this.buffer.take();
        if (next.next() === Token.RightCurly) {
          return value;
        } else {
          throw unexpected("}", next.toString(), this.buffer.position);
        }
      } else {
        throw unexpected("{", next.toString(), this.buffer.position);
      }
    }
    deserializeObject(visitor) {
      return this._deserializeObject(visitor.visitObject.bind(visitor));
    }
    deserializeString(visitor) {
      const next = this.buffer.take();
      if (next.next() === Token.Quote) {
        let index = -1;
        do {
          index = this.buffer.indexOf(Token.Quote, index);
        } while (index > -1 && this.buffer.at(index - 1) === Token.ForwardSlash);
        if (index === -1) {
          throw new SyntaxError("Unterminated string literal");
        }
        const bytes = this.buffer.take(index);
        this.buffer.take();
        return visitor.visitString(bytes.toString());
      } else {
        throw unexpected('"', next.toString(), this.buffer.position);
      }
    }
    deserializeNumber(visitor) {
      const next = this.buffer.peek().next();
      if (isNumericToken(next)) {
        const digits = this.buffer.takeWhile(isNumericToken).toString();
        if (digits.length >= 16) {
          const number = BigInt(digits);
          return visitor.visitBigInt(number);
        } else if (digits.length > 0) {
          let number = parseInt(digits.toString(), 10);
          return visitor.visitNumber(number);
        }
      }
      throw unexpected('"-", ".", or 0..=9', next.toString(), this.buffer.position);
    }
    deserializeBigInt(visitor) {
      return this.deserializeNumber(visitor);
    }
    deserializeBoolean(visitor) {
      const next = this.buffer.next();
      let length = 3;
      switch (next) {
        case Literal.False[0]:
          length = 4;
        case Literal.True[0]:
          break;
        default:
          throw unexpected('"true" or "false"', this.buffer.next().toString(), this.buffer.position);
      }
      this.buffer.take(length);
      return visitor.visitBoolean(length === 3);
    }
    deserializeSymbol(_visitor) {
      throw new Error("Method not implemented.");
    }
    deserializeIterable(visitor) {
      let next = this.buffer.take();
      if (next.next() === Token.LeftSquare) {
        const value = visitor.visitIterable(new CommaSeparated(this));
        next = this.buffer.take();
        if (next.next() === Token.RightSquare) {
          return value;
        } else {
          throw unexpected("]", next.toString(), this.buffer.position);
        }
      } else {
        throw unexpected("[", next.toString(), this.buffer.position);
      }
    }
  };

  // src/index.ts
  function toString(value) {
    const serializer = new JSONSerializer();
    (0, import_ser2.serializeWith)(serializer, value);
    return serializer.output;
  }
  function fromString(value, into) {
    const deserializer = JSONDeserializer.fromString(value);
    return into.deserialize(deserializer);
  }
})();