1409 lines
52 KiB
JavaScript
1409 lines
52 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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
|
|
var __typeError = (msg) => {
|
|
throw TypeError(msg);
|
|
};
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
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
|
|
));
|
|
var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
|
|
var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
|
|
var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
|
|
var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
|
|
var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
|
|
var __runInitializers = (array, flags, self, value) => {
|
|
for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
|
|
return value;
|
|
};
|
|
var __decorateElement = (array, flags, name, decorators, target, extra) => {
|
|
var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
|
|
var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
|
|
var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
|
|
var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
|
|
return __privateGet(this, extra);
|
|
}, set [name](x) {
|
|
return __privateSet(this, extra, x);
|
|
} }, name));
|
|
k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
|
|
for (var i = decorators.length - 1; i >= 0; i--) {
|
|
ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
|
|
if (k) {
|
|
ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
|
|
if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
|
|
if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
|
|
}
|
|
it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
|
|
if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
|
|
else if (typeof it !== "object" || it === null) __typeError("Object expected");
|
|
else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
|
|
}
|
|
return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
|
|
};
|
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
|
|
var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
|
|
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
|
|
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
|
|
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
|
|
|
|
// ../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js
|
|
var require_lib = __commonJS({
|
|
"../serde-ts/node_modules/@tsmetadata/polyfill/lib/index.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
Symbol.metadata ??= Symbol("Symbol.metadata");
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/utils.js
|
|
var require_utils = __commonJS({
|
|
"../serde-ts/dist/utils.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.staticImplements = staticImplements;
|
|
exports2.isPlainObject = isPlainObject;
|
|
exports2.isFunction = isFunction;
|
|
exports2.isIterable = isIterable;
|
|
exports2.isString = isString;
|
|
exports2.isNumber = isNumber;
|
|
exports2.orElse = orElse;
|
|
exports2.ifNull = ifNull;
|
|
exports2.mixin = mixin2;
|
|
exports2.pipe = pipe;
|
|
function staticImplements() {
|
|
return (constructor) => {
|
|
constructor;
|
|
};
|
|
}
|
|
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);
|
|
}
|
|
function orElse(thisArg, a, b2) {
|
|
return function(...args) {
|
|
const fn = a != null ? a : b2;
|
|
return fn.apply(thisArg, args);
|
|
};
|
|
}
|
|
function ifNull(thisArg, b2, ...args) {
|
|
return function(a) {
|
|
return orElse(thisArg, a, b2).apply(thisArg, args);
|
|
};
|
|
}
|
|
function applyMixins(derivedCtor, constructors) {
|
|
constructors.forEach((baseCtor) => {
|
|
Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
|
|
Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || /* @__PURE__ */ Object.create(null));
|
|
});
|
|
});
|
|
}
|
|
function mixin2(impl) {
|
|
return function(constructor) {
|
|
applyMixins(constructor, [impl]);
|
|
return constructor;
|
|
};
|
|
}
|
|
function pipe(arg, firstFn, ...fns) {
|
|
return fns.reduce((acc, fn) => fn(acc), firstFn(arg));
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../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.isGenericSerializer = isGenericSerializer;
|
|
var utils_1 = require_utils();
|
|
var TypeSerializerMethods = [
|
|
"serializeString",
|
|
"serializeNumber",
|
|
"serializeBigInt",
|
|
"serializeBoolean",
|
|
"serializeSymbol",
|
|
//'serializeMap',
|
|
"serializeIterable",
|
|
"serializeNull",
|
|
"serializeObject",
|
|
"serializeClass"
|
|
];
|
|
var AnySerializerMethods = ["serializeAny"];
|
|
function isGenericSerializer(value) {
|
|
return AnySerializerMethods.every((k) => (0, utils_1.isFunction)(value[k])) && TypeSerializerMethods.every((k) => !(0, utils_1.isFunction)(value[k]));
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/case.js
|
|
var require_case = __commonJS({
|
|
"../serde-ts/dist/case.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.CaseConvention = void 0;
|
|
exports2.convertCase = convertCase;
|
|
exports2.CaseConvention = Object.freeze({
|
|
Lowercase: 0,
|
|
Uppercase: 1,
|
|
PascalCase: 2,
|
|
CamelCase: 3,
|
|
SnakeCase: 4,
|
|
ScreamingSnakeCase: 5,
|
|
KebabCase: 6,
|
|
ScreamingKebabCase: 7
|
|
});
|
|
var wordBoundaryRegex = /[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g;
|
|
function identifyWords(value) {
|
|
return value && value.match(wordBoundaryRegex);
|
|
}
|
|
var lower = (ch) => ch.toLowerCase();
|
|
var upper = (ch) => ch.toUpperCase();
|
|
var first = (xs) => xs && xs[0];
|
|
var tail = (xs) => xs && xs.slice(1);
|
|
function upperFirst(xs) {
|
|
return upper(first(xs)) + tail(xs);
|
|
}
|
|
function toPascalCase(words) {
|
|
return words.map(lower).map(upperFirst).join("");
|
|
}
|
|
var joinMap = (fn, delim, xs) => {
|
|
return xs.map(fn).join(delim);
|
|
};
|
|
function convertCase(value, convention) {
|
|
const words = identifyWords(value);
|
|
if (!words || words.length <= 0) {
|
|
return "";
|
|
}
|
|
switch (convention) {
|
|
case exports2.CaseConvention.Lowercase:
|
|
return words.join("").toLowerCase();
|
|
case exports2.CaseConvention.Uppercase:
|
|
return words.join("").toUpperCase();
|
|
case exports2.CaseConvention.PascalCase:
|
|
return toPascalCase(words);
|
|
case exports2.CaseConvention.CamelCase:
|
|
const pascal = toPascalCase(words);
|
|
return first(pascal).toLowerCase() + tail(pascal);
|
|
case exports2.CaseConvention.SnakeCase:
|
|
return joinMap(lower, "_", words);
|
|
case exports2.CaseConvention.ScreamingSnakeCase:
|
|
return joinMap(upper, "_", words);
|
|
case exports2.CaseConvention.KebabCase:
|
|
return joinMap(lower, "-", words);
|
|
case exports2.CaseConvention.ScreamingKebabCase:
|
|
return joinMap(upper, "-", words);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/registry.js
|
|
var require_registry = __commonJS({
|
|
"../serde-ts/dist/registry.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.GlobalRegistry = exports2.Registry = void 0;
|
|
var Registry = class {
|
|
constructor() {
|
|
Object.defineProperty(this, "registeredClasses", {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: /* @__PURE__ */ new Map()
|
|
});
|
|
}
|
|
add(ctor, key = ctor.name) {
|
|
this.registeredClasses.set(key, ctor);
|
|
}
|
|
get(name) {
|
|
return this.registeredClasses.get(name);
|
|
}
|
|
};
|
|
exports2.Registry = Registry;
|
|
exports2.GlobalRegistry = new Registry();
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/options.js
|
|
var require_options = __commonJS({
|
|
"../serde-ts/dist/options.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.SerdeOptions = exports2.Stage = void 0;
|
|
var case_1 = require_case();
|
|
var utils_1 = require_utils();
|
|
var registry_1 = require_registry();
|
|
exports2.Stage = Object.freeze({
|
|
Serialize: 0,
|
|
Deserialize: 1
|
|
});
|
|
var SerdeOptions = class {
|
|
get registry() {
|
|
return this.options.registry || registry_1.GlobalRegistry;
|
|
}
|
|
constructor(options = {}, properties = /* @__PURE__ */ new Map()) {
|
|
Object.defineProperty(this, "target", {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
Object.defineProperty(this, "options", {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
Object.defineProperty(this, "properties", {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: void 0
|
|
});
|
|
this.options = options;
|
|
this.properties = properties;
|
|
}
|
|
static from(target) {
|
|
return new this(target);
|
|
}
|
|
getClassName(stage) {
|
|
var _a, _b;
|
|
if ((0, utils_1.isString)(this.options.rename)) {
|
|
return this.options.rename;
|
|
} else if (stage === exports2.Stage.Serialize && (0, utils_1.isString)((_a = this.options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) {
|
|
return this.options.rename.serialize;
|
|
} else if (stage === exports2.Stage.Deserialize && (0, utils_1.isString)((_b = this.options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) {
|
|
return this.options.rename.deserialize;
|
|
} else {
|
|
return this.target.constructor.name;
|
|
}
|
|
}
|
|
getPropertyRename(property, stage, options) {
|
|
var _a, _b;
|
|
if (options != null) {
|
|
if ((0, utils_1.isString)(options.rename)) {
|
|
return options.rename;
|
|
} else if (stage === exports2.Stage.Serialize && (0, utils_1.isString)((_a = options.rename) === null || _a === void 0 ? void 0 : _a.serialize)) {
|
|
return options.rename.serialize;
|
|
} else if (stage === exports2.Stage.Deserialize && (0, utils_1.isString)((_b = options.rename) === null || _b === void 0 ? void 0 : _b.deserialize)) {
|
|
return options.rename.deserialize;
|
|
}
|
|
}
|
|
return property;
|
|
}
|
|
getPropertyCase(name, stage) {
|
|
var _a, _b;
|
|
if ((0, utils_1.isNumber)(this.options.renameAll)) {
|
|
return (0, case_1.convertCase)(name, this.options.renameAll);
|
|
} else if (stage === exports2.Stage.Serialize && (0, utils_1.isNumber)((_a = this.options.renameAll) === null || _a === void 0 ? void 0 : _a.serialize)) {
|
|
return (0, case_1.convertCase)(name, this.options.renameAll.serialize);
|
|
} else if (stage === exports2.Stage.Deserialize && (0, utils_1.isNumber)((_b = this.options.renameAll) === null || _b === void 0 ? void 0 : _b.deserialize)) {
|
|
return (0, case_1.convertCase)(name, this.options.renameAll.deserialize);
|
|
} else {
|
|
return name;
|
|
}
|
|
}
|
|
getPropertyName(property, stage) {
|
|
const options = this.properties.get(property);
|
|
const name = options != null ? this.getPropertyRename(property, stage, options) : property;
|
|
return this.getPropertyCase(name, stage);
|
|
}
|
|
getSerializationName(property) {
|
|
return this.getPropertyName(property, exports2.Stage.Serialize);
|
|
}
|
|
getDeserializationName(property) {
|
|
return this.getPropertyName(property, exports2.Stage.Deserialize);
|
|
}
|
|
getDefault(property) {
|
|
const options = this.properties.get(property);
|
|
if (options && (0, utils_1.isFunction)(options.default)) {
|
|
return options.default();
|
|
} else if ((0, utils_1.isFunction)(this.options.default)) {
|
|
return this.options.default();
|
|
}
|
|
}
|
|
//getCustomImpl(property: string, stage: Stage) {
|
|
// const options = this.properties.get(property)
|
|
// if (options != null) {
|
|
// if (stage === Stage.Serialize && isFunction(options.serializeWith)) {
|
|
// return options.serializeWith
|
|
// } else if (stage === Stage.Deserialize && isFunction(options.deserializeWith)) {
|
|
// return options.deserializeWith
|
|
// }
|
|
// }
|
|
//}
|
|
//getSerializer(property: string): Nullable<CustomSerializer> {
|
|
// return this.getCustomImpl(property, Stage.Serialize) as CustomSerializer
|
|
//}
|
|
//getDeserializer(property: string): Nullable<CustomDeserializer> {
|
|
// return this.getCustomImpl(property, Stage.Deserialize) as CustomDeserializer
|
|
//}
|
|
isConditionalSkip(skip) {
|
|
return "if" in skip && (0, utils_1.isFunction)(skip.if);
|
|
}
|
|
shouldSkip(property, value, stage) {
|
|
const options = this.properties.get(property);
|
|
if (options != null && options.skip != null) {
|
|
if (typeof options.skip === "boolean") {
|
|
return options.skip;
|
|
} else if (this.isConditionalSkip(options.skip)) {
|
|
return options.skip.if(value);
|
|
} else if (stage === exports2.Stage.Serialize && typeof options.skip.serializing === "boolean") {
|
|
return options.skip.serializing;
|
|
} else if (stage === exports2.Stage.Serialize && this.isConditionalSkip(options.skip.serializing)) {
|
|
return options.skip.serializing.if(value);
|
|
} else if (stage === exports2.Stage.Deserialize && typeof options.skip.deserializing === "boolean") {
|
|
return options.skip.deserializing;
|
|
} else if (stage === exports2.Stage.Deserialize && this.isConditionalSkip(options.skip.deserializing)) {
|
|
return options.skip.deserializing.if(value);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
shouldSkipSerializing(property, value) {
|
|
return this.shouldSkip(property, value, exports2.Stage.Serialize);
|
|
}
|
|
shouldSkipDeserializing(property, value) {
|
|
return this.shouldSkip(property, value, exports2.Stage.Deserialize);
|
|
}
|
|
};
|
|
exports2.SerdeOptions = SerdeOptions;
|
|
}
|
|
});
|
|
|
|
// ../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.serializeWith = serializeWith3;
|
|
var options_1 = require_options();
|
|
var utils_1 = require_utils();
|
|
var unhandledType = (serializer, value) => new TypeError(`'${serializer.constructor.name}' has no method for value type '${typeof value}'`);
|
|
function serializeEntries(serializer, value, options) {
|
|
var _a;
|
|
let state;
|
|
for (const [key, val] of value) {
|
|
if (options === null || options === void 0 ? void 0 : options.shouldSkipSerializing(key, val)) {
|
|
continue;
|
|
}
|
|
const name = (_a = options === null || options === void 0 ? void 0 : options.getPropertyName(key, options_1.Stage.Serialize)) !== null && _a !== void 0 ? _a : key;
|
|
state = serializer.serializeKey(name);
|
|
state = serializer.serializeValue(val);
|
|
}
|
|
return serializer.end();
|
|
}
|
|
function serializeClass(serializer, value, options) {
|
|
const ser2 = serializer.serializeClass(value.constructor.name);
|
|
return serializeEntries(ser2, Object.entries(value), options);
|
|
}
|
|
function serializeObject(serializer, value, options) {
|
|
const ser2 = serializer.serializeObject();
|
|
return serializeEntries(ser2, Object.entries(value), options);
|
|
}
|
|
function serializeIter(serializer, value, options) {
|
|
let state;
|
|
for (const val of value) {
|
|
state = serializer.serializeElement(val);
|
|
}
|
|
return serializer.end();
|
|
}
|
|
function defaultOptions(value) {
|
|
return value.constructor[Symbol.metadata].serde;
|
|
}
|
|
function serializeWith3(serializer, value, optionsGetter = defaultOptions) {
|
|
const serializeAny = (0, utils_1.orElse)(serializer, serializer.serializeAny, (value2) => unhandledType(serializer, value2));
|
|
const serialize2 = (0, utils_1.ifNull)(serializer, serializeAny, value);
|
|
switch (typeof value) {
|
|
case "string":
|
|
return serialize2(serializer.serializeString);
|
|
case "number":
|
|
return serialize2(serializer.serializeNumber);
|
|
case "bigint":
|
|
return serialize2(serializer.serializeBigInt);
|
|
case "boolean":
|
|
return serialize2(serializer.serializeBoolean);
|
|
case "symbol":
|
|
return serialize2(serializer.serializeSymbol);
|
|
case "undefined":
|
|
return serialize2(serializer.serializeNull);
|
|
case "object":
|
|
const options = optionsGetter(value);
|
|
if ((0, utils_1.isIterable)(value) && (0, utils_1.isFunction)(serializer.serializeIterable)) {
|
|
return serializeIter(serializer.serializeIterable(), value, options);
|
|
} else if (!(0, utils_1.isPlainObject)(value)) {
|
|
return serializeClass(serializer, value, options);
|
|
} else if ((0, utils_1.isFunction)(serializer.serializeObject)) {
|
|
return serializeObject(serializer, value, options);
|
|
}
|
|
// deliberate fallthrough when the above fail
|
|
default:
|
|
return serializeAny(value);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/ser/mixin.js
|
|
var require_mixin = __commonJS({
|
|
"../serde-ts/dist/ser/mixin.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.serialize = serialize2;
|
|
var impl_1 = require_impl();
|
|
var interface_1 = require_interface();
|
|
function serialize2(constructor) {
|
|
class Serializable2 extends constructor {
|
|
serialize(serializer) {
|
|
if ((0, interface_1.isGenericSerializer)(serializer)) {
|
|
return serializer.serializeAny(this);
|
|
} else {
|
|
return (0, impl_1.serializeWith)(serializer, this);
|
|
}
|
|
}
|
|
}
|
|
Object.defineProperty(Serializable2, "name", {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: constructor.name
|
|
});
|
|
return Serializable2;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../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 });
|
|
require_lib();
|
|
__exportStar(require_interface(), exports2);
|
|
__exportStar(require_mixin(), exports2);
|
|
__exportStar(require_impl(), exports2);
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/de/generic.js
|
|
var require_generic = __commonJS({
|
|
"../serde-ts/dist/de/generic.js"(exports2) {
|
|
"use strict";
|
|
var __esDecorate = exports2 && exports2.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
|
function accept(f) {
|
|
if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
|
|
return f;
|
|
}
|
|
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
|
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
|
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
|
var _, done = false;
|
|
for (var i = decorators.length - 1; i >= 0; i--) {
|
|
var context = {};
|
|
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
|
|
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
|
|
context.addInitializer = function(f) {
|
|
if (done) throw new TypeError("Cannot add initializers after decoration has completed");
|
|
extraInitializers.push(accept(f || null));
|
|
};
|
|
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
|
if (kind === "accessor") {
|
|
if (result === void 0) continue;
|
|
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
|
|
if (_ = accept(result.get)) descriptor.get = _;
|
|
if (_ = accept(result.set)) descriptor.set = _;
|
|
if (_ = accept(result.init)) initializers.unshift(_);
|
|
} else if (_ = accept(result)) {
|
|
if (kind === "field") initializers.unshift(_);
|
|
else descriptor[key] = _;
|
|
}
|
|
}
|
|
if (target) Object.defineProperty(target, contextIn.name, descriptor);
|
|
done = true;
|
|
};
|
|
var __runInitializers2 = exports2 && exports2.__runInitializers || function(thisArg, initializers, value) {
|
|
var useValue = arguments.length > 2;
|
|
for (var i = 0; i < initializers.length; i++) {
|
|
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
|
}
|
|
return useValue ? value : void 0;
|
|
};
|
|
var __setFunctionName = exports2 && exports2.__setFunctionName || function(f, name, prefix) {
|
|
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
|
|
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.GenericVisitor = exports2.GenericSeed = void 0;
|
|
var utils_1 = require_utils();
|
|
var GenericSeed = (() => {
|
|
let _classDecorators = [(0, utils_1.staticImplements)()];
|
|
let _classDescriptor;
|
|
let _classExtraInitializers = [];
|
|
let _classThis;
|
|
var GenericSeed2 = _classThis = class {
|
|
static deserialize(deserializer) {
|
|
return deserializer.deserializeAny(new GenericVisitor2());
|
|
}
|
|
deserialize(deserializer) {
|
|
return GenericSeed2.deserialize(deserializer);
|
|
}
|
|
};
|
|
__setFunctionName(_classThis, "GenericSeed");
|
|
(() => {
|
|
const _metadata = typeof Symbol === "function" && Symbol.metadata ? /* @__PURE__ */ Object.create(null) : void 0;
|
|
__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
|
|
GenericSeed2 = _classThis = _classDescriptor.value;
|
|
if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
|
|
__runInitializers2(_classThis, _classExtraInitializers);
|
|
})();
|
|
return GenericSeed2 = _classThis;
|
|
})();
|
|
exports2.GenericSeed = GenericSeed;
|
|
var GenericVisitor2 = class {
|
|
visitString(value) {
|
|
return value;
|
|
}
|
|
visitNumber(value) {
|
|
return value;
|
|
}
|
|
visitBigInt(value) {
|
|
return value;
|
|
}
|
|
visitBoolean(value) {
|
|
return value;
|
|
}
|
|
visitSymbol(value) {
|
|
return value;
|
|
}
|
|
visitNull() {
|
|
return null;
|
|
}
|
|
visitObject(access) {
|
|
const result = {};
|
|
let entry;
|
|
while (entry = access.nextEntry()) {
|
|
result[entry[0]] = entry[1];
|
|
}
|
|
return result;
|
|
}
|
|
visitClass(name, value) {
|
|
console.log(name, "!!!!!!");
|
|
return this.visitObject(value);
|
|
}
|
|
visitIterable(access) {
|
|
const result = new Array(access.sizeHint());
|
|
let element;
|
|
while (element = access.nextElement()) {
|
|
result.push(element);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
exports2.GenericVisitor = GenericVisitor2;
|
|
}
|
|
});
|
|
|
|
// ../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.DefaultIterableAccessImpl = exports2.DefaultMapAccessImpl = void 0;
|
|
var generic_1 = require_generic();
|
|
var DefaultMapAccessImpl2 = class {
|
|
nextEntrySeed(kseed, vseed) {
|
|
const key = this.nextKeySeed(kseed);
|
|
if (key !== void 0) {
|
|
const value = this.nextValueSeed(vseed);
|
|
if (value !== void 0) {
|
|
return [key, value];
|
|
}
|
|
}
|
|
}
|
|
nextKey() {
|
|
return this.nextValueSeed(generic_1.GenericSeed);
|
|
}
|
|
nextValue() {
|
|
return this.nextValueSeed(generic_1.GenericSeed);
|
|
}
|
|
nextEntry() {
|
|
return this.nextEntrySeed(generic_1.GenericSeed, generic_1.GenericSeed);
|
|
}
|
|
};
|
|
exports2.DefaultMapAccessImpl = DefaultMapAccessImpl2;
|
|
var DefaultIterableAccessImpl2 = class {
|
|
nextElement() {
|
|
return this.nextElementSeed(generic_1.GenericSeed);
|
|
}
|
|
sizeHint() {
|
|
return 0;
|
|
}
|
|
};
|
|
exports2.DefaultIterableAccessImpl = DefaultIterableAccessImpl2;
|
|
}
|
|
});
|
|
|
|
// ../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.deserializeWith = deserializeWith;
|
|
var options_1 = require_options();
|
|
var generic_1 = require_generic();
|
|
function deserializeWith(deserializer, into, options) {
|
|
const visitor = new generic_1.GenericVisitor();
|
|
const target = new into();
|
|
const obj = deserializer.deserializeClass(into.name, visitor);
|
|
const newObject = {};
|
|
for (const property in target) {
|
|
const name = options.getPropertyName(property, options_1.Stage.Deserialize);
|
|
const value = obj[name] || options.getDefault(property);
|
|
newObject[property] = value;
|
|
delete obj[name];
|
|
}
|
|
if (options.options.denyUnknownFields && Object.keys(obj).length > 0) {
|
|
throw new TypeError(`Unexpected fields: ${Object.keys(obj).join(", ")}`);
|
|
}
|
|
return Object.assign(target, newObject);
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/de/mixin.js
|
|
var require_mixin2 = __commonJS({
|
|
"../serde-ts/dist/de/mixin.js"(exports2) {
|
|
"use strict";
|
|
var __esDecorate = exports2 && exports2.__esDecorate || function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
|
function accept(f) {
|
|
if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
|
|
return f;
|
|
}
|
|
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
|
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
|
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
|
var _, done = false;
|
|
for (var i = decorators.length - 1; i >= 0; i--) {
|
|
var context = {};
|
|
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
|
|
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
|
|
context.addInitializer = function(f) {
|
|
if (done) throw new TypeError("Cannot add initializers after decoration has completed");
|
|
extraInitializers.push(accept(f || null));
|
|
};
|
|
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
|
if (kind === "accessor") {
|
|
if (result === void 0) continue;
|
|
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
|
|
if (_ = accept(result.get)) descriptor.get = _;
|
|
if (_ = accept(result.set)) descriptor.set = _;
|
|
if (_ = accept(result.init)) initializers.unshift(_);
|
|
} else if (_ = accept(result)) {
|
|
if (kind === "field") initializers.unshift(_);
|
|
else descriptor[key] = _;
|
|
}
|
|
}
|
|
if (target) Object.defineProperty(target, contextIn.name, descriptor);
|
|
done = true;
|
|
};
|
|
var __runInitializers2 = exports2 && exports2.__runInitializers || function(thisArg, initializers, value) {
|
|
var useValue = arguments.length > 2;
|
|
for (var i = 0; i < initializers.length; i++) {
|
|
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
|
}
|
|
return useValue ? value : void 0;
|
|
};
|
|
var __setFunctionName = exports2 && exports2.__setFunctionName || function(f, name, prefix) {
|
|
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
|
|
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
|
|
};
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.deserialize = deserialize2;
|
|
var utils_1 = require_utils();
|
|
var impl_1 = require_impl2();
|
|
function deserialize2(constructor) {
|
|
let Deserializable = (() => {
|
|
let _classDecorators = [(0, utils_1.staticImplements)()];
|
|
let _classDescriptor;
|
|
let _classExtraInitializers = [];
|
|
let _classThis;
|
|
let _classSuper = constructor;
|
|
var Deserializable2 = _classThis = class extends _classSuper {
|
|
static deserialize(deserializer) {
|
|
return (0, impl_1.deserializeWith)(deserializer, this, this[Symbol.metadata].serde);
|
|
}
|
|
};
|
|
__setFunctionName(_classThis, "Deserializable");
|
|
(() => {
|
|
var _a;
|
|
const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
|
|
__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
|
|
Deserializable2 = _classThis = _classDescriptor.value;
|
|
if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
|
|
})();
|
|
Object.defineProperty(_classThis, "name", {
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true,
|
|
value: constructor.name
|
|
});
|
|
(() => {
|
|
__runInitializers2(_classThis, _classExtraInitializers);
|
|
})();
|
|
return Deserializable2 = _classThis;
|
|
})();
|
|
return Deserializable;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../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_interface2(), exports2);
|
|
__exportStar(require_generic(), exports2);
|
|
__exportStar(require_mixin2(), exports2);
|
|
}
|
|
});
|
|
|
|
// ../serde-ts/dist/decorator.js
|
|
var require_decorator = __commonJS({
|
|
"../serde-ts/dist/decorator.js"(exports2) {
|
|
"use strict";
|
|
Object.defineProperty(exports2, "__esModule", { value: true });
|
|
exports2.serde = serde2;
|
|
exports2.register = register2;
|
|
var options_1 = require_options();
|
|
var registry_1 = require_registry();
|
|
function decorateContainer(target, context, options) {
|
|
const meta = context.metadata;
|
|
const serde3 = meta.serde || new options_1.SerdeOptions(target);
|
|
serde3.target = target;
|
|
serde3.options = options;
|
|
meta.serde = serde3;
|
|
}
|
|
function decorateProperty(target, context, options) {
|
|
const meta = context.metadata;
|
|
const serde3 = meta.serde || new options_1.SerdeOptions(target);
|
|
serde3.properties.set(context.name, options);
|
|
meta.serde = serde3;
|
|
}
|
|
function serde2(options) {
|
|
return function(target, context) {
|
|
if (target == null) {
|
|
decorateProperty(target, context, options);
|
|
} else
|
|
decorateContainer(target, context, options);
|
|
};
|
|
}
|
|
function register2(registry = registry_1.GlobalRegistry) {
|
|
return function(target, _context) {
|
|
registry.add(target);
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../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_case(), exports2);
|
|
__exportStar(require_registry(), exports2);
|
|
__exportStar(require_decorator(), exports2);
|
|
__exportStar(require_options(), exports2);
|
|
}
|
|
});
|
|
|
|
// test.ts
|
|
var import_serde = __toESM(require_dist());
|
|
var import_de3 = __toESM(require_de());
|
|
var import_ser4 = __toESM(require_ser());
|
|
|
|
// src/index.ts
|
|
var import_ser2 = __toESM(require_ser());
|
|
|
|
// src/ser.ts
|
|
var import_ser = __toESM(require_ser());
|
|
var JSONObjectSerializer = class {
|
|
ser;
|
|
first = true;
|
|
constructor(serializer) {
|
|
this.ser = serializer;
|
|
serializer.write("{");
|
|
}
|
|
serializeKey(key) {
|
|
if (!this.first) {
|
|
this.ser.write(",");
|
|
} else {
|
|
this.first = false;
|
|
}
|
|
(0, import_ser.serializeWith)(this.ser, key);
|
|
this.ser.write(":");
|
|
}
|
|
serializeValue(value) {
|
|
(0, import_ser.serializeWith)(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.serializeWith)(this.ser, element);
|
|
}
|
|
end() {
|
|
this.ser.write("]");
|
|
}
|
|
};
|
|
var JSONClassSerializer = class {
|
|
outer;
|
|
inner;
|
|
constructor(serializer, name) {
|
|
this.outer = new JSONObjectSerializer(serializer);
|
|
this.outer.serializeKey("type");
|
|
this.outer.serializeValue(name);
|
|
this.outer.serializeKey("object");
|
|
this.inner = new JSONObjectSerializer(serializer);
|
|
}
|
|
serializeKey(key) {
|
|
return this.inner.serializeKey(key);
|
|
}
|
|
serializeValue(value) {
|
|
return this.inner.serializeValue(value);
|
|
}
|
|
end() {
|
|
this.inner.end();
|
|
this.outer.end();
|
|
}
|
|
};
|
|
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 new JSONClassSerializer(this, name);
|
|
}
|
|
serializeNumber(value) {
|
|
this.write(value.toString());
|
|
}
|
|
serializeBigInt(value) {
|
|
this.write(value.toString());
|
|
}
|
|
serializeIterable() {
|
|
return new JSONIterableSerializer(this);
|
|
}
|
|
serializeNull() {
|
|
return this.write("null");
|
|
}
|
|
};
|
|
|
|
// src/de.ts
|
|
var import_de = __toESM(require_de());
|
|
var import_utils = __toESM(require_utils());
|
|
|
|
// 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_decorators, _init;
|
|
_CommaSeparated_decorators = [(0, import_utils.mixin)(import_de.DefaultMapAccessImpl), (0, import_utils.mixin)(import_de.DefaultIterableAccessImpl)];
|
|
var CommaSeparated = class {
|
|
de;
|
|
first = true;
|
|
constructor(deserializer) {
|
|
this.de = deserializer;
|
|
}
|
|
nextKeySeed(seed) {
|
|
if (this.de.buffer.peek().next() === Token.RightCurly) {
|
|
return;
|
|
}
|
|
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 seed.deserialize(this.de);
|
|
}
|
|
nextValueSeed(seed) {
|
|
const next = this.de.buffer.next();
|
|
if (next !== Token.Colon) {
|
|
throw unexpected(":", next.toString(), this.de.buffer.position);
|
|
}
|
|
return seed.deserialize(this.de);
|
|
}
|
|
nextElementSeed(seed) {
|
|
if (this.de.buffer.peek().next() === Token.RightSquare) {
|
|
return;
|
|
}
|
|
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 seed.deserialize(this.de);
|
|
}
|
|
};
|
|
_init = __decoratorStart(null);
|
|
CommaSeparated = __decorateElement(_init, 0, "CommaSeparated", _CommaSeparated_decorators, CommaSeparated);
|
|
__runInitializers(_init, 1, CommaSeparated);
|
|
var StringBuffer = class _StringBuffer {
|
|
view;
|
|
index = 0;
|
|
encoder;
|
|
decoder;
|
|
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 _StringBuffer(
|
|
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;
|
|
constructor(buffer) {
|
|
this.buffer = buffer;
|
|
}
|
|
static fromString(value) {
|
|
return new this(StringBuffer.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(fn) {
|
|
let next = this.buffer.take();
|
|
if (next.next() === Token.LeftCurly) {
|
|
const value = fn(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) {
|
|
return this._deserializeObject(visitor.visitObject.bind(visitor));
|
|
}
|
|
deserializeClass(name, visitor) {
|
|
if (this.buffer.peek(9).startsWith('{"type":"')) {
|
|
const name2 = this.buffer.drop(9).takeUntil((v) => v === Token.Quote);
|
|
if (this.buffer.startsWith('","object":')) {
|
|
this.buffer.drop(11);
|
|
return this._deserializeObject(visitor.visitClass.bind(visitor, name2.toString()));
|
|
} else {
|
|
throw unexpected('"object" property', this.buffer.toString(), this.buffer.position);
|
|
}
|
|
} else {
|
|
throw unexpected('"type" property', this.buffer.toString(), this.buffer.position);
|
|
}
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/index.ts
|
|
function toString(value) {
|
|
const serializer = new JSONSerializer();
|
|
(0, import_ser2.serializeWith)(serializer, value);
|
|
return serializer.output;
|
|
}
|
|
function fromString(value, into) {
|
|
const deserializer = JSONDeserializer.fromString(value);
|
|
return into.deserialize(deserializer);
|
|
}
|
|
|
|
// test.ts
|
|
var _metadata_dec, _InnerStruct_decorators, _init2;
|
|
_InnerStruct_decorators = [import_ser4.serialize, import_de3.deserialize, (0, import_serde.register)(), (0, import_serde.serde)({ renameAll: import_serde.CaseConvention.PascalCase })], _metadata_dec = [(0, import_serde.serde)({ skip: true })];
|
|
var InnerStruct = class {
|
|
constructor(v) {
|
|
__publicField(this, "value");
|
|
__publicField(this, "metadata", __runInitializers(_init2, 8, this)), __runInitializers(_init2, 11, this);
|
|
this.value = v;
|
|
}
|
|
};
|
|
_init2 = __decoratorStart(null);
|
|
__decorateElement(_init2, 5, "metadata", _metadata_dec, InnerStruct);
|
|
InnerStruct = __decorateElement(_init2, 0, "InnerStruct", _InnerStruct_decorators, InnerStruct);
|
|
__runInitializers(_init2, 1, InnerStruct);
|
|
var _aBoolean_dec, _TestStruct_decorators, _init3;
|
|
_TestStruct_decorators = [import_ser4.serialize, import_de3.deserialize, (0, import_serde.register)(), (0, import_serde.serde)({ renameAll: import_serde.CaseConvention.SnakeCase })], _aBoolean_dec = [(0, import_serde.serde)({ skip: { serializing: { if: (v) => v } } })];
|
|
var TestStruct = class {
|
|
constructor(str) {
|
|
__publicField(this, "aNumber", 69);
|
|
__publicField(this, "aString");
|
|
__publicField(this, "aBoolean", __runInitializers(_init3, 8, this, false)), __runInitializers(_init3, 11, this);
|
|
__publicField(this, "innerStruct");
|
|
this.innerStruct = new InnerStruct(str);
|
|
}
|
|
};
|
|
_init3 = __decoratorStart(null);
|
|
__decorateElement(_init3, 5, "aBoolean", _aBoolean_dec, TestStruct);
|
|
TestStruct = __decorateElement(_init3, 0, "TestStruct", _TestStruct_decorators, TestStruct);
|
|
__runInitializers(_init3, 1, TestStruct);
|
|
var test = new TestStruct("hi :3");
|
|
console.log(test.constructor.name);
|
|
var ser = toString(test);
|
|
console.log(ser);
|
|
var de = fromString(ser, TestStruct);
|
|
console.log(de);
|