@lsmsgpack/client 0.0.0-stage → 2026.10.2201

package/dist/decoder.js

@@ -0,0 +1,720 @@
+// Reads application/x-lsmsgpack payloads (the schema, or a reference to it, followed by the body) into complete objects:
+// every property of the schema entry is set, the ones the writer left out (nil, or missing) get their default.
+// An object that came with a type id gets its type name as the property $type (as System.Text.Json names it): the encoder writes it back as the type id.
+import { MissingSchemaError, MsgPackError } from './errors.js';
+import { MsgPackExtension, MsgPackReader } from './reader.js';
+import { nameFunction } from './names.js';
+import { AnyType, Schema } from './schema.js';
+import { toHex } from './sha256.js';
+import { convertDecimal, dateOnlyText, decodeDecimal, EmptyGuid, guidString, MinDateTimeMs, offsetText, timeOnlyText, timeSpanText } from './values.js';
+let codeAllowed = true; // false once new Function failed (Content-Security-Policy without 'unsafe-eval')
+/** The property that holds the type name of an object read with a type id, and that the encoder writes as the type id. */
+export const TypeProperty = '$type';
+/**
+ * The generated create and fill of a plan (see DecodeOptions.generateCode), undefined when code cannot be generated. Instances of classes only get the fill (create is new).
+ * The fill has the read functions of the properties as constants: each call site then always calls the same function (reads[t](r) was one call site for all of them).
+ */
+function generate(names, reads, literals) {
+    if (!codeAllowed || names.length === 0 || names.length > 512 || names.includes('__proto__') || names.includes(TypeProperty))
+        return undefined; // an object literal would set the prototype, or have $type twice
+    const literal = names.map((n, t) => `${JSON.stringify(n)}: v[${t}]`).join(', ');
+    let fill = `const ${names.map((_, t) => `read${t} = reads[${t}]`).join(', ')};\nreturn function fill(r, o, n) {\nconst b = r.bytes;\n`;
+    names.forEach((n, t) => {
+        fill += `if (n === ${t}) return;\nif (b[r.pos] === 0xc0) r.pos++; else o[${JSON.stringify(n)}] = read${t}(r);\n`;
+    });
+    fill += `for (let k = ${names.length}; k < n; k++) r.value();\n};`;
+    try {
+        const fillFn = new Function('reads', fill)(reads);
+        if (!literals)
+            return { fill: fillFn };
+        return {
+            create: new Function('v', `return { ${literal} };`),
+            createTyped: new Function('v', 't', `return { ${JSON.stringify(TypeProperty)}: t, ${literal} };`), // $type first, as System.Text.Json writes it
+            fill: fillFn,
+        };
+    }
+    catch {
+        codeAllowed = false;
+        return undefined;
+    }
+}
+/**
+ * Generates the reading of an object of the array layout: the values into variables first (the defaults where the data left them out), then the object at once,
+ * so its properties are written once (a literal, or for a model a constructor function with the class's prototype: new of the class would make its initial values
+ * only to have them replaced). The defaults that are made per object (makers, null until then) are made after the values, as Plan.complete does.
+ * @param order the properties in the order the object gets them: an index of names, or an Extra
+ * @param proto the prototype of the model's class, undefined for a plain object
+ */
+function generateReadArray(names, reads, defaults, makers, order, proto) {
+    const count = names.length;
+    if (!codeAllowed || count === 0 || count > 512 || names.includes('__proto__') || names.includes(TypeProperty) || order.some((p) => typeof p !== 'number' && p.name === '__proto__'))
+        return undefined;
+    const v = names.map((_, t) => `v${t}`);
+    let code = `const ${names.map((_, t) => `read${t} = reads[${t}], d${t} = defaults[${t}], m${t} = makers[${t}]`).join(', ')};\n`;
+    let result;
+    if (proto === undefined)
+        result = `{ ${order.map((p) => `${JSON.stringify(names[p])}: v${p}`).join(', ')} }`;
+    else {
+        code += `const extras = order.filter((p) => typeof p !== 'number');\n`;
+        let extra = 0;
+        code += `function Model(${v.join(', ')}) {\n${order.map((p) => typeof p === 'number'
+            ? `this[${JSON.stringify(names[p])}] = v${p};\n`
+            : `this[${JSON.stringify(p.name)}] = ${p.make === undefined ? `extras[${extra++}].value` : `extras[${extra++}].make()`};\n`).join('')}}\nModel.prototype = proto;\n`;
+        result = `new Model(${v.join(', ')})`;
+    }
+    code += `return function readArray(r, n) {\nconst b = r.bytes;\nlet ${names.map((_, t) => `v${t} = d${t}`).join(', ')};\nvalues: {\n`;
+    names.forEach((_, t) => {
+        code += `if (n === ${t}) break values;\nif (b[r.pos] === 0xc0) r.pos++; else v${t} = read${t}(r);\n`;
+    });
+    code += `for (let k = ${count}; k < n; k++) r.value();\n}\n`;
+    makers.forEach((m, t) => {
+        if (m !== undefined)
+            code += `if (v${t} === null) v${t} = m${t}();\n`;
+    });
+    code += `return ${result};\n};`;
+    try {
+        return new Function('reads', 'defaults', 'makers', 'order', 'proto', code)(reads, defaults, makers, order, proto);
+    }
+    catch {
+        codeAllowed = false;
+        return undefined;
+    }
+}
+/** The initial value of a field of a model's class (probe: an instance), and how to make it for each object when it is not a primitive. */
+function initialOf(cls, probe, name) {
+    const value = probe[name];
+    if (value === null || (typeof value !== 'object' && typeof value !== 'function'))
+        return { value };
+    if (value instanceof Date) {
+        const time = value.getTime();
+        return { value: null, make: () => new Date(time) };
+    }
+    if (Array.isArray(value) && value.length === 0 && Object.getPrototypeOf(value) === Array.prototype)
+        return { value: null, make: () => [] };
+    return { value: null, make: () => new cls()[name] }; // e.g. a nested object: as the class makes it
+}
+/** Sets a property, also one named __proto__ (as JSON.parse does: an own property, not the prototype). */
+export function setOwn(o, name, value) {
+    if (name === '__proto__')
+        Object.defineProperty(o, name, { value, writable: true, enumerable: true, configurable: true });
+    else
+        o[name] = value;
+}
+/** How to read the values of one schema entry. */
+class Plan {
+    /** Makes what create and fill use, once the properties are known: the template, and with generateCode their code. */
+    prepare(generateCode) {
+        if (this.cls === undefined) {
+            const o = {};
+            for (let t = 0; t < this.names.length; t++)
+                setOwn(o, this.names[t], this.values[t]);
+            this.template = o;
+        }
+        if (!generateCode)
+            return;
+        const code = generate(this.names, this.reads, this.cls === undefined);
+        this.createFn = code?.create;
+        this.createTypedFn = code?.createTyped;
+        this.fillFn = code?.fill;
+        this.readArrayFn = this.generateReadArray();
+    }
+    /** readArrayFn for plain objects and the models (not for DecodeOptions.classes: their constructors may do more than set fields). */
+    generateReadArray() {
+        const names = this.names;
+        if (this.cls === undefined)
+            return generateReadArray(names, this.reads, this.values, this.makers, names.map((_, t) => t), undefined);
+        if (!this.model)
+            return undefined;
+        // The generated classes only initialize their fields: the same fields with the same values in the same order, without new of the class.
+        const cls = this.cls, probe = new cls();
+        const defaults = this.values.slice(), makers = this.makers.slice(), order = [];
+        for (const name of Object.keys(probe)) {
+            const t = this.indexOf(name), initial = initialOf(cls, probe, name);
+            if (t < 0)
+                order.push({ name, ...initial });
+            else {
+                order.push(t);
+                defaults[t] = initial.value;
+                makers[t] = initial.make;
+            }
+        }
+        for (let t = 0; t < this.missing.length; t++)
+            order.push(this.missing[t]); // after the class's fields, as create sets them
+        return generateReadArray(names, this.reads, defaults, makers, order, cls.prototype);
+    }
+    /**
+     * @param names the names of the properties in JavaScript (DecodeOptions.propertyNames)
+     * @param cls the class of the entry (a model, or one of DecodeOptions.classes)
+     * @param model the class is a model: it has $type on its prototype
+     */
+    constructor(entry, names, cls, model = false) {
+        this.entry = entry;
+        this.cls = cls;
+        this.model = model;
+        /** The properties the class does not initialize (they get the defaults of the schema: e.g. a property the server has and the models do not have yet). */
+        this.missing = [];
+        const count = entry.properties.length;
+        this.names = names;
+        this.reads = new Array(count);
+        this.values = new Array(count);
+        this.makers = new Array(count);
+        this.isObject = entry.content === undefined;
+        if (cls !== undefined) {
+            const probe = new cls(); // the same fields for every instance
+            for (let t = 0; t < count; t++)
+                if (probe[this.names[t]] === undefined)
+                    this.missing.push(t);
+        }
+    }
+    /** A new object with every property at its default (null for the ones that are made, see complete), in the order of the schema. */
+    create() {
+        const names = this.names, values = this.values;
+        if (this.createFn !== undefined)
+            return this.createFn(values, null);
+        if (this.template !== undefined)
+            return { ...this.template }; // own properties, also one named __proto__
+        const o = new this.cls(); // new rather than a copy of one instance: the initial values (Date, arrays, nested objects) are not shared
+        const missing = this.missing;
+        for (let t = 0; t < missing.length; t++)
+            setOwn(o, names[missing[t]], values[missing[t]]);
+        return o;
+    }
+    /** create for an object that came with a type id: with its type name in $type (the first property; on instances of your classes after their own). */
+    createTyped() {
+        const typeName = this.entry.name;
+        if (typeName === null)
+            return this.create(); // the root entry of a described schema (type ids never refer to it) or a nameless entry
+        if (this.createTypedFn !== undefined)
+            return this.createTypedFn(this.values, typeName);
+        if (this.template !== undefined)
+            return { [TypeProperty]: typeName, ...this.template };
+        const o = this.create();
+        if (!this.model)
+            o[TypeProperty] = typeName; // a model has it on its prototype
+        return o;
+    }
+    /** Makes the defaults the data did not replace (a Date or struct is never null, so null means not read). */
+    complete(o) {
+        const made = this.made;
+        if (made === undefined)
+            return o;
+        for (let t = 0; t < made.length; t++) {
+            const name = this.names[made[t]];
+            if (o[name] === null)
+                o[name] = this.makers[made[t]]();
+        }
+        return o;
+    }
+    /** A new object with every default made (e.g. the default of a struct). */
+    createComplete() {
+        return this.complete(this.create());
+    }
+    indexOf(name) {
+        if (this._byName === undefined) {
+            this._byName = new Map();
+            for (let t = this.names.length - 1; t >= 0; t--)
+                this._byName.set(this.names[t], t);
+        }
+        return this._byName.get(name) ?? -1;
+    }
+    /** The index of a property by the name the writer gave it (a key of ObjectLayout.Map without the schema): the .NET name. */
+    indexOfWriterName(name) {
+        const properties = this.entry.properties;
+        if (this._byWriterName === undefined) {
+            this._byWriterName = new Map();
+            for (let t = properties.length - 1; t >= 0; t--)
+                this._byWriterName.set(properties[t].name, t);
+        }
+        return this._byWriterName.get(name) ?? -1;
+    }
+}
+/** The plans of one schema for one set of options, made when first used. */
+class Plans {
+    constructor(schema, options) {
+        this.schema = schema;
+        this.options = options;
+        this.inline = new Map();
+        this.field = nameFunction(options.propertyNames);
+        this.keyName = this.field('Key');
+        this.valueName = this.field('Value');
+        this.plans = new Array(schema.entries.length);
+        this.root = schema.root === undefined ? readDynamic : this.compile(schema.root);
+    }
+    plan(index) {
+        const plan = this.plans[index];
+        if (plan !== undefined)
+            return plan;
+        if (!Number.isInteger(index) || index < 0 || index >= this.plans.length)
+            throw new MsgPackError(`The type id ${index} is not an entry of the schema (${this.plans.length} entries).`);
+        return this.build(index);
+    }
+    /** The plan of an entry by index, or of a struct described inline. */
+    planOf(entry) {
+        if (typeof entry === 'number')
+            return this.plan(entry);
+        const plan = this.inline.get(entry);
+        return plan ?? this.build(-1, entry);
+    }
+    build(index, entry = this.schema.entries[index]) {
+        const model = entry.name === null ? undefined : this.options.models?.byName(entry.name);
+        const plan = new Plan(entry, entry.properties.map((p) => this.field(p.name)), model?.ctor ?? (entry.name === null ? undefined : this.options.classes?.[entry.name]), model !== undefined);
+        if (index >= 0)
+            this.plans[index] = plan; // before the properties: they may refer to this entry
+        else
+            this.inline.set(entry, plan);
+        entry.properties.forEach((p, t) => {
+            const type = p.type ?? model?.byName.get(p.name) ?? AnyType; // a plain schema has names only: the models know the types
+            plan.reads[t] = this.compile(type);
+            const d = p.hasDefault ? this.convertDefault(p.default, type) : this.defaultOf(type);
+            plan.values[t] = d.make === undefined ? d.value : null;
+            plan.makers[t] = d.make;
+            if (d.make !== undefined && (plan.cls === undefined || plan.missing.includes(t)))
+                (plan.made ?? (plan.made = [])).push(t);
+        });
+        if (entry.content !== undefined)
+            plan.content = this.compile(entry.content);
+        plan.prepare(this.options.generateCode);
+        return plan;
+    }
+    /** A read function for values of the type (each handles nil and values wrapped with a type id). */
+    compile(type) {
+        switch (type.k) {
+            case 'kind': return this.kind(type.kind);
+            case 'nullable': return this.compile(type.of);
+            case 'object': {
+                const entry = type.entry;
+                let plan; // not when compiled: the entry may refer to itself
+                return (r) => r.readObject(plan ?? (plan = this.planOf(entry)));
+            }
+            case 'list': {
+                const element = this.compile(type.of);
+                return (r) => r.readList(element);
+            }
+            case 'dict': {
+                const key = this.compile(type.key), value = this.compile(type.value);
+                return (r) => r.readDictionary(key, value);
+            }
+            case 'pair': {
+                const key = this.compile(type.key), value = this.compile(type.value), keyName = this.keyName, valueName = this.valueName;
+                return (r) => {
+                    const items = r.readItems([key, value]);
+                    return Array.isArray(items) ? { [keyName]: items[0], [valueName]: items[1] } : items;
+                };
+            }
+            case 'tuple': {
+                const items = type.items.map((t) => this.compile(t));
+                return (r) => r.readItems(items);
+            }
+            case 'model': { // a class of the models: the entry of its name (none: the value is nil, or has a type id)
+                const index = this.schema.indexOf(type.name);
+                return index < 0 ? readDynamic : (r) => r.readObject(this.plan(index));
+            }
+        }
+    }
+    /** The kinds the formatters write most have their usual format read in place, without the dispatch of value(). */
+    kind(kind) {
+        switch (kind) {
+            case 'guid': return readGuid;
+            case 'string': return readString;
+            case 'int': return readInt;
+            case 'decimal': {
+                const mode = this.options.decimal, convert = this.converter(kind);
+                return (r) => {
+                    const bytes = r.bytes, p = r.pos;
+                    if (bytes[p] === 0xd8 && bytes[p + 1] === 1 && p + 18 <= bytes.length) { // fixext 16 of type 1
+                        r.pos = p + 18;
+                        return decodeDecimal(bytes, p + 2, mode);
+                    }
+                    return convert(r.value());
+                };
+            }
+            case 'datetime':
+                if (this.options.dates === 'iso')
+                    return (r) => {
+                        const v = r.readDate();
+                        return v instanceof Date ? v.toISOString() : v;
+                    };
+                return (r) => r.readDate();
+        }
+        const convert = this.converter(kind);
+        return convert === undefined ? readDynamic : (r) => convert(r.value());
+    }
+    /** Converts a value of the kind as it was read (undefined: no conversion). Values in another form are returned as they are. */
+    converter(kind) {
+        const o = this.options;
+        switch (kind) {
+            case 'long':
+            case 'ulong':
+                return o.int64 === 'bigint'
+                    ? (v) => (typeof v === 'number' ? BigInt(v) : v)
+                    : (v) => (typeof v === 'bigint' ? Number(v) : v);
+            case 'bigint': return (v) => (typeof v === 'number' ? BigInt(v) : v);
+            case 'char': return (v) => (typeof v === 'number' ? String.fromCharCode(v) : v);
+            case 'decimal': return (v) => (v instanceof MsgPackExtension && v.type === 1 && v.data.length === 16 ? decodeDecimal(v.data, 0, o.decimal) : convertDecimal(v, o.decimal));
+            case 'guid': return (v) => (v instanceof Uint8Array && v.length === 16 ? guidString(v) : v);
+            case 'datetime': return o.dates === 'iso' ? (v) => (v instanceof Date ? v.toISOString() : v) : undefined;
+            case 'dto':
+            case 'dto-clock': {
+                const clock = kind === 'dto-clock';
+                const iso = o.dates === 'iso';
+                return (v) => {
+                    if (v instanceof Date)
+                        return iso ? offsetText(v, 0) : v; // a bare timestamp (DateTimeOffsetFormat.Timestamp)
+                    if (!Array.isArray(v) || v.length !== 2 || !(v[0] instanceof Date) || typeof v[1] !== 'number')
+                        return v;
+                    const moment = clock ? new Date(v[0].getTime() - v[1] * 60000) : v[0];
+                    return iso ? offsetText(moment, v[1]) : moment;
+                };
+            }
+            case 'timespan': return (v) => (typeof v === 'number' || typeof v === 'bigint' ? timeSpanText(v) : v);
+            case 'dateonly': return (v) => (typeof v === 'number' ? dateOnlyText(v) : v);
+            case 'timeonly': return (v) => (typeof v === 'number' || typeof v === 'bigint' ? timeOnlyText(v) : v);
+        }
+        return undefined; // string, bool, int, float, bin, uri, any: as read
+    }
+    /** The value of a property the writer left out: the default of its type. */
+    defaultOf(type) {
+        const o = this.options;
+        switch (type.k) {
+            case 'kind':
+                switch (type.kind) {
+                    case 'bool': return { value: false };
+                    case 'int':
+                    case 'float': return { value: 0 };
+                    case 'long':
+                    case 'ulong': return { value: o.int64 === 'bigint' ? 0n : 0 };
+                    case 'bigint': return { value: 0n };
+                    case 'decimal': return { value: convertDecimal(0, o.decimal) };
+                    case 'char': return { value: '\0' };
+                    case 'guid': return { value: EmptyGuid };
+                    case 'datetime': return o.dates === 'iso' ? { value: new Date(MinDateTimeMs).toISOString() } : { value: null, make: () => new Date(MinDateTimeMs) };
+                    case 'dto':
+                    case 'dto-clock': return o.dates === 'iso' ? { value: offsetText(new Date(MinDateTimeMs), 0) } : { value: null, make: () => new Date(MinDateTimeMs) };
+                    case 'timespan': return { value: '00:00:00' };
+                    case 'dateonly': return { value: '0001-01-01' };
+                    case 'timeonly': return { value: '00:00:00' };
+                }
+                return { value: null };
+            case 'object':
+                if (type.struct) {
+                    const entry = type.entry;
+                    return { value: null, make: () => this.planOf(entry).createComplete() };
+                }
+                return { value: null };
+            case 'pair': {
+                const key = this.defaultOf(type.key), value = this.defaultOf(type.value), keyName = this.keyName, valueName = this.valueName;
+                return { value: null, make: () => ({ [keyName]: key.make ? key.make() : key.value, [valueName]: value.make ? value.make() : value.value }) };
+            }
+            case 'model': {
+                if (!type.struct)
+                    return { value: null };
+                const ctor = this.options.models?.byName(type.name)?.ctor;
+                return ctor === undefined ? { value: null } : { value: null, make: () => new ctor() };
+            }
+        }
+        return { value: null }; // classes, nullables, collections, tuples
+    }
+    /** A [DefaultValue] of the schema (as read: decimals raw), converted as the values of the property are. */
+    convertDefault(raw, type) {
+        const kind = type.k === 'nullable' ? type.of : type;
+        const convert = kind.k === 'kind' ? this.converter(kind.kind) : undefined;
+        const value = convert === undefined ? raw : convert(raw);
+        if (value instanceof Date)
+            return { value: null, make: () => new Date(value.getTime()) };
+        return { value };
+    }
+}
+const readDynamic = (r) => r.value();
+/** A string: fixstr and str8 read in place. */
+const readString = (r) => {
+    const bytes = r.bytes, p = r.pos, b = bytes[p];
+    if (b >= 0xa0 && b <= 0xbf) {
+        r.pos = p + 1;
+        return r.str(b & 0x1f);
+    }
+    if (b === 0xd9 && p + 1 < bytes.length) {
+        r.pos = p + 2;
+        return r.str(bytes[p + 1]);
+    }
+    return r.value();
+};
+/** An int (also enums): a positive fixint read in place. */
+const readInt = (r) => {
+    const b = r.bytes[r.pos];
+    if (b <= 0x7f) {
+        r.pos++;
+        return b;
+    }
+    return r.value();
+};
+/** A Guid: bin 16 read in place (no copy of the bytes), any other form as the converter does. */
+const readGuid = (r) => {
+    const bytes = r.bytes, p = r.pos;
+    if (bytes[p] === 0xc4 && bytes[p + 1] === 16 && p + 18 <= bytes.length) {
+        r.pos = p + 18;
+        return guidString(bytes, p + 2);
+    }
+    const v = r.value();
+    return v instanceof Uint8Array && v.length === 16 ? guidString(v) : v;
+};
+/** The reader of a body: values wrapped with a type id ({ "": index, "@": content }, or { "": index, 0: value, ... }) become what their schema entry describes. */
+export class SchemaReader extends MsgPackReader {
+    constructor(bytes, options, plans, pos) {
+        super(bytes, options, pos);
+        this.plans = plans;
+    }
+    /** The first key of the map whose header was just read is "" (a type id). */
+    firstKeyIsTypeId() {
+        const k = this.bytes[this.pos];
+        return k === 0xa0 || (k === 0xd9 && this.bytes[this.pos + 1] === 0);
+    }
+    map(n) {
+        if (this.plans !== null && n > 0 && this.firstKeyIsTypeId())
+            return this.wrapped(n);
+        return super.map(n);
+    }
+    /** A value wrapped with a type id, the header (n entries) is read. */
+    wrapped(n) {
+        this.pos += this.bytes[this.pos] === 0xa0 ? 1 : 2; // the key ""
+        const index = this.value();
+        if (typeof index !== 'number')
+            throw new MsgPackError('A type id is not a schema index.', this.pos);
+        const plan = this.plans.plan(index);
+        this.enter();
+        let result = null;
+        if (plan.isObject) {
+            const o = plan.createTyped();
+            for (let t = 1; t < n; t++) {
+                const key = this.value();
+                if (key === '@') { // the array layout: { "": index, "@": [values] }
+                    const count = this.arrayLength();
+                    if (count >= 0)
+                        this.fill(plan, o, count);
+                    else
+                        this.value();
+                }
+                else
+                    this.setByKey(plan, o, key);
+            }
+            result = plan.complete(o);
+        }
+        else {
+            for (let t = 1; t < n; t++) {
+                const key = this.value();
+                if (key === '@')
+                    result = plan.content(this);
+                else
+                    this.value(); // a property of a collection ([SerializeEnumerable(SerializeProperties)]): not kept, a JS array has no place for it
+            }
+        }
+        this.depth--;
+        return result;
+    }
+    /** An object of the plan: an array of its values (the array layout), a map from property index to value, or a value with a type id. */
+    readObject(plan) {
+        const b = this.peek();
+        if (b === 0xc0) {
+            this.pos++;
+            return null;
+        }
+        let n = this.arrayLength();
+        if (n >= 0) {
+            this.enter();
+            const readArray = plan.readArrayFn;
+            if (readArray !== undefined) {
+                const o = readArray(this, n);
+                this.depth--;
+                return o;
+            }
+            const o = plan.create();
+            this.fill(plan, o, n);
+            this.depth--;
+            return plan.complete(o);
+        }
+        n = this.mapLength();
+        if (n < 0)
+            return this.value(); // not an object: as it is
+        if (n > 0 && this.firstKeyIsTypeId())
+            return this.wrapped(n);
+        this.enter();
+        const o = plan.create();
+        for (let t = 0; t < n; t++)
+            this.setByKey(plan, o, this.value());
+        this.depth--;
+        return plan.complete(o);
+    }
+    /** Values by position, nil leaves the default (the writer left the value out), values beyond the entry are skipped. */
+    fill(plan, o, n) {
+        if (plan.fillFn !== undefined)
+            return plan.fillFn(this, o, n);
+        const names = plan.names, reads = plan.reads, count = names.length, bytes = this.bytes;
+        for (let k = 0; k < n; k++) {
+            if (bytes[this.pos] === 0xc0) {
+                this.pos++;
+                continue;
+            }
+            if (k < count)
+                setOwn(o, names[k], reads[k](this));
+            else
+                this.value();
+        }
+    }
+    /** ObjectLayout.Map: the key is the index of the property in the entry (or its name). */
+    setByKey(plan, o, key) {
+        const index = typeof key === 'number' ? key : typeof key === 'string' ? plan.indexOfWriterName(key) : -1;
+        if (index >= 0 && index < plan.names.length)
+            setOwn(o, plan.names[index], plan.reads[index](this));
+        else
+            this.value();
+    }
+    readList(element) {
+        const b = this.peek();
+        if (b === 0xc0) {
+            this.pos++;
+            return null;
+        }
+        const n = this.arrayLength();
+        if (n < 0)
+            return this.value(); // wrapped with a type id, or not a list
+        this.enter();
+        const result = new Array(n);
+        for (let t = 0; t < n; t++)
+            result[t] = element(this);
+        this.depth--;
+        return result;
+    }
+    readDictionary(key, value) {
+        const b = this.peek();
+        if (b === 0xc0) {
+            this.pos++;
+            return null;
+        }
+        if (this.startsWithTypeId())
+            return this.value();
+        const n = this.mapLength();
+        if (n < 0)
+            return this.value();
+        this.enter();
+        const result = {};
+        for (let t = 0; t < n; t++) {
+            const k = key(this);
+            setOwn(result, typeof k === 'string' ? k : String(k), value(this));
+        }
+        this.depth--;
+        return result;
+    }
+    /** An array of items of the given types (pairs, tuples), extra items as they are. */
+    readItems(items) {
+        const b = this.peek();
+        if (b === 0xc0) {
+            this.pos++;
+            return null;
+        }
+        const n = this.arrayLength();
+        if (n < 0)
+            return this.value();
+        this.enter();
+        const result = new Array(n);
+        for (let t = 0; t < n; t++)
+            result[t] = t < items.length ? items[t](this) : this.value();
+        this.depth--;
+        return result;
+    }
+    /** A DateTime: the timestamps of 4 and 8 bytes read in place. */
+    readDate() {
+        const bytes = this.bytes, p = this.pos, b = bytes[p];
+        if (bytes[p + 1] === 0xff && (b === 0xd6 || b === 0xd7)) {
+            const length = b === 0xd6 ? 4 : 8;
+            if (p + 2 + length <= bytes.length) {
+                this.pos = p + 2;
+                return this.timestamp(length);
+            }
+        }
+        return this.value();
+    }
+    readRoot() {
+        return this.plans === null ? this.value() : this.plans.root(this);
+    }
+}
+/** The models' TypeScript types assume the options they were generated with. */
+function checkModelOptions(models, o) {
+    const differs = (name, model, actual) => {
+        if (model !== undefined && model !== actual)
+            throw new Error(`The models (${models.generator ?? 'lsmsgpack-ts'}) were generated for ${name}: '${model}', the client reads with '${typeof actual === 'function' ? 'a function' : actual}'. Generate them with the same option, or leave it out here.`);
+    };
+    differs('int64', models.int64, o.int64);
+    differs('dates', models.dates, o.dates);
+    if (typeof o.decimal !== 'function')
+        differs('decimal', models.decimal, o.decimal); // a function of the text: the user's own type
+    differs('propertyNames', models.propertyNames, o.propertyNames); // the field names of the classes
+}
+/** Decodes payloads with the given options (one per client). Thread-safe in the sense of JavaScript: no state between calls except the plans per schema. */
+export class Decoder {
+    constructor(options = {}) {
+        this.plans = new WeakMap();
+        const models = options.models;
+        this.options = {
+            decimal: options.decimal ?? models?.decimal ?? 'number',
+            int64: options.int64 ?? models?.int64 ?? 'number',
+            dates: options.dates ?? models?.dates ?? 'date',
+            models,
+            classes: options.classes,
+            propertyNames: options.propertyNames ?? models?.propertyNames ?? 'dotnet',
+            generateCode: options.generateCode ?? true,
+        };
+        if (models !== undefined)
+            checkModelOptions(models, this.options);
+        this.readerOptions = { decimal: this.options.decimal, maxDepth: options.maxDepth };
+        this.indexedSchema = options.indexedSchema ?? true;
+    }
+    /**
+     * Decodes application/x-lsmsgpack data: the schema (or a reference to it) followed by the body.
+     * @param lookup finds a schema the data refers to by its id
+     * @param inline makes the schema of the inline bytes (e.g. the known instance when the bytes are the same), default: parses them
+     */
+    decode(bytes, lookup, inline) {
+        if (bytes.length === 0)
+            return { value: undefined, reference: false };
+        if (!this.indexedSchema || bytes[0] === 0xc0) // null is written without a schema
+            return { value: this.read(bytes, null, 0), reference: false };
+        if (bytes[0] === 0xd8 && bytes[1] === 2) { // a reference: fixext 16 of type 2 with the id
+            if (bytes.length < 18)
+                throw new MsgPackError('Unexpected end of data.', bytes.length);
+            const id = toHex(bytes, 2, 18);
+            const schema = lookup?.(id);
+            if (schema === undefined)
+                throw new MissingSchemaError(id);
+            return { value: this.read(bytes, schema, 18), schema, reference: true };
+        }
+        const b = bytes[0];
+        if (!((b >= 0x80 && b <= 0x8f) || b === 0xde || b === 0xdf))
+            throw new MsgPackError(`The data does not start with a schema (0x${b.toString(16)}), set indexedSchema to false for data without it.`, 0);
+        const skip = new MsgPackReader(bytes, { decimal: 'raw' });
+        skip.skip();
+        const schemaBytes = bytes.subarray(0, skip.pos);
+        const schema = inline ? inline(schemaBytes) : new Schema(schemaBytes);
+        return { value: this.read(bytes, schema, skip.pos), schema, reference: false };
+    }
+    /** Plain MsgPack (application/msgpack): any value, maps as objects. */
+    decodePlain(bytes) {
+        if (bytes.length === 0)
+            return undefined;
+        return this.read(bytes, null, 0);
+    }
+    read(bytes, schema, pos) {
+        const reader = new SchemaReader(bytes, this.readerOptions, schema === null ? null : this.plansOf(schema), pos);
+        const value = reader.readRoot();
+        if (reader.pos !== bytes.length)
+            throw new MsgPackError('Data after the value.', reader.pos);
+        return value;
+    }
+    plansOf(schema) {
+        let plans = this.plans.get(schema);
+        if (plans === undefined) {
+            plans = new Plans(schema, this.options);
+            this.plans.set(schema, plans);
+        }
+        return plans;
+    }
+}
+//# sourceMappingURL=decoder.js.map