From 5cc7e6d265fe4512d5a67b7d85f413d5600b6923 Mon Sep 17 00:00:00 2001 From: rowan Date: Sun, 25 May 2025 13:02:20 -0500 Subject: [PATCH] update readme --- README.md | 3 + dist/test.js | 1174 ++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1177 insertions(+) create mode 100644 dist/test.js diff --git a/README.md b/README.md index fc426af..2c6ff6f 100644 --- a/README.md +++ b/README.md @@ -2,6 +2,9 @@ a (de)serializer for [serde-ts](https://git.kitsu.cafe/rowan/serde-ts) # Usage +`fromString` and `toString` are provided as easy entrypoints into the (de)serializer. `JSONSerializer` and `JSONDeserializer` are also directly usable in more complex scenarios + +# Example ```ts import { Null, registerSerialize, registerDeserialize } from 'serde' import { ISerializer } from 'serde/ser' diff --git a/dist/test.js b/dist/test.js new file mode 100644 index 0000000..c55082f --- /dev/null +++ b/dist/test.js @@ -0,0 +1,1174 @@ +"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 = forward2; + var impl_1 = require_impl2(); + var interface_1 = require_interface2(); + var registry_1 = require_registry(); + var utils_1 = require_utils(); + function forward2(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); + } +}); + +// test.ts +var import_serde3 = __toESM(require_dist(), 1); +var import_de4 = __toESM(require_de(), 1); + +// 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); +} + +// test.ts +var Vector2 = class _Vector2 { + x; + y; + constructor(x, y) { + this.x = x; + this.y = y; + } + static serialize(serializer2, value) { + const iter = serializer2.serializeIterable(); + iter.serializeElement(value.x); + iter.serializeElement(value.y); + return iter.end(); + } + static deserialize(deserializer2) { + return deserializer2.deserializeIterable({ + // we could implement visitNumber here, but we'll let the default + // deserializer handle it + visitIterable(access) { + const elements = []; + for (const item of access) { + elements.push(item); + } + return new _Vector2(elements[0], elements[1]); + } + }); + } +}; +var Entity = class _Entity { + name; + position; + constructor(name, position) { + this.name = name; + this.position = position; + } + static serialize(serializer2, value) { + const ser = serializer2.serializeObject(); + ser.serializeEntry("name", value.name); + ser.serializeEntry("position", value.position); + return ser.end(); + } + static deserialize(deserializer2) { + return deserializer2.deserializeObject({ + visitObject(access) { + let name, position; + for (const [key, value] of access) { + switch (key) { + case "name": + name = value; + break; + case "position": + position = (0, import_de4.forward)(value, Vector2); + break; + } + } + return new _Entity(name, position); + } + }); + } +}; +(0, import_serde3.registerSerialize)(Vector2, Vector2.serialize); +(0, import_serde3.registerDeserialize)(Vector2, Vector2.deserialize); +(0, import_serde3.registerSerialize)(Entity, Entity.serialize); +(0, import_serde3.registerDeserialize)(Entity, Entity.deserialize); +var one = new Vector2(1, 1); +var serialized = toString(one); +console.log(serialized); +var deserializedOne = fromString(serialized, Vector2); +console.log(deserializedOne); +var player = new Entity("Player", one); +var serializedPlayer = toString(player); +console.log(serializedPlayer); +var deserializedPlayer = fromString(serializedPlayer, Entity); +console.log(deserializedPlayer); +var Recipient = class _Recipient { + static { + (0, import_serde3.registerSerialize)(_Recipient, _Recipient.serialize); + (0, import_serde3.registerDeserialize)(_Recipient, _Recipient.deserialize); + } + displayName; + email; + constructor(displayName, email) { + this.displayName = displayName; + this.email = email; + } + static serialize(serializer2, recipient) { + return serializer2.serializeString(`${recipient.displayName}<${recipient.email}>`); + } + static deserialize(deserializer2) { + return deserializer2.deserializeString({ + visitString(value) { + let [displayName, email] = value.split("<"); + email = email.slice(0, -1); + return new _Recipient(displayName, email); + } + }); + } +}; +var Message = class _Message { + static { + (0, import_serde3.registerSerialize)(_Message, _Message.serialize); + (0, import_serde3.registerDeserialize)(_Message, _Message.deserialize); + } + from; + to; + text; + constructor(from, to, text) { + this.from = from; + this.to = to; + this.text = text; + } + static serialize(serializer2, message2) { + const serializeObj = serializer2.serializeObject(); + serializeObj.serializeEntry("from", message2.from); + serializeObj.serializeEntry("to", message2.to); + serializeObj.serializeEntry("text", message2.text); + return serializeObj.end(); + } + static deserialize(deserializer2) { + return deserializer2.deserializeObject({ + visitObject(access) { + let from, to, text; + for (const [key, value] of access) { + switch (key) { + case "from": + from = (0, import_de4.forward)(value, Recipient); + break; + case "to": + to = value.map((v) => (0, import_de4.forward)(v, Recipient)); + break; + case "text": + text = value; + break; + } + } + return new _Message(from, to, text); + } + }); + } +}; +var bob = new Recipient("Bob", "bob@security.lol"); +var alice = new Recipient("Alice", "alice@balloon.party"); +var alicesMom = new Recipient("Alice's Mom", "alice.mom@malware.zip"); +var message = new Message(bob, [alice, alicesMom], "i hope this email finds you before i do"); +var messageSerial = toString(message); +console.log(messageSerial); +var messageDecereal = fromString(messageSerial, Message); +console.log(messageDecereal);