diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..972a198 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,1023 @@ +"use strict"; +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + + // ../serde-ts/dist/ser/interface.js + var require_interface = __commonJS({ + "../serde-ts/dist/ser/interface.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Serializer = exports.SerializeIterable = exports.SerializeObject = void 0; + var SerializeObject2 = class { + serializeEntry(key, value) { + this.serializeKey(key); + this.serializeValue(value); + } + }; + exports.SerializeObject = SerializeObject2; + var SerializeIterable2 = class { + }; + exports.SerializeIterable = SerializeIterable2; + var Serializer2 = class { + serializeAny(_value) { + throw new Error("Method not implemented."); + } + serializeBoolean(_value) { + throw new Error("Method not implemented."); + } + serializeNumber(_value) { + throw new Error("Method not implemented."); + } + serializeBigInt(_value) { + throw new Error("Method not implemented."); + } + serializeString(_value) { + throw new Error("Method not implemented."); + } + serializeSymbol(_value) { + throw new Error("Method not implemented."); + } + serializeNull() { + throw new Error("Method not implemented."); + } + serializeIterable(_len) { + throw new Error("Method not implemented."); + } + serializeObject(_len) { + throw new Error("Method not implemented."); + } + serializeClass(_name, _len) { + throw new Error("Method not implemented."); + } + }; + exports.Serializer = Serializer2; + } + }); + + // ../serde-ts/dist/ser/identity.js + var require_identity = __commonJS({ + "../serde-ts/dist/ser/identity.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.IdentitySerializer = void 0; + var interface_1 = require_interface(); + var IdentityMap = class extends interface_1.SerializeObject { + constructor() { + super(...arguments); + Object.defineProperty(this, "value", { + enumerable: true, + configurable: true, + writable: true, + value: {} + }); + Object.defineProperty(this, "currentKey", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + } + serializeKey(key) { + this.currentKey = key; + } + serializeValue(value) { + this.value[this.currentKey] = value; + } + end() { + return this.value; + } + }; + var IdentityIterable = class extends interface_1.SerializeIterable { + constructor() { + super(...arguments); + Object.defineProperty(this, "value", { + enumerable: true, + configurable: true, + writable: true, + value: [] + }); + } + serializeElement(value) { + this.value.push(value); + } + end() { + return this.value; + } + }; + var IdentitySerializer2 = class { + serializeAny(value) { + return value; + } + serializeBoolean(value) { + return value; + } + serializeNumber(value) { + return value; + } + serializeBigInt(value) { + return value; + } + serializeString(value) { + return value; + } + serializeSymbol(value) { + return value; + } + serializeNull() { + return null; + } + serializeIterable(_len) { + return new IdentityIterable(); + } + serializeObject(_len) { + return new IdentityMap(); + } + serializeClass(_name, _len) { + return new IdentityMap(); + } + }; + exports.IdentitySerializer = IdentitySerializer2; + } + }); + + // ../serde-ts/dist/utils.js + var require_utils = __commonJS({ + "../serde-ts/dist/utils.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.PrimitivePrototype = exports.IterResult = void 0; + exports.isObject = isObject; + exports.isPlainObject = isPlainObject; + exports.isFunction = isFunction; + exports.isIterable = isIterable; + exports.isString = isString; + exports.isNumber = isNumber; + exports.Null = Null; + exports.type = type; + function isObject(value) { + return typeof value === "object" && !Array.isArray(value); + } + function isPlainObject(value) { + return Object.getPrototypeOf(value) === Object.prototype; + } + function isFunction(value) { + return value != null && typeof value === "function"; + } + function isIterable(value) { + return isFunction(value[Symbol.iterator]); + } + function isString(value) { + return typeof value === "string"; + } + function isNumber(value) { + return !isNaN(value); + } + var IterResult2 = class { + static Next(value) { + return { done: false, value }; + } + static Done() { + return { done: true, value: void 0 }; + } + }; + exports.IterResult = IterResult2; + function Null(...args) { + return null; + } + exports.PrimitivePrototype = Object.freeze({ + undefined: Null, + boolean: Boolean, + number: Number, + bigint: BigInt, + string: String, + symbol: Symbol, + object: Object, + function: Function + }); + function type(value) { + switch (true) { + case Array.isArray(value): + return Array; + case isPlainObject(value): + return Object; + case isObject(value): + return value.constructor; + default: + return exports.PrimitivePrototype[typeof value]; + } + } + } + }); + + // ../serde-ts/dist/registry.js + var require_registry = __commonJS({ + "../serde-ts/dist/registry.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.registerDeserialize = exports.registerSerialize = exports.GlobalRegistry = exports.Registry = void 0; + exports.getSerialize = getSerialize2; + exports.getDeserialize = getDeserialize2; + var utils_1 = require_utils(); + var Registry3 = class { + constructor() { + Object.defineProperty(this, "serializers", { + enumerable: true, + configurable: true, + writable: true, + value: /* @__PURE__ */ new Map() + }); + Object.defineProperty(this, "deserializers", { + enumerable: true, + configurable: true, + writable: true, + value: /* @__PURE__ */ new Map() + }); + } + registerSerialize(ctor, serialize3) { + this.serializers.set(ctor, serialize3); + } + registerDeserialize(ctor, deserialize2) { + this.deserializers.set(ctor, deserialize2); + } + }; + exports.Registry = Registry3; + exports.GlobalRegistry = new Registry3(); + exports.registerSerialize = exports.GlobalRegistry.registerSerialize.bind(exports.GlobalRegistry); + exports.registerDeserialize = exports.GlobalRegistry.registerDeserialize.bind(exports.GlobalRegistry); + function getFrom(map, value) { + return map.get((0, utils_1.type)(value)); + } + function getSerialize2(value, fallback, registry) { + return getFrom(registry.serializers, value) || fallback; + } + function getDeserialize2(value, fallback, registry) { + return getFrom(registry.deserializers, value) || fallback; + } + (0, exports.registerSerialize)(Boolean, (ser, value) => ser.serializeBoolean(value)); + (0, exports.registerSerialize)(String, (ser, value) => ser.serializeString(value)); + (0, exports.registerSerialize)(Number, (ser, value) => ser.serializeNumber(value)); + (0, exports.registerSerialize)(BigInt, (ser, value) => ser.serializeBigInt(value)); + (0, exports.registerSerialize)(Symbol, (ser, value) => ser.serializeSymbol(value)); + (0, exports.registerSerialize)(utils_1.Null, (ser, _value) => ser.serializeNull()); + (0, exports.registerSerialize)(Object, (ser, value) => { + const obj = Object.entries(value); + const serObj = ser.serializeObject(obj.length); + obj.forEach(([key, value2]) => serObj.serializeEntry(key, value2)); + return serObj.end(); + }); + (0, exports.registerSerialize)(Array, (ser, value) => { + const arr = value; + const iter = ser.serializeIterable(arr.length); + arr.forEach((value2) => iter.serializeElement(value2)); + return iter.end(); + }); + (0, exports.registerDeserialize)(Boolean, (de) => de.deserializeBoolean({ + visitBoolean(value) { + return value; + } + })); + (0, exports.registerDeserialize)(String, (de) => de.deserializeString({ + visitString(value) { + return value; + } + })); + (0, exports.registerDeserialize)(Number, (de) => de.deserializeNumber({ + visitNumber(value) { + return value; + } + })); + (0, exports.registerDeserialize)(BigInt, (de) => de.deserializeBigInt({ + visitBigInt(value) { + return value; + } + })); + (0, exports.registerDeserialize)(Symbol, (de) => de.deserializeSymbol({ + visitSymbol(value) { + return value; + } + })); + (0, exports.registerDeserialize)(Object, (de) => de.deserializeObject({ + visitObject(access) { + let result = {}; + for (const [key, value] of access) { + result[key] = value; + } + return result; + } + })); + (0, exports.registerDeserialize)(Array, (de) => de.deserializeIterable({ + visitIterable(access) { + let result = []; + for (const value of access) { + result.push(value); + } + return result; + } + })); + } + }); + + // ../serde-ts/dist/ser/impl.js + var require_impl = __commonJS({ + "../serde-ts/dist/ser/impl.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.serialize = serialize3; + var utils_1 = require_utils(); + var registry_1 = require_registry(); + var UnhandledTypeError = class extends TypeError { + constructor(serializer2, value) { + super(`unhandled type: '${typeof value}' for serializer ${serializer2.constructor.name}`); + } + }; + function serializeObject(serializer2, obj) { + for (const key in obj) { + const value = obj[key]; + serializer2.serializeEntry(key, value); + } + return serializer2.end(); + } + function serializeIterable(serializer2, iter) { + for (const item of iter) { + serializer2.serializeElement(item); + } + return serializer2.end(); + } + function serializeClass(serializer2, value) { + const name = value.constructor.name; + const ser = serializer2.serializeClass(name); + return serializeObject(ser, value); + } + function defaultSerialize(serializer2, value) { + switch (typeof value) { + case "string": + return serializer2.serializeString(value); + case "number": + return serializer2.serializeNumber(value); + case "bigint": + return serializer2.serializeBigInt(value); + case "boolean": + return serializer2.serializeBoolean(value); + case "symbol": + return serializer2.serializeSymbol(value); + case "undefined": + return serializer2.serializeNull(); + case "object": + switch (true) { + case value == null: + return serializer2.serializeNull(); + case Array.isArray(value): + return serializeIterable(serializer2.serializeIterable(value.length), value); + case !(0, utils_1.isPlainObject)(value): + return serializeClass(serializer2, value); + default: + return serializeObject(serializer2.serializeObject(), value); + } + default: + throw new UnhandledTypeError(serializer2, value); + } + } + function serialize3(serializer2, value, registry = registry_1.GlobalRegistry) { + const ser = (0, registry_1.getSerialize)(value, defaultSerialize, registry); + return ser(serializer2, value); + } + } + }); + + // ../serde-ts/dist/ser/index.js + var require_ser = __commonJS({ + "../serde-ts/dist/ser/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar(require_identity(), exports); + __exportStar(require_impl(), exports); + __exportStar(require_interface(), exports); + } + }); + + // ../serde-ts/dist/de/impl.js + var require_impl2 = __commonJS({ + "../serde-ts/dist/de/impl.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.deserialize = deserialize2; + var registry_1 = require_registry(); + function deserialize2(deserializer2, into, registry = registry_1.GlobalRegistry) { + const de = registry.deserializers.get(into); + if (de == null) { + throw new ReferenceError(`No deserializer for ${into.name}`); + } else { + return de(deserializer2); + } + } + } + }); + + // ../serde-ts/dist/de/interface.js + var require_interface2 = __commonJS({ + "../serde-ts/dist/de/interface.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.IterableAccess = exports.MapAccess = void 0; + exports.isVisitor = isVisitor; + var utils_1 = require_utils(); + var MapAccess2 = class { + nextEntry(kseed, vseed) { + const key = this.nextKey(kseed); + if (!key.done) { + const value = this.nextValue(vseed); + if (!value.done) { + return utils_1.IterResult.Next([key.value, value.value]); + } + } + return utils_1.IterResult.Done(); + } + *generate(next) { + let item; + while ((item = next()) && !item.done) { + yield item.value; + } + } + keys(seed) { + return this.generate(this.nextKey.bind(this, seed)); + } + values(seed) { + return this.generate(this.nextValue.bind(this, seed)); + } + entries(kseed, vseed) { + return this.generate(this.nextEntry.bind(this, kseed, vseed)); + } + [Symbol.iterator]() { + return this.entries(); + } + }; + exports.MapAccess = MapAccess2; + var IterableAccess2 = class { + [Symbol.iterator]() { + return { + next: this.nextElement.bind(this) + }; + } + }; + exports.IterableAccess = IterableAccess2; + var VisitorMethods = Object.freeze([ + "visitBoolean", + "visitNumber", + "visitBigInt", + "visitString", + "visitSymbol", + "visitNull", + "visitObject", + "visitIterable" + ]); + function isVisitor(visitor) { + return VisitorMethods.every((method) => method in visitor); + } + } + }); + + // ../serde-ts/dist/de/forward.js + var require_forward = __commonJS({ + "../serde-ts/dist/de/forward.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Forwarder = void 0; + exports.forward = forward; + var impl_1 = require_impl2(); + var interface_1 = require_interface2(); + var registry_1 = require_registry(); + var utils_1 = require_utils(); + function forward(value, into, registry = registry_1.GlobalRegistry) { + const forwarder = new Forwarder2(value); + return (0, impl_1.deserialize)(forwarder, into, registry); + } + var ForwardMapAccess = class extends interface_1.MapAccess { + constructor(entries) { + super(); + Object.defineProperty(this, "_entries", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "index", { + enumerable: true, + configurable: true, + writable: true, + value: -1 + }); + this._entries = entries; + } + static fromObject(value) { + return new this(Object.entries(value)); + } + nextKey(seed) { + this.index += 1; + if (this.index >= this._entries.length) { + return utils_1.IterResult.Done(); + } else { + const key = this._entries[this.index][0]; + const value = seed != null ? seed(new Forwarder2(key)) : key; + return utils_1.IterResult.Next(value); + } + } + nextValue(seed) { + if (this.index >= this._entries.length) { + return utils_1.IterResult.Done(); + } else { + const value = this._entries[this.index][1]; + const deser = seed != null ? seed(value) : value; + return utils_1.IterResult.Next(deser); + } + } + }; + var ForwardIterableAccess = class extends interface_1.IterableAccess { + constructor(elements) { + super(); + Object.defineProperty(this, "elements", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + Object.defineProperty(this, "index", { + enumerable: true, + configurable: true, + writable: true, + value: -1 + }); + this.elements = elements; + } + nextElement(seed) { + this.index += 1; + if (this.index >= this.elements.length) { + return utils_1.IterResult.Done(); + } else { + const element = this.elements[this.index]; + const deser = seed != null ? seed(new Forwarder2(element)) : element; + return utils_1.IterResult.Next(deser); + } + } + }; + var Forwarder2 = class { + constructor(value) { + Object.defineProperty(this, "value", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.value = value; + } + deserializeAny(visitor) { + switch (typeof this.value) { + case "string": + return this.deserializeString(visitor); + case "number": + return this.deserializeNumber(visitor); + case "bigint": + return this.deserializeBigInt(visitor); + case "boolean": + return this.deserializeBoolean(visitor); + case "symbol": + return this.deserializeSymbol(visitor); + case "undefined": + return this.deserializeNull(visitor); + case "object": { + switch (true) { + case Array.isArray(this.value): + return this.deserializeIterable(visitor); + default: + return this.deserializeObject(visitor); + } + } + case "function": + return this.deserializeFunction(visitor); + } + } + deserializeBoolean(visitor) { + return visitor.visitBoolean(this.value); + } + deserializeNumber(visitor) { + return visitor.visitNumber(this.value); + } + deserializeBigInt(visitor) { + return visitor.visitBigInt(this.value); + } + deserializeString(visitor) { + return visitor.visitString(this.value); + } + deserializeSymbol(visitor) { + return visitor.visitSymbol(this.value); + } + deserializeNull(visitor) { + return visitor.visitNull(); + } + deserializeObject(visitor) { + return visitor.visitObject(ForwardMapAccess.fromObject(this.value)); + } + deserializeIterable(visitor) { + return visitor.visitIterable(new ForwardIterableAccess(this.value)); + } + deserializeFunction(_visitor) { + throw new Error("Method not implemented."); + } + }; + exports.Forwarder = Forwarder2; + } + }); + + // ../serde-ts/dist/de/generic.js + var require_generic = __commonJS({ + "../serde-ts/dist/de/generic.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.Visitor = void 0; + var utils_1 = require_utils(); + var interface_1 = require_interface2(); + var Visitor2 = class _Visitor { + constructor(overrides) { + Object.defineProperty(this, "overrides", { + enumerable: true, + configurable: true, + writable: true, + value: void 0 + }); + this.overrides = overrides; + } + static from(visitor) { + if (visitor instanceof _Visitor || (0, interface_1.isVisitor)(visitor)) { + return visitor; + } + return new this(visitor); + } + visitBoolean(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitBoolean) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitNumber(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitNumber) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitBigInt(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitBigInt) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitString(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitString) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitSymbol(value) { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : value; + } + visitNull() { + var _a, _b, _c; + return (_c = (_b = (_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitNull) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : null; + } + visitObject(access) { + var _a, _b; + if ((0, utils_1.isFunction)((_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitObject)) { + return (_b = this.overrides) === null || _b === void 0 ? void 0 : _b.visitObject(access); + } + const result = []; + for (const entry of access) { + result.push(entry); + } + return Object.fromEntries(result); + } + visitIterable(access) { + var _a, _b; + if ((0, utils_1.isFunction)((_a = this.overrides) === null || _a === void 0 ? void 0 : _a.visitIterable)) { + return (_b = this.overrides) === null || _b === void 0 ? void 0 : _b.visitIterable(access); + } + const result = []; + for (const element of access) { + result.push(element); + } + return result; + } + }; + exports.Visitor = Visitor2; + } + }); + + // ../serde-ts/dist/de/index.js + var require_de = __commonJS({ + "../serde-ts/dist/de/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + __exportStar(require_forward(), exports); + __exportStar(require_generic(), exports); + __exportStar(require_impl2(), exports); + __exportStar(require_interface2(), exports); + } + }); + + // ../serde-ts/dist/index.js + var require_dist = __commonJS({ + "../serde-ts/dist/index.js"(exports) { + "use strict"; + var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { + return m[k]; + } }; + } + Object.defineProperty(o, k2, desc); + } : function(o, m, k, k2) { + if (k2 === void 0) k2 = k; + o[k2] = m[k]; + }); + var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); + } : function(o, v) { + o["default"] = v; + }); + var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function(o2) { + var ar = []; + for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function(mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) { + for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + } + __setModuleDefault(result, mod); + return result; + }; + }(); + var __exportStar = exports && exports.__exportStar || function(m, exports2) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p); + }; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.de = exports.ser = void 0; + exports.ser = __importStar(require_ser()); + exports.de = __importStar(require_de()); + __exportStar(require_registry(), exports); + __exportStar(require_utils(), exports); + } + }); + + // src/ser.ts + var import_serde = __toESM(require_dist(), 1); + var import_ser = __toESM(require_ser(), 1); + var JSONSerializeObject = class extends import_ser.SerializeObject { + stringify; + value = {}; + currentKey; + constructor(stringify2) { + super(); + this.stringify = stringify2; + } + serializeKey(key) { + this.currentKey = key; + } + serializeValue(value) { + this.value[this.currentKey] = value; + this.currentKey = void 0; + } + end() { + return this.stringify(this.value); + } + }; + var JSONSerializeIterable = class extends import_ser.SerializeIterable { + stringify; + elements = []; + constructor(stringify2) { + super(); + this.stringify = stringify2; + } + serializeElement(value) { + this.elements.push(value); + } + end() { + return this.stringify(this.elements); + } + }; + var id = (_ser, value) => value; + var serializer = (registry) => (_key, value) => { + const ser = (0, import_serde.getSerialize)(value, id, registry); + return ser(new import_ser.IdentitySerializer(), value); + }; + var stringify = (replacer) => (value) => JSON.stringify(value, replacer); + var JSONSerializer = class extends import_ser.Serializer { + stringify; + constructor(registry = import_serde.GlobalRegistry) { + super(); + this.stringify = stringify(serializer(registry)); + } + serializeAny(value) { + return this.stringify(value); + } + serializeBoolean(value) { + return JSON.stringify(value); + } + serializeNumber(value) { + return JSON.stringify(value); + } + serializeBigInt(value) { + return JSON.stringify(value); + } + serializeString(value) { + return JSON.stringify(value); + } + serializeSymbol(value) { + return JSON.stringify(value); + } + serializeNull() { + return JSON.stringify(null); + } + serializeIterable(_len) { + return new JSONSerializeIterable(this.stringify); + } + serializeObject(_len) { + return new JSONSerializeObject(this.stringify); + } + serializeClass(_name, _len) { + return new JSONSerializeObject(this.stringify); + } + }; + + // src/index.ts + var import_de2 = __toESM(require_de(), 1); + + // src/de.ts + var import_serde2 = __toESM(require_dist(), 1); + var import_de = __toESM(require_de(), 1); + var unwrap = (de) => de.deserializeAny(new import_de.Visitor()); + var deserializer = (registry = import_serde2.GlobalRegistry) => (_key, value) => { + const de = (0, import_serde2.getDeserialize)(value, unwrap, registry); + return de(new import_de.Forwarder(value)); + }; + var parser = (reviver) => (value) => { + return JSON.parse(value, reviver); + }; + var JSONMapAccess = class extends import_de.MapAccess { + _entries; + index = -1; + constructor(entries) { + super(); + this._entries = entries; + } + static fromObject(value) { + return new this(Object.entries(value)); + } + nextKey(seed) { + this.index += 1; + if (this.index >= this._entries.length) { + return import_serde2.IterResult.Done(); + } else { + const key = this._entries[this.index][0]; + const deser = seed != null ? seed(key) : key; + return import_serde2.IterResult.Next(deser); + } + } + nextValue(seed) { + if (this.index >= this._entries.length) { + return import_serde2.IterResult.Done(); + } else { + const value = this._entries[this.index][1]; + const deser = seed != null ? seed(value) : value; + return import_serde2.IterResult.Next(deser); + } + } + }; + var JSONIterableAccess = class extends import_de.IterableAccess { + iterator; + constructor(iterator) { + super(); + this.iterator = iterator; + } + static fromIterable(iterable) { + return new this(iterable[Symbol.iterator]()); + } + nextElement(seed) { + const result = this.iterator.next(); + if (result.done) { + return import_serde2.IterResult.Done(); + } else { + const value = seed != null ? seed(result.value) : result.value; + return import_serde2.IterResult.Next(value); + } + } + }; + var JSONDeserializer = class { + input; + parser; + constructor(input, registry = import_serde2.GlobalRegistry) { + this.input = input; + this.parser = parser(deserializer(registry)); + } + static fromString(value, registry) { + return new this(value, registry); + } + deserializeAny(_visitor) { + return this.parser(this.input); + } + deserializeBoolean(visitor) { + return visitor.visitBoolean(this.parser(this.input)); + } + deserializeNumber(visitor) { + return visitor.visitNumber(this.parser(this.input)); + } + deserializeBigInt(visitor) { + return visitor.visitBigInt(this.parser(this.input)); + } + deserializeString(visitor) { + return visitor.visitString(this.parser(this.input)); + } + deserializeSymbol(visitor) { + return visitor.visitSymbol(this.parser(this.input)); + } + deserializeNull(visitor) { + return visitor.visitNull(); + } + deserializeObject(visitor) { + const value = this.parser(this.input); + return visitor.visitObject(JSONMapAccess.fromObject(value)); + } + deserializeIterable(visitor) { + const value = this.parser(this.input); + return visitor.visitIterable(JSONIterableAccess.fromIterable(value)); + } + deserializeFunction(_visitor) { + throw new Error("Method not implemented"); + } + }; + + // src/index.ts + var import_ser3 = __toESM(require_ser(), 1); + function toString(value) { + const serializer2 = new JSONSerializer(); + return (0, import_ser3.serialize)(serializer2, value); + } + function fromString(value, into) { + const deserializer2 = JSONDeserializer.fromString(value); + return (0, import_de2.deserialize)(deserializer2, into); + } +})(); diff --git a/dist/test.js b/dist/test.js deleted file mode 100644 index a6eae4a..0000000 --- a/dist/test.js +++ /dev/null @@ -1,1101 +0,0 @@ -"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); diff --git a/package-lock.json b/package-lock.json index 68a7db6..a28f7f8 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,6 +9,7 @@ "version": "1.0.0", "license": "ISC", "dependencies": { + "kuebiko": "file:../kuebiko/", "serde": "file:../serde-ts" }, "devDependencies": { @@ -16,6 +17,19 @@ "typescript": "^5.8.3" } }, + "../kuebiko": { + "version": "1.0.0", + "license": "ISC", + "dependencies": { + "izuna": "git+https://git.kitsu.cafe/rowan/izuna.git", + "kojima": "git+https://git.kitsu.cafe/rowan/kojima.git" + }, + "devDependencies": { + "esbuild": "^0.25.2", + "folktest": "git+https://git.kitsu.cafe/rowan/folktest.git", + "typescript": "^5.8.3" + } + }, "../serde-ts": { "name": "serde", "version": "1.0.0", @@ -494,6 +508,10 @@ "@esbuild/win32-x64": "0.25.4" } }, + "node_modules/kuebiko": { + "resolved": "../kuebiko", + "link": true + }, "node_modules/serde": { "resolved": "../serde-ts", "link": true diff --git a/package.json b/package.json index 6aadd8b..4318795 100644 --- a/package.json +++ b/package.json @@ -3,6 +3,7 @@ "version": "1.0.0", "description": "", "main": "dist/index.js", + "type": "module", "scripts": { "build": "esbuild src/index.ts --bundle --outfile=dist/index.js", "build:test": "esbuild test.ts --format=cjs --bundle --target=es2022 --outfile=dist/test.js --tsconfig=tsconfig.json", @@ -11,7 +12,6 @@ "keywords": [], "author": "", "license": "ISC", - "type": "commonjs", "dependencies": { "serde": "file:../serde-ts" }, diff --git a/src/de.ts b/src/de.ts index 94b0b2f..ca0bf87 100644 --- a/src/de.ts +++ b/src/de.ts @@ -1,396 +1,135 @@ -import { GlobalRegistry, IterResult, Registry } from 'serde' -import { IIterableAccess, MapAccess, IVisitor, IDeserializer, Deserialize, GenericSeed, Visitor } from 'serde/de' -import { unexpected } from './err' +import { getDeserialize, GlobalRegistry, IterResult, Registry } from 'serde' +import { Deserialize, Forwarder, IDeserializer, IterableAccess, IVisitor, MapAccess, Visitor } from 'serde/de' -type Byte = number - -const clamp = (value: number, min: number, max: number): number => { - return Math.min(Math.max(value, min), max) +interface Reviver { + (key: string, value: T): U } -const isNumeric = (value: any): value is number => { - return !isNaN(value) +type Entry = [any, any] + +const unwrap = (de: IDeserializer) => de.deserializeAny(new Visitor()) +const deserializer = (registry: Registry = GlobalRegistry) => (_key: string, value: T) => { + const de = getDeserialize(value, unwrap, registry) + return de(new Forwarder(value)) as U } -const isNumericToken = (value: Byte) => { - return value === Token.Period || value === Token.Hyphen || Token.Digit.includes(value) +const parser = (reviver: Reviver) => (value: T): U => { + return JSON.parse(value as any, reviver) } -interface Predicate { - (value: T): boolean -} +export class JSONMapAccess extends MapAccess { + private readonly _entries: Entry[] + private index: number = -1 -const encoder = new TextEncoder() -const b = (strings: TemplateStringsArray) => encoder.encode(strings[0]) -const char = (strings: TemplateStringsArray) => b(strings)[0] - -const Literal = Object.freeze({ - True: b`true`, - False: b`false` -} as const) - -const 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`:` -} as const) - -export class CommaSeparated extends MapAccess implements IIterableAccess { - private readonly de: JSONDeserializer - private readonly defaultSeed: GenericSeed - private first: boolean = true - - constructor(deserializer: JSONDeserializer, visitor: IVisitor = new Visitor()) { + constructor(entries: Entry[]) { super() - this.de = deserializer - this.defaultSeed = new GenericSeed(visitor) + + this._entries = entries } - private seed(): Deserialize { - return this.defaultSeed.deserialize.bind(this.defaultSeed) as Deserialize + static fromObject(value: object) { + return new this(Object.entries(value)) } - private nextItemSeed>(seed: D, end: number): IteratorResult { - if (this.de.buffer.peek().next() === end) { + nextKey(seed?: Deserialize): IteratorResult { + this.index += 1 + + if (this.index >= this._entries.length) { return IterResult.Done() + } else { + const key = this._entries[this.index][0] + const deser = seed != null ? seed(key) : key + return IterResult.Next(deser) } + } - if (!this.first) { - const take = this.de.buffer.take() - if (take.next() !== Token.Comma) { - throw unexpected(',', take.toString(), this.de.buffer.position) - } + nextValue(seed?: Deserialize): IteratorResult { + if (this.index >= this._entries.length) { + return IterResult.Done() + } else { + const value = this._entries[this.index][1] + const deser = seed != null ? seed(value) : value + return IterResult.Next(deser) } - - this.first = false - return IterResult.Next(seed(this.de)) as IteratorResult - } - - nextKeySeed>(seed: K): IteratorResult { - return this.nextItemSeed(seed, Token.RightCurly) - } - - nextValueSeed>(seed: V): IteratorResult { - const next = this.de.buffer.next() - - if (next !== Token.Colon) { - throw unexpected(':', String.fromCharCode(next), this.de.buffer.position) - } - - return IterResult.Next(seed(this.de)) as IteratorResult - } - - private nextItem(end: number): IteratorResult { - return this.nextItemSeed(this.seed(), end) - } - - nextKey(): IteratorResult { - return this.nextItem(Token.RightCurly) - } - - nextValue(): IteratorResult { - return this.nextValueSeed(this.seed()) - } - - nextElement(): IteratorResult { - return this.nextItem(Token.RightSquare) } } -class ByteArray { - private readonly view: Uint8Array - private readonly encoder: TextEncoder - private readonly decoder: TextDecoder +export class JSONIterableAccess extends IterableAccess { + private readonly iterator: Iterator - private index: number = 0 - - get position() { - return this.index + constructor(iterator: Iterator) { + super() + this.iterator = iterator } - get length() { - return this.view.byteLength + static fromIterable(iterable: Iterable) { + return new this(iterable[Symbol.iterator]()) } - constructor(view: Uint8Array, encoder: TextEncoder = new TextEncoder(), decoder: TextDecoder = new TextDecoder()) { - this.view = view - this.encoder = encoder - this.decoder = decoder - } - - static fromArrayBuffer(value: ArrayBuffer, encoder?: TextEncoder, decoder?: TextDecoder): ByteArray { - return new this(new Uint8Array(value), encoder, decoder) - } - - static fromString(value: string, encoder: TextEncoder = new TextEncoder(), decoder?: TextDecoder): ByteArray { - return this.fromArrayBuffer( - encoder.encode(value), - encoder, - decoder - ) - } - - next() { - const value = this.view[this.index] - this.index += 1 - return value - } - - nextChar() { - return this.take().toString() - } - - done(): boolean { - return this.index >= this.view.byteLength - } - - toBytes() { - return this.view.slice(this.index) - } - - toString() { - return this.decoder.decode(this.toBytes()) - } - - take(limit: number = 1): ByteArray { - const bytes = this.peek(limit) - this.index += limit - return bytes - } - - at(index: number) { - return this.view[this.index + index] - } - - takeWhile(fn: Predicate): ByteArray { - let index = 0 - - while (!this.done() && fn(this.at(index))) { - index += 1 + nextElement>(seed?: D): IteratorResult { + const result = this.iterator.next() + if (result.done) { + return IterResult.Done() + } else { + const value = seed != null ? seed(result.value) : result.value + return IterResult.Next(value) } - - return this.take(index) - } - - takeUntil(fn: Predicate): ByteArray { - return this.takeWhile((v: number) => !fn(v)) - } - - drop(limit: number) { - this.index += limit - return this - } - - dropWhile(fn: Predicate): ByteArray { - let index = 0 - - while (!this.done() && fn(this.at(index))) { - index += 1 - } - - return this.drop(index) - } - - dropUntil(fn: Predicate): ByteArray { - return this.dropWhile((v: number) => !fn(v)) - } - - peek(limit: number = 1): ByteArray { - const index = this.index - return this.slice(index, index + limit) - } - - startsWith(value: string | ArrayBufferLike): boolean { - 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?: number, end?: number) { - return new ByteArray( - this.view.subarray(start, end), - this.encoder, - this.decoder - ) - } - - indexOf(value: number | ArrayBufferLike, start: number = 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 } } export class JSONDeserializer implements IDeserializer { - readonly buffer: ByteArray - readonly registry: Registry + private readonly input: string + private readonly parser: (value: T) => U - constructor(buffer: ByteArray, registry: Registry = GlobalRegistry) { - this.buffer = buffer - this.registry = registry + constructor(input: string, registry: Registry = GlobalRegistry) { + this.input = input + this.parser = parser(deserializer(registry)) } - static fromString(value: string): JSONDeserializer { - return new this(ByteArray.fromString(value)) + static fromString(value: string, registry?: Registry) { + return new this(value, registry) } - deserializeAny(visitor: IVisitor): T { - 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()}"`) - } + deserializeAny(_visitor: IVisitor): T { + return this.parser(this.input) } - deserializeNull>(visitor: V): T { - if (this.buffer.startsWith('null')) { - this.buffer.take(4) - } + deserializeBoolean(visitor: IVisitor): T { + return visitor.visitBoolean(this.parser(this.input)) + } + deserializeNumber(visitor: IVisitor): T { + return visitor.visitNumber(this.parser(this.input)) + } + + deserializeBigInt(visitor: IVisitor): T { + return visitor.visitBigInt(this.parser(this.input)) + } + + deserializeString(visitor: IVisitor): T { + return visitor.visitString(this.parser(this.input)) + } + + deserializeSymbol(visitor: IVisitor): T { + return visitor.visitSymbol(this.parser(this.input)) + } + + deserializeNull(visitor: IVisitor): T { return visitor.visitNull() } - deserializeObject>(visitor: V): T { - 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) - } + deserializeObject(visitor: IVisitor): T { + const value = this.parser(this.input) as object + return visitor.visitObject(JSONMapAccess.fromObject(value)) } - deserializeClass>(_name: string, visitor: V): T { - return this.deserializeObject(visitor) + deserializeIterable(visitor: IVisitor): T { + const value = this.parser(this.input) as Iterable + return visitor.visitIterable(JSONIterableAccess.fromIterable(value)) } - deserializeString>(visitor: V): T { - 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) - } + deserializeFunction(_visitor: IVisitor): T { + throw new Error('Method not implemented') } - - deserializeNumber>(visitor: V): T { - 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: V): T { - return this.deserializeNumber(visitor) - } - - deserializeBoolean>(visitor: V): T { - 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: V): T { - throw new Error('Method not implemented.') - } - - deserializeIterable>(visitor: V): T { - 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: V): T { - throw new Error('Method not implemented.') - } - } diff --git a/src/index.ts b/src/index.ts index 8f7e972..ca77546 100644 --- a/src/index.ts +++ b/src/index.ts @@ -5,8 +5,7 @@ import { serialize } from 'serde/ser' export function toString(value: any): string { const serializer = new JSONSerializer() - serialize(serializer, value) - return serializer.output + return serialize(serializer, value) } export function fromString(value: string, into: any): T { diff --git a/src/ser.ts b/src/ser.ts index 7429ff6..2e3a4e3 100644 --- a/src/ser.ts +++ b/src/ser.ts @@ -1,106 +1,79 @@ -import { ISerializeIterable, ISerializeObject, ISerializer, serialize, SerializeObject } from "serde/ser" +import { getSerialize, GlobalRegistry, Registry } from 'serde' +import { IdentitySerializer, ISerializer, serialize, SerializeIterable, SerializeObject, Serializer } from 'serde/ser' -class JSONObjectSerializer extends SerializeObject { - private ser: JSONSerializer - private first: boolean = true +interface Stringify { + (value: any): string +} - constructor(serializer: JSONSerializer) { +type Replacer = (key: PropertyKey, value: any) => any + +class JSONSerializeObject extends SerializeObject { + private readonly stringify: Stringify + private value: Record = {} + private currentKey?: string + + constructor(stringify: Stringify) { super() - this.ser = serializer - serializer.write('{') + this.stringify = stringify } - serializeKey(key: U): void { - if (!this.first) { - this.ser.write(',') - } else { - this.first = false - } - - serialize(this.ser, key) - this.ser.write(':') + serializeKey(key: string): void { + this.currentKey = key } serializeValue(value: U): void { - serialize(this.ser, value) + this.value[this.currentKey!] = value + this.currentKey = undefined } - end(): void { - this.ser.write('}') + end(): string { + return this.stringify(this.value) } } -class JSONIterableSerializer implements ISerializeIterable { - private ser: JSONSerializer - private first: boolean = true +class JSONSerializeIterable extends SerializeIterable { + private readonly stringify: Stringify + private elements: any[] = [] - constructor(serializer: JSONSerializer) { - this.ser = serializer - serializer.write('[') + constructor(stringify: Stringify) { + super() + this.stringify = stringify } - serializeElement(element: U): void { - if (!this.first) { - this.ser.write(',') - } else { - this.first = false - } - - serialize(this.ser, element) + serializeElement(value: U): void { + this.elements.push(value) } - end(): void { - this.ser.write(']') + end(): string { + return this.stringify(this.elements) } } -export class JSONSerializer implements ISerializer { - output: string = '' - - write(value: string) { - this.output += value - } - - serializeString(value: string) { - this.write(`"${value}"`) - } - - serializeBoolean(value: boolean): void { - this.write(value.toString()) - } - - serializeSymbol(value: symbol): void { - const key = Symbol.keyFor(value) - if (key) { - this.write(key) - } else { - return this.serializeString(value.toString()) - } - } - - serializeObject(): ISerializeObject { - return new JSONObjectSerializer(this) - } - - serializeClass(_name: PropertyKey): ISerializeObject { - return this.serializeObject() - } - - serializeNumber(value: number) { - this.write(value.toString()) - } - - serializeBigInt(value: bigint) { - this.write(value.toString()) - } - - serializeIterable(): ISerializeIterable { - return new JSONIterableSerializer(this) - } - - serializeNull() { - return this.write('null') - } +const id = (_ser: ISerializer, value: U) => value +const serializer = (registry: Registry) => (_key: PropertyKey, value: T) => { + const ser = getSerialize(value, id, registry) + return ser(new IdentitySerializer(), value) } +const stringify = (replacer: Replacer) => (value: any) => JSON.stringify(value, replacer) + +export class JSONSerializer extends Serializer { + private stringify: (value: any) => string + + constructor(registry: Registry = GlobalRegistry) { + super() + this.stringify = stringify(serializer(registry)) + } + + serializeAny(value: any) { return this.stringify(value) } + serializeBoolean(value: any) { return JSON.stringify(value) } + serializeNumber(value: any) { return JSON.stringify(value) } + serializeBigInt(value: any) { return JSON.stringify(value) } + serializeString(value: any) { return JSON.stringify(value) } + serializeSymbol(value: any) { return JSON.stringify(value) } + serializeNull() { return JSON.stringify(null) } + serializeIterable(_len: number) { return new JSONSerializeIterable(this.stringify) } + serializeObject(_len: number) { return new JSONSerializeObject(this.stringify) } + serializeClass(_name: string, _len: number) { return new JSONSerializeObject(this.stringify) } +}