1101 lines
34 KiB
JavaScript
1101 lines
34 KiB
JavaScript
"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);
|