"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/utils.js
var require_utils = __commonJS({
  "../serde-ts/dist/utils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.IterResult = void 0;
    exports2.isPlainObject = isPlainObject;
    exports2.isFunction = isFunction;
    exports2.isIterable = isIterable;
    exports2.isString = isString;
    exports2.isNumber = isNumber;
    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;
  }
});

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

// ../serde-ts/dist/ser/interface.js
var require_interface = __commonJS({
  "../serde-ts/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 SerializeIterable = class {
    };
    exports2.SerializeIterable = SerializeIterable;
    var Serializer = 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.");
      }
      serializeObject() {
        throw new Error("Method not implemented.");
      }
      serializeClass(_name) {
        throw new Error("Method not implemented.");
      }
    };
    exports2.Serializer = Serializer;
  }
});

// ../serde-ts/dist/ser/index.js
var require_ser = __commonJS({
  "../serde-ts/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_impl(), exports2);
    __exportStar(require_interface(), exports2);
  }
});

// ../serde-ts/dist/de/interface.js
var require_interface2 = __commonJS({
  "../serde-ts/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 {
      nextEntrySeed(kseed, vseed) {
        const key = this.nextKeySeed(kseed);
        if (!key.done) {
          const value = this.nextValueSeed(vseed);
          if (!value.done) {
            return utils_1.IterResult.Next([key.value, value.value]);
          }
        }
        return utils_1.IterResult.Done();
      }
      nextEntry() {
        const key = this.nextKey();
        if (!key.done) {
          const value = this.nextValue();
          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(seed == null ? this.nextKey.bind(this) : this.nextKeySeed.bind(this, seed));
      }
      values(seed) {
        return this.generate(seed == null ? this.nextValue.bind(this) : this.nextValueSeed.bind(this, seed));
      }
      entries(kseed, vseed) {
        return this.generate(kseed == null || vseed == null ? this.nextEntry.bind(this) : this.nextEntrySeed.bind(this, kseed, vseed));
      }
      [Symbol.iterator]() {
        return this.entries();
      }
    };
    exports2.MapAccess = MapAccess2;
    var IterableAccess = class {
      *[Symbol.iterator]() {
        return {
          next: this.nextElement
        };
      }
    };
    exports2.IterableAccess = IterableAccess;
    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"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Forward = exports2.ForwardIterableAccess = exports2.ForwardMapAccess = void 0;
    var utils_1 = require_utils();
    var interface_1 = require_interface2();
    var ForwardMapAccess = class _ForwardMapAccess extends interface_1.MapAccess {
      constructor(keys, values) {
        super();
        Object.defineProperty(this, "_keys", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        Object.defineProperty(this, "_values", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        Object.defineProperty(this, "kindex", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: 0
        });
        Object.defineProperty(this, "vindex", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: 0
        });
        this._keys = keys;
        this._values = values;
      }
      static fromObject(obj) {
        return new _ForwardMapAccess(Object.keys(obj), Object.values(obj));
      }
      nextKeySeed(_seed) {
        return this.nextKey();
      }
      nextValueSeed(_seed) {
        return this.nextValue();
      }
      nextKey() {
        if (this.kindex < this.keys.length) {
          return utils_1.IterResult.Next(this._keys[this.kindex++]);
        } else {
          return utils_1.IterResult.Done();
        }
      }
      nextValue() {
        if (this.vindex < this.values.length) {
          return utils_1.IterResult.Next(this._values[this.vindex++]);
        } else {
          return utils_1.IterResult.Done();
        }
      }
    };
    exports2.ForwardMapAccess = ForwardMapAccess;
    var ForwardIterableAccess = class extends interface_1.IterableAccess {
      constructor(items) {
        super();
        Object.defineProperty(this, "items", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        Object.defineProperty(this, "index", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: 0
        });
        this.items = items;
      }
      nextElement() {
        if (this.index < this.items.length) {
          return utils_1.IterResult.Next(this.items[this.index++]);
        } else {
          return utils_1.IterResult.Done();
        }
      }
    };
    exports2.ForwardIterableAccess = ForwardIterableAccess;
    var Forward2 = class {
      constructor(value) {
        Object.defineProperty(this, "value", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        this.value = value;
      }
      static with(value) {
        return new this(value);
      }
      deserializeAny(_visitor) {
        throw new Error("Can't forward to deserializeAny");
      }
      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.Forward = Forward2;
  }
});

// ../serde-ts/dist/de/generic.js
var require_generic = __commonJS({
  "../serde-ts/dist/de/generic.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Visitor = exports2.GenericSeed = void 0;
    var utils_1 = require_utils();
    var interface_1 = require_interface2();
    var GenericSeed2 = class _GenericSeed {
      constructor(visitor = new Visitor2()) {
        Object.defineProperty(this, "visitor", {
          enumerable: true,
          configurable: true,
          writable: true,
          value: void 0
        });
        this.visitor = visitor;
      }
      static deserialize(deserializer, visitor = new Visitor2()) {
        return deserializer.deserializeAny(visitor);
      }
      deserialize(deserializer) {
        return _GenericSeed.deserialize(deserializer, this.visitor);
      }
    };
    exports2.GenericSeed = GenericSeed2;
    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;
  }
});

// ../serde-ts/dist/registry.js
var require_registry = __commonJS({
  "../serde-ts/dist/registry.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.registerDeserializer = exports2.registerSerializer = exports2.GlobalRegistry = exports2.Registry = void 0;
    var Registry2 = 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()
        });
      }
      registerSerializer(ctor, serialize3) {
        this.serializers.set(ctor, serialize3);
      }
      registerDeserializer(ctor, deserialize3) {
        this.deserializers.set(ctor, deserialize3);
      }
    };
    exports2.Registry = Registry2;
    exports2.GlobalRegistry = new Registry2();
    exports2.registerSerializer = exports2.GlobalRegistry.registerSerializer.bind(exports2.GlobalRegistry);
    exports2.registerDeserializer = exports2.GlobalRegistry.registerDeserializer.bind(exports2.GlobalRegistry);
  }
});

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

// ../serde-ts/dist/de/index.js
var require_de = __commonJS({
  "../serde-ts/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);
  }
});

// ../serde-ts/dist/index.js
var require_dist = __commonJS({
  "../serde-ts/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);
  }
});

// test.ts
var import_serde2 = __toESM(require_dist());
var import_de4 = __toESM(require_de());

// src/ser.ts
var import_ser = __toESM(require_ser());
var JSONObjectSerializer = class extends import_ser.SerializeObject {
  ser;
  first = true;
  constructor(serializer) {
    super();
    this.ser = serializer;
    serializer.write("{");
  }
  serializeKey(key) {
    if (!this.first) {
      this.ser.write(",");
    } else {
      this.first = false;
    }
    (0, import_ser.serialize)(this.ser, key);
    this.ser.write(":");
  }
  serializeValue(value) {
    (0, import_ser.serialize)(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.serialize)(this.ser, element);
  }
  end() {
    this.ser.write("]");
  }
};
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 this.serializeObject();
  }
  serializeNumber(value) {
    this.write(value.toString());
  }
  serializeBigInt(value) {
    this.write(value.toString());
  }
  serializeIterable() {
    return new JSONIterableSerializer(this);
  }
  serializeNull() {
    return this.write("null");
  }
};

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

// src/de.ts
var import_serde = __toESM(require_dist());
var import_de = __toESM(require_de());

// 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 = class extends import_de.MapAccess {
  de;
  defaultSeed;
  first = true;
  constructor(deserializer, visitor = new import_de.Visitor()) {
    super();
    this.de = deserializer;
    this.defaultSeed = new import_de.GenericSeed(visitor);
  }
  seed() {
    return this.defaultSeed.deserialize.bind(this.defaultSeed);
  }
  nextItemSeed(seed, end) {
    if (this.de.buffer.peek().next() === end) {
      return import_serde.IterResult.Done();
    }
    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 import_serde.IterResult.Next(seed(this.de));
  }
  nextKeySeed(seed) {
    return this.nextItemSeed(seed, Token.RightCurly);
  }
  nextValueSeed(seed) {
    const next = this.de.buffer.next();
    if (next !== Token.Colon) {
      throw unexpected(":", String.fromCharCode(next), this.de.buffer.position);
    }
    return import_serde.IterResult.Next(seed(this.de));
  }
  nextItem(end) {
    return this.nextItemSeed(this.seed(), end);
  }
  nextKey() {
    return this.nextItem(Token.RightCurly);
  }
  nextValue() {
    return this.nextValueSeed(this.seed());
  }
  nextElement() {
    return this.nextItem(Token.RightSquare);
  }
};
var ByteArray = class _ByteArray {
  view;
  encoder;
  decoder;
  index = 0;
  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);
  }
  takeUntil(fn) {
    return this.takeWhile((v) => !fn(v));
  }
  drop(limit) {
    this.index += limit;
    return this;
  }
  dropWhile(fn) {
    let index = 0;
    while (!this.done() && fn(this.at(index))) {
      index += 1;
    }
    return this.drop(index);
  }
  dropUntil(fn) {
    return this.dropWhile((v) => !fn(v));
  }
  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 _ByteArray(
      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;
  registry;
  constructor(buffer, registry = import_serde.GlobalRegistry) {
    this.buffer = buffer;
    this.registry = registry;
  }
  static fromString(value) {
    return new this(ByteArray.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(visitor) {
    let next = this.buffer.take();
    if (next.next() === Token.LeftCurly) {
      const value = visitor.visitObject(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);
    }
  }
  deserializeClass(_name, visitor) {
    return this.deserializeObject(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);
    }
  }
  deserializeFunction(_visitor) {
    throw new Error("Method not implemented.");
  }
};

// src/index.ts
var import_ser3 = __toESM(require_ser());
function toString(value) {
  const serializer = new JSONSerializer();
  (0, import_ser3.serialize)(serializer, value);
  return serializer.output;
}
function fromString(value, into) {
  const deserializer = JSONDeserializer.fromString(value);
  return (0, import_de2.deserialize)(deserializer, into);
}

// test.ts
var InnerStruct = class {
  value;
  constructor(v) {
    this.value = v;
  }
};
var TestStruct = class {
  aNumber;
  innerStruct;
  constructor(str2, n) {
    this.aNumber = n;
    this.innerStruct = new InnerStruct(str2);
  }
};
var test = new TestStruct("hi :3", 69);
(0, import_serde2.registerSerializer)(InnerStruct, (ser, value) => ser.serializeAny?.(value));
(0, import_serde2.registerDeserializer)(InnerStruct, (de2) => de2.deserializeObject({
  visitObject(access) {
    let value;
    for (const [key, val] of access) {
      if (key === "value") {
        value = val;
        break;
      }
    }
    return new InnerStruct(value);
  }
}));
(0, import_serde2.registerDeserializer)(TestStruct, (de2) => de2.deserializeObject({
  visitObject(access) {
    let str2, num;
    for (const [key, value] of access) {
      switch (key) {
        case "aNumber":
          num = value;
          break;
        case "innerStruct":
          const inner = (0, import_de4.deserialize)(import_de4.Forward.with(value), InnerStruct);
          str2 = inner.value;
          break;
      }
    }
    return new TestStruct(str2, num);
  }
}));
(0, import_serde2.registerSerializer)(TestStruct, (ser, value) => ser.serializeAny?.(value));
var str = toString(test);
console.log(str);
var de = fromString(str, TestStruct);
console.log(de);