1023 lines
35 KiB
JavaScript
1023 lines
35 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
|
|
));
|
|
|
|
// node_modules/serde/dist/ser/interface.js
|
|
var require_interface = __commonJS({
|
|
"node_modules/serde/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;
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/ser/identity.js
|
|
var require_identity = __commonJS({
|
|
"node_modules/serde/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;
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/utils.js
|
|
var require_utils = __commonJS({
|
|
"node_modules/serde/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];
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/registry.js
|
|
var require_registry = __commonJS({
|
|
"node_modules/serde/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;
|
|
}
|
|
}));
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/ser/impl.js
|
|
var require_impl = __commonJS({
|
|
"node_modules/serde/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);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/ser/index.js
|
|
var require_ser = __commonJS({
|
|
"node_modules/serde/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);
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/de/impl.js
|
|
var require_impl2 = __commonJS({
|
|
"node_modules/serde/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);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/de/interface.js
|
|
var require_interface2 = __commonJS({
|
|
"node_modules/serde/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);
|
|
}
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/de/forward.js
|
|
var require_forward = __commonJS({
|
|
"node_modules/serde/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;
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/de/generic.js
|
|
var require_generic = __commonJS({
|
|
"node_modules/serde/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;
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/de/index.js
|
|
var require_de = __commonJS({
|
|
"node_modules/serde/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);
|
|
}
|
|
});
|
|
|
|
// node_modules/serde/dist/index.js
|
|
var require_dist = __commonJS({
|
|
"node_modules/serde/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());
|
|
var import_ser = __toESM(require_ser());
|
|
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());
|
|
|
|
// src/de.ts
|
|
var import_serde2 = __toESM(require_dist());
|
|
var import_de = __toESM(require_de());
|
|
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());
|
|
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);
|
|
}
|
|
})();
|