first commit

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackDecoder.d.ts

@@ -0,0 +1,19 @@
+import { MsgPackDecoderFast } from './MsgPackDecoderFast';
+import type { Path } from '@jsonjoy.com/json-pointer';
+import type { Reader } from '@jsonjoy.com/buffers/lib/Reader';
+export declare class MsgPackDecoder extends MsgPackDecoderFast<Reader> {
+    skipAny(): number;
+    protected skipArr(size: number): number;
+    protected skipObj(size: number): number;
+    readLevel(uint8: Uint8Array): unknown;
+    protected valOneLevel(): unknown;
+    protected primitive(): unknown;
+    protected skip(length: number): number;
+    validate(value: Uint8Array, offset?: number, size?: number): void;
+    readObjHdr(): number;
+    readStrHdr(): number;
+    findKey(key: string): this;
+    readArrHdr(): number;
+    findIndex(index: number): this;
+    find(path: Path): this;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackDecoder.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackDecoder = void 0;
+const _1 = require(".");
+const MsgPackDecoderFast_1 = require("./MsgPackDecoderFast");
+class MsgPackDecoder extends MsgPackDecoderFast_1.MsgPackDecoderFast {
+    skipAny() {
+        const byte = this.reader.u8();
+        if (byte >= 0xe0)
+            return 1;
+        if (byte <= 0xbf) {
+            if (byte < 0x90) {
+                if (byte <= 0b1111111)
+                    return 1;
+                return 1 + this.skipObj(byte & 0b1111);
+            }
+            else {
+                if (byte < 0xa0)
+                    return 1 + this.skipArr(byte & 0b1111);
+                else
+                    return 1 + this.skip(byte & 0b11111);
+            }
+        }
+        if (byte <= 0xd0) {
+            if (byte <= 0xc8) {
+                if (byte <= 0xc4) {
+                    if (byte <= 0xc2)
+                        return byte === 0xc2 ? 1 : 1;
+                    else
+                        return byte === 0xc4 ? 2 + this.skip(this.reader.u8()) : 1;
+                }
+                else {
+                    if (byte <= 0xc6)
+                        return byte === 0xc6 ? 5 + this.skip(this.reader.u32()) : 3 + this.skip(this.reader.u16());
+                    else
+                        return byte === 0xc8 ? 4 + this.skip(this.reader.u16()) : 3 + this.skip(this.reader.u8());
+                }
+            }
+            else {
+                return byte <= 0xcc
+                    ? byte <= 0xca
+                        ? byte === 0xca
+                            ? 1 + this.skip(4)
+                            : 1 + 1 + 4 + this.skip(this.reader.u32())
+                        : byte === 0xcc
+                            ? 1 + this.skip(1)
+                            : 1 + this.skip(8)
+                    : byte <= 0xce
+                        ? byte === 0xce
+                            ? 1 + this.skip(4)
+                            : 1 + this.skip(2)
+                        : byte === 0xd0
+                            ? 1 + this.skip(1)
+                            : 1 + this.skip(8);
+            }
+        }
+        else if (byte <= 0xd8) {
+            return byte <= 0xd4
+                ? byte <= 0xd2
+                    ? byte === 0xd2
+                        ? 1 + this.skip(4)
+                        : 1 + this.skip(2)
+                    : byte === 0xd4
+                        ? 1 + this.skip(2)
+                        : 1 + this.skip(8)
+                : byte <= 0xd6
+                    ? byte === 0xd6
+                        ? 1 + this.skip(5)
+                        : 1 + this.skip(3)
+                    : byte === 0xd8
+                        ? 1 + this.skip(17)
+                        : 1 + this.skip(9);
+        }
+        else {
+            switch (byte) {
+                case 0xd9:
+                    return 2 + this.skip(this.reader.u8());
+                case 0xda:
+                    return 3 + this.skip(this.reader.u16());
+                case 0xdb:
+                    return 5 + this.skip(this.reader.u32());
+                case 0xdc:
+                    return 3 + this.skipArr(this.reader.u16());
+                case 0xdd:
+                    return 5 + this.skipArr(this.reader.u32());
+                case 0xde:
+                    return 3 + this.skipObj(this.reader.u16());
+                case 0xdf:
+                    return 5 + this.skipObj(this.reader.u32());
+            }
+        }
+        return 1;
+    }
+    skipArr(size) {
+        let length = 0;
+        for (let i = 0; i < size; i++)
+            length += this.skipAny();
+        return length;
+    }
+    skipObj(size) {
+        let length = 0;
+        for (let i = 0; i < size; i++) {
+            length += this.skipAny() + this.skipAny();
+        }
+        return length;
+    }
+    readLevel(uint8) {
+        this.reader.reset(uint8);
+        return this.valOneLevel();
+    }
+    valOneLevel() {
+        const byte = this.reader.view.getUint8(this.reader.x);
+        const isMap = byte === 0xde || byte === 0xdf || byte >> 4 === 0b1000;
+        if (isMap) {
+            this.reader.x++;
+            const size = byte === 0xde ? this.reader.u16() : byte === 0xdf ? this.reader.u32() : byte & 0b1111;
+            const obj = {};
+            for (let i = 0; i < size; i++) {
+                const key = this.key();
+                obj[key] = this.primitive();
+            }
+            return obj;
+        }
+        const isArray = byte === 0xdc || byte === 0xdd || byte >> 4 === 0b1001;
+        if (isArray) {
+            this.reader.x++;
+            const size = byte === 0xdc ? this.reader.u16() : byte === 0xdd ? this.reader.u32() : byte & 0b1111;
+            const arr = [];
+            for (let i = 0; i < size; i++)
+                arr.push(this.primitive());
+            return arr;
+        }
+        return this.readAny();
+    }
+    primitive() {
+        const reader = this.reader;
+        const byte = reader.view.getUint8(reader.x);
+        const isMapOrArray = byte === 0xde || byte === 0xdf || byte === 0xdc || byte === 0xdd || byte >> 5 === 0b100;
+        if (isMapOrArray) {
+            const length = this.skipAny();
+            reader.x -= length;
+            const buf = reader.buf(length);
+            return new _1.JsonPackValue(buf);
+        }
+        return this.readAny();
+    }
+    skip(length) {
+        this.reader.x += length;
+        return length;
+    }
+    validate(value, offset = 0, size = value.length) {
+        this.reader.reset(value);
+        this.reader.x = offset;
+        const start = offset;
+        this.skipAny();
+        const end = this.reader.x;
+        if (end - start !== size)
+            throw new Error('INVALID_SIZE');
+    }
+    readObjHdr() {
+        const reader = this.reader;
+        const byte = reader.u8();
+        const isFixMap = byte >> 4 === 0b1000;
+        if (isFixMap)
+            return byte & 0b1111;
+        switch (byte) {
+            case 0xde:
+                return reader.u16();
+            case 0xdf:
+                return reader.u32();
+        }
+        throw new Error('NOT_OBJ');
+    }
+    readStrHdr() {
+        const reader = this.reader;
+        const byte = reader.u8();
+        if (byte >> 5 === 0b101)
+            return byte & 0b11111;
+        switch (byte) {
+            case 0xd9:
+                return reader.u8();
+            case 0xda:
+                return reader.u16();
+            case 0xdb:
+                return reader.u32();
+        }
+        throw new Error('NOT_STR');
+    }
+    findKey(key) {
+        const size = this.readObjHdr();
+        for (let i = 0; i < size; i++) {
+            const k = this.key();
+            if (k === key)
+                return this;
+            this.skipAny();
+        }
+        throw new Error('KEY_NOT_FOUND');
+    }
+    readArrHdr() {
+        const reader = this.reader;
+        const byte = reader.u8();
+        const isFixArr = byte >> 4 === 0b1001;
+        if (isFixArr)
+            return byte & 0b1111;
+        switch (byte) {
+            case 0xdc:
+                return this.reader.u16();
+            case 0xdd:
+                return this.reader.u32();
+        }
+        throw new Error('NOT_ARR');
+    }
+    findIndex(index) {
+        const size = this.readArrHdr();
+        if (index >= size)
+            throw new Error('INDEX_OUT_OF_BOUNDS');
+        for (let i = 0; i < index; i++)
+            this.skipAny();
+        return this;
+    }
+    find(path) {
+        for (let i = 0; i < path.length; i++) {
+            const segment = path[i];
+            if (typeof segment === 'string')
+                this.findKey(segment);
+            else
+                this.findIndex(segment);
+        }
+        return this;
+    }
+}
+exports.MsgPackDecoder = MsgPackDecoder;
+//# sourceMappingURL=MsgPackDecoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackDecoderFast.d.ts

@@ -0,0 +1,19 @@
+import { JsonPackExtension } from '../JsonPackExtension';
+import { Reader } from '@jsonjoy.com/buffers/lib/Reader';
+import type { BinaryJsonDecoder, PackValue } from '../types';
+import type { CachedUtf8Decoder } from '@jsonjoy.com/buffers/lib/utf8/CachedUtf8Decoder';
+export declare class MsgPackDecoderFast<R extends Reader> implements BinaryJsonDecoder {
+    reader: R;
+    protected readonly keyDecoder: CachedUtf8Decoder;
+    constructor(reader?: R, keyDecoder?: CachedUtf8Decoder);
+    decode(uint8: Uint8Array): unknown;
+    read(uint8: Uint8Array): PackValue;
+    val(): unknown;
+    readAny(): unknown;
+    str(): unknown;
+    protected obj(size: number): object;
+    protected key(): string;
+    protected arr(size: number): unknown[];
+    protected ext(size: number): JsonPackExtension;
+    protected back(bytes: number): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackDecoderFast.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackDecoderFast = void 0;
+const tslib_1 = require("tslib");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const sharedCachedUtf8Decoder_1 = tslib_1.__importDefault(require("@jsonjoy.com/buffers/lib/utf8/sharedCachedUtf8Decoder"));
+class MsgPackDecoderFast {
+    constructor(reader = new Reader_1.Reader(), keyDecoder = sharedCachedUtf8Decoder_1.default) {
+        this.reader = reader;
+        this.keyDecoder = keyDecoder;
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    read(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    val() {
+        return this.readAny();
+    }
+    readAny() {
+        const reader = this.reader;
+        const byte = reader.u8();
+        if (byte >= 0xe0)
+            return byte - 0x100;
+        if (byte <= 0xbf) {
+            if (byte < 0x90) {
+                if (byte <= 0b1111111)
+                    return byte;
+                return this.obj(byte & 0b1111);
+            }
+            else {
+                if (byte < 0xa0)
+                    return this.arr(byte & 0b1111);
+                else
+                    return reader.utf8(byte & 0b11111);
+            }
+        }
+        if (byte <= 0xd0) {
+            if (byte <= 0xc8) {
+                if (byte <= 0xc4) {
+                    if (byte <= 0xc2)
+                        return byte === 0xc2 ? false : byte === 0xc0 ? null : undefined;
+                    else
+                        return byte === 0xc4 ? reader.buf(reader.u8()) : true;
+                }
+                else {
+                    if (byte <= 0xc6)
+                        return byte === 0xc6 ? reader.buf(reader.u32()) : reader.buf(reader.u16());
+                    else
+                        return byte === 0xc8 ? this.ext(reader.u16()) : this.ext(reader.u8());
+                }
+            }
+            else {
+                return byte <= 0xcc
+                    ? byte <= 0xca
+                        ? byte === 0xca
+                            ? reader.f32()
+                            : this.ext(reader.u32())
+                        : byte === 0xcc
+                            ? reader.u8()
+                            : reader.f64()
+                    : byte <= 0xce
+                        ? byte === 0xce
+                            ? reader.u32()
+                            : reader.u16()
+                        : byte === 0xd0
+                            ? reader.i8()
+                            : reader.u32() * 4294967296 + reader.u32();
+            }
+        }
+        else if (byte <= 0xd8) {
+            return byte <= 0xd4
+                ? byte <= 0xd2
+                    ? byte === 0xd2
+                        ? reader.i32()
+                        : reader.i16()
+                    : byte === 0xd4
+                        ? this.ext(1)
+                        : reader.i32() * 4294967296 + reader.u32()
+                : byte <= 0xd6
+                    ? byte === 0xd6
+                        ? this.ext(4)
+                        : this.ext(2)
+                    : byte === 0xd8
+                        ? this.ext(16)
+                        : this.ext(8);
+        }
+        else {
+            switch (byte) {
+                case 0xd9:
+                    return reader.utf8(reader.u8());
+                case 0xda:
+                    return reader.utf8(reader.u16());
+                case 0xdb:
+                    return reader.utf8(reader.u32());
+                case 0xdc:
+                    return this.arr(reader.u16());
+                case 0xdd:
+                    return this.arr(reader.u32());
+                case 0xde:
+                    return this.obj(reader.u16());
+                case 0xdf:
+                    return this.obj(reader.u32());
+            }
+        }
+        return undefined;
+    }
+    str() {
+        const reader = this.reader;
+        const byte = reader.u8();
+        if (byte >> 5 === 0b101)
+            return reader.utf8(byte & 0b11111);
+        switch (byte) {
+            case 0xd9:
+                return reader.utf8(reader.u8());
+            case 0xda:
+                return reader.utf8(reader.u16());
+            case 0xdb:
+                return reader.utf8(reader.u32());
+        }
+        return undefined;
+    }
+    obj(size) {
+        const obj = {};
+        for (let i = 0; i < size; i++) {
+            const key = this.key();
+            if (key === '__proto__')
+                throw 6;
+            obj[key] = this.readAny();
+        }
+        return obj;
+    }
+    key() {
+        const reader = this.reader;
+        const byte = reader.view.getUint8(reader.x);
+        if (byte >= 0b10100000 && byte <= 0b10111111) {
+            const size = byte & 0b11111;
+            const key = this.keyDecoder.decode(reader.uint8, reader.x + 1, size);
+            reader.x += 1 + size;
+            return key;
+        }
+        else if (byte === 0xd9) {
+            const size = reader.view.getUint8(reader.x + 1);
+            if (size < 32) {
+                const key = this.keyDecoder.decode(reader.uint8, reader.x + 2, size);
+                reader.x += 2 + size;
+                return key;
+            }
+        }
+        reader.x++;
+        switch (byte) {
+            case 0xd9:
+                return reader.utf8(reader.u8());
+            case 0xda:
+                return reader.utf8(reader.u16());
+            case 0xdb:
+                return reader.utf8(reader.u32());
+            default:
+                return '';
+        }
+    }
+    arr(size) {
+        const arr = [];
+        for (let i = 0; i < size; i++)
+            arr.push(this.readAny());
+        return arr;
+    }
+    ext(size) {
+        const reader = this.reader;
+        const type = reader.u8();
+        const end = reader.x + size;
+        const buf = reader.uint8.subarray(reader.x, end);
+        reader.x = end;
+        return new JsonPackExtension_1.JsonPackExtension(type, buf);
+    }
+    back(bytes) {
+        this.reader.x -= bytes;
+    }
+}
+exports.MsgPackDecoderFast = MsgPackDecoderFast;
+//# sourceMappingURL=MsgPackDecoderFast.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoder.d.ts

@@ -0,0 +1,5 @@
+import { MsgPackEncoderFast } from './MsgPackEncoderFast';
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+export declare class MsgPackEncoder<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> extends MsgPackEncoderFast<W> {
+    writeAny(value: unknown): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoder.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackEncoder = void 0;
+const MsgPackEncoderFast_1 = require("./MsgPackEncoderFast");
+const isUint8Array_1 = require("@jsonjoy.com/buffers/lib/isUint8Array");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const JsonPackValue_1 = require("../JsonPackValue");
+class MsgPackEncoder extends MsgPackEncoderFast_1.MsgPackEncoderFast {
+    writeAny(value) {
+        switch (value) {
+            case null:
+                return this.writer.u8(192);
+            case false:
+                return this.writer.u8(194);
+            case true:
+                return this.writer.u8(195);
+        }
+        if (value instanceof Array)
+            return this.encodeArray(value);
+        switch (typeof value) {
+            case 'number':
+                return this.encodeNumber(value);
+            case 'string':
+                return this.encodeString(value);
+            case 'object': {
+                if (value instanceof JsonPackValue_1.JsonPackValue)
+                    return this.writer.buf(value.val, value.val.length);
+                if (value instanceof JsonPackExtension_1.JsonPackExtension)
+                    return this.encodeExt(value);
+                if ((0, isUint8Array_1.isUint8Array)(value))
+                    return this.encodeBinary(value);
+                return this.encodeObject(value);
+            }
+            case 'undefined':
+                return this.writer.u8(193);
+        }
+    }
+}
+exports.MsgPackEncoder = MsgPackEncoder;
+//# sourceMappingURL=MsgPackEncoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MsgPackEncoder.js","sourceRoot":"","sources":["../../src/msgpack/MsgPackEncoder.ts"],"names":[],"mappings":";;;AAAA,6DAAwD;AACxD,wEAAmE;AACnE,4DAAuD;AACvD,oDAA+C;AAO/C,MAAa,cAEX,SAAQ,uCAAqB;IACtB,QAAQ,CAAC,KAAc;QAC5B,QAAQ,KAAK,EAAE,CAAC;YACd,KAAK,IAAI;gBACP,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,KAAc,CAAC;YACtC,KAAK,KAAK;gBACR,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,KAAe,CAAC;YACvC,KAAK,IAAI;gBACP,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,KAAc,CAAC;QACxC,CAAC;QACD,IAAI,KAAK,YAAY,KAAK;YAAE,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC3D,QAAQ,OAAO,KAAK,EAAE,CAAC;YACrB,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAClC,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAClC,KAAK,QAAQ,CAAC,CAAC,CAAC;gBACd,IAAI,KAAK,YAAY,6BAAa;oBAAE,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACxF,IAAI,KAAK,YAAY,qCAAiB;oBAAE,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;gBACrE,IAAI,IAAA,2BAAY,EAAC,KAAK,CAAC;oBAAE,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;gBACzD,OAAO,IAAI,CAAC,YAAY,CAAC,KAAgC,CAAC,CAAC;YAC7D,CAAC;YACD,KAAK,WAAW;gBACd,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,KAAmB,CAAC;QAC7C,CAAC;IACH,CAAC;CACF;AA5BD,wCA4BC"}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoderFast.d.ts

@@ -0,0 +1,45 @@
+import { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+import { JsonPackExtension } from '../JsonPackExtension';
+import { BinaryJsonEncoder, TlvBinaryJsonEncoder } from '../types';
+import { IMessagePackEncoder } from './types';
+export declare class MsgPackEncoderFast<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> implements IMessagePackEncoder, BinaryJsonEncoder, TlvBinaryJsonEncoder {
+    readonly writer: W;
+    constructor(writer?: W);
+    encode(json: unknown): Uint8Array;
+    encodeAny(json: unknown): void;
+    writeAny(value: unknown): void;
+    protected encodeFloat64(num: number): void;
+    writeNull(): void;
+    writeFloat(float: number): void;
+    u32(num: number): void;
+    n32(num: number): void;
+    encodeNumber(num: number): void;
+    writeNumber(num: number): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    encodeNull(): void;
+    encodeTrue(): void;
+    encodeFalse(): void;
+    encodeBoolean(bool: boolean): void;
+    writeBoolean(bool: boolean): void;
+    encodeStringHeader(length: number): void;
+    writeStrHdr(length: number): void;
+    encodeString(str: string): void;
+    writeStr(str: string): void;
+    encodeAsciiString(str: string): void;
+    writeAsciiStr(str: string): void;
+    encodeArrayHeader(length: number): void;
+    encodeArray(arr: unknown[]): void;
+    writeArrHdr(length: number): void;
+    writeArr(arr: unknown[]): void;
+    encodeObjectHeader(length: number): void;
+    encodeObject(obj: Record<string, unknown>): void;
+    writeObjHdr(length: number): void;
+    writeObj(obj: Record<string, unknown>): void;
+    encodeExtHeader(type: number, length: number): void;
+    encodeExt(ext: JsonPackExtension): void;
+    encodeBinaryHeader(length: number): void;
+    encodeBinary(buf: Uint8Array): void;
+    writeBinHdr(length: number): void;
+    writeBin(buf: Uint8Array): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoderFast.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackEncoderFast = void 0;
+const Writer_1 = require("@jsonjoy.com/buffers/lib/Writer");
+class MsgPackEncoderFast {
+    constructor(writer = new Writer_1.Writer()) {
+        this.writer = writer;
+    }
+    encode(json) {
+        this.writer.reset();
+        this.writeAny(json);
+        return this.writer.flush();
+    }
+    encodeAny(json) {
+        this.writeAny(json);
+    }
+    writeAny(value) {
+        switch (value) {
+            case null:
+                return this.writer.u8(0xc0);
+            case false:
+                return this.writer.u8(0xc2);
+            case true:
+                return this.writer.u8(0xc3);
+        }
+        if (value instanceof Array)
+            return this.writeArr(value);
+        switch (typeof value) {
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                return this.writeStr(value);
+            case 'object':
+                return this.writeObj(value);
+        }
+    }
+    encodeFloat64(num) {
+        this.writeFloat(num);
+    }
+    writeNull() {
+        return this.writer.u8(0xc0);
+    }
+    writeFloat(float) {
+        this.writer.u8f64(0xcb, float);
+    }
+    u32(num) {
+        const writer = this.writer;
+        this.writer.ensureCapacity(5);
+        const uint8 = writer.uint8;
+        if (num <= 0b1111111) {
+            uint8[writer.x++] = num;
+        }
+        else if (num <= 0xffff) {
+            uint8[writer.x++] = 0xcd;
+            writer.view.setUint16(writer.x, num);
+            writer.x += 2;
+        }
+        else if (num <= 0xffffffff) {
+            uint8[writer.x++] = 0xce;
+            writer.view.setUint32(writer.x, num);
+            writer.x += 4;
+        }
+        else
+            this.writeFloat(num);
+    }
+    n32(num) {
+        const writer = this.writer;
+        this.writer.ensureCapacity(5);
+        const uint8 = writer.uint8;
+        if (num >= -0x20) {
+            uint8[writer.x++] = 0x100 + num;
+        }
+        else if (num >= -0x8000) {
+            uint8[writer.x++] = 0xd1;
+            writer.view.setInt16(writer.x, num);
+            writer.x += 2;
+        }
+        else if (num >= -0x80000000) {
+            uint8[writer.x++] = 0xd2;
+            writer.view.setInt32(writer.x, num);
+            writer.x += 4;
+        }
+        else
+            this.writeFloat(num);
+    }
+    encodeNumber(num) {
+        this.writeNumber(num);
+    }
+    writeNumber(num) {
+        if (num >>> 0 === num)
+            return this.u32(num);
+        if (num >> 0 === num)
+            return this.n32(num);
+        this.writeFloat(num);
+    }
+    writeInteger(int) {
+        if (int >= 0)
+            if (int <= 0xffffffff)
+                return this.u32(int);
+            else if (int > -0x80000000)
+                return this.n32(int);
+        this.writeFloat(int);
+    }
+    writeUInteger(uint) {
+        if (uint <= 0xffffffff)
+            return this.u32(uint);
+        this.writeFloat(uint);
+    }
+    encodeNull() {
+        this.writer.u8(0xc0);
+    }
+    encodeTrue() {
+        this.writer.u8(0xc3);
+    }
+    encodeFalse() {
+        this.writer.u8(0xc2);
+    }
+    encodeBoolean(bool) {
+        this.writeBoolean(bool);
+    }
+    writeBoolean(bool) {
+        if (bool)
+            this.writer.u8(0xc3);
+        else
+            this.writer.u8(0xc2);
+    }
+    encodeStringHeader(length) {
+        this.writeStrHdr(length);
+    }
+    writeStrHdr(length) {
+        if (length <= 0b11111)
+            this.writer.u8(0b10100000 | length);
+        else if (length <= 0xff)
+            this.writer.u16(0xd900 + length);
+        else if (length <= 0xffff)
+            this.writer.u8u16(0xda, length);
+        else
+            this.writer.u8u32(0xdb, length);
+    }
+    encodeString(str) {
+        this.writeStr(str);
+    }
+    writeStr(str) {
+        const writer = this.writer;
+        const length = str.length;
+        const maxSize = length * 4;
+        writer.ensureCapacity(5 + maxSize);
+        const uint8 = writer.uint8;
+        let lengthOffset = writer.x;
+        if (maxSize <= 0b11111)
+            writer.x++;
+        else if (maxSize <= 0xff) {
+            uint8[writer.x++] = 0xd9;
+            lengthOffset = writer.x;
+            writer.x++;
+        }
+        else if (maxSize <= 0xffff) {
+            uint8[writer.x++] = 0xda;
+            lengthOffset = writer.x;
+            writer.x += 2;
+        }
+        else {
+            uint8[writer.x++] = 0xdb;
+            lengthOffset = writer.x;
+            writer.x += 4;
+        }
+        const bytesWritten = this.writer.utf8(str);
+        if (maxSize <= 0b11111)
+            uint8[lengthOffset] = 0b10100000 | bytesWritten;
+        else if (maxSize <= 0xff)
+            uint8[lengthOffset] = bytesWritten;
+        else if (maxSize <= 0xffff)
+            writer.view.setUint16(lengthOffset, bytesWritten);
+        else
+            writer.view.setUint32(lengthOffset, bytesWritten);
+    }
+    encodeAsciiString(str) {
+        this.writeAsciiStr(str);
+    }
+    writeAsciiStr(str) {
+        this.writeStrHdr(str.length);
+        this.writer.ascii(str);
+    }
+    encodeArrayHeader(length) {
+        this.writeArrHdr(length);
+    }
+    encodeArray(arr) {
+        this.writeArr(arr);
+    }
+    writeArrHdr(length) {
+        if (length <= 0b1111)
+            this.writer.u8(0b10010000 | length);
+        else if (length <= 0xffff)
+            this.writer.u8u16(0xdc, length);
+        else if (length <= 0xffffffff)
+            this.writer.u8u32(0xdd, length);
+    }
+    writeArr(arr) {
+        const length = arr.length;
+        if (length <= 0b1111)
+            this.writer.u8(0b10010000 | length);
+        else if (length <= 0xffff)
+            this.writer.u8u16(0xdc, length);
+        else if (length <= 0xffffffff)
+            this.writer.u8u32(0xdd, length);
+        for (let i = 0; i < length; i++)
+            this.writeAny(arr[i]);
+    }
+    encodeObjectHeader(length) {
+        this.writeObjHdr(length);
+    }
+    encodeObject(obj) {
+        this.writeObj(obj);
+    }
+    writeObjHdr(length) {
+        if (length <= 0b1111)
+            this.writer.u8(0b10000000 | length);
+        else if (length <= 0xffff) {
+            this.writer.u8u16(0xde, length);
+        }
+        else if (length <= 0xffffffff) {
+            this.writer.u8u32(0xdf, length);
+        }
+    }
+    writeObj(obj) {
+        const keys = Object.keys(obj);
+        const length = keys.length;
+        this.writeObjHdr(length);
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key);
+            this.writeAny(obj[key]);
+        }
+    }
+    encodeExtHeader(type, length) {
+        switch (length) {
+            case 1:
+                this.writer.u16((0xd4 << 8) | type);
+                break;
+            case 2:
+                this.writer.u16((0xd5 << 8) | type);
+                break;
+            case 4:
+                this.writer.u16((0xd6 << 8) | type);
+                break;
+            case 8:
+                this.writer.u16((0xd7 << 8) | type);
+                break;
+            case 16:
+                this.writer.u16((0xd8 << 8) | type);
+                break;
+            default:
+                if (length <= 0xff) {
+                    this.writer.u16((0xc7 << 8) | length);
+                    this.writer.u8(type);
+                }
+                else if (length <= 0xffff) {
+                    this.writer.u8u16(0xc8, length);
+                    this.writer.u8(type);
+                }
+                else if (length <= 0xffffffff) {
+                    this.writer.u8u32(0xc9, length);
+                    this.writer.u8(type);
+                }
+        }
+    }
+    encodeExt(ext) {
+        const { tag: type, val: buf } = ext;
+        const length = buf.length;
+        this.encodeExtHeader(type, length);
+        this.writer.buf(buf, length);
+    }
+    encodeBinaryHeader(length) {
+        this.writeBinHdr(length);
+    }
+    encodeBinary(buf) {
+        this.writeBin(buf);
+    }
+    writeBinHdr(length) {
+        if (length <= 0xff)
+            this.writer.u16((0xc4 << 8) | length);
+        else if (length <= 0xffff) {
+            this.writer.u8u16(0xc5, length);
+        }
+        else if (length <= 0xffffffff) {
+            this.writer.u8u32(0xc6, length);
+        }
+    }
+    writeBin(buf) {
+        const length = buf.length;
+        this.writeBinHdr(length);
+        this.writer.buf(buf, length);
+    }
+}
+exports.MsgPackEncoderFast = MsgPackEncoderFast;
+//# sourceMappingURL=MsgPackEncoderFast.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoderStable.d.ts

@@ -0,0 +1,4 @@
+import { MsgPackEncoderFast } from './MsgPackEncoderFast';
+export declare class MsgPackEncoderStable extends MsgPackEncoderFast {
+    writeObj(obj: Record<string, unknown>): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoderStable.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackEncoderStable = void 0;
+const insertion_1 = require("@jsonjoy.com/util/lib/sort/insertion");
+const MsgPackEncoderFast_1 = require("./MsgPackEncoderFast");
+class MsgPackEncoderStable extends MsgPackEncoderFast_1.MsgPackEncoderFast {
+    writeObj(obj) {
+        const keys = (0, insertion_1.sort)(Object.keys(obj));
+        const length = keys.length;
+        this.writeObjHdr(length);
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key);
+            this.writeAny(obj[key]);
+        }
+    }
+}
+exports.MsgPackEncoderStable = MsgPackEncoderStable;
+//# sourceMappingURL=MsgPackEncoderStable.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackEncoderStable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MsgPackEncoderStable.js","sourceRoot":"","sources":["../../src/msgpack/MsgPackEncoderStable.ts"],"names":[],"mappings":";;;AAAA,oEAA0D;AAC1D,6DAAwD;AAKxD,MAAa,oBAAqB,SAAQ,uCAAkB;IACnD,QAAQ,CAAC,GAA4B;QAC1C,MAAM,IAAI,GAAG,IAAA,gBAAI,EAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACpC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAChC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;CACF;AAXD,oDAWC"}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackToJsonConverter.d.ts

@@ -0,0 +1,24 @@
+import { json_string } from '@jsonjoy.com/util/lib/json-brand';
+export declare class MsgPackToJsonConverter {
+    protected uint8: Uint8Array;
+    protected view: DataView;
+    protected x: number;
+    constructor();
+    reset(uint8: Uint8Array): void;
+    convert<T = unknown>(uint8: Uint8Array): json_string<T>;
+    protected val(): string;
+    protected str(size: number): string;
+    protected obj(size: number): json_string<object>;
+    protected key(): json_string<string>;
+    protected arr(size: number): json_string<unknown[]>;
+    protected bin(size: number): string;
+    protected ext(size: number): string;
+    protected u8(): number;
+    protected u16(): number;
+    protected u32(): number;
+    protected i8(): number;
+    protected i16(): number;
+    protected i32(): number;
+    protected f32(): number;
+    protected f64(): number;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/MsgPackToJsonConverter.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackToJsonConverter = void 0;
+const asString_1 = require("@jsonjoy.com/util/lib/strings/asString");
+const toDataUri_1 = require("../util/buffers/toDataUri");
+class MsgPackToJsonConverter {
+    constructor() {
+        this.uint8 = new Uint8Array([]);
+        this.view = new DataView(this.uint8.buffer);
+        this.x = 0;
+    }
+    reset(uint8) {
+        this.x = 0;
+        this.uint8 = uint8;
+        this.view = new DataView(uint8.buffer, uint8.byteOffset, uint8.length);
+    }
+    convert(uint8) {
+        this.reset(uint8);
+        return this.val();
+    }
+    val() {
+        const byte = this.u8();
+        if (byte >= 0xe0)
+            return (byte - 0x100).toString();
+        if (byte <= 0xbf) {
+            if (byte < 0x90) {
+                if (byte <= 0b1111111)
+                    return byte.toString();
+                return this.obj(byte & 0b1111);
+            }
+            else {
+                if (byte < 0xa0)
+                    return this.arr(byte & 0b1111);
+                else
+                    return this.str(byte & 0b11111);
+            }
+        }
+        if (byte <= 0xd0) {
+            if (byte <= 0xc8) {
+                if (byte <= 0xc4) {
+                    if (byte <= 0xc2)
+                        return byte === 0xc2 ? 'false' : 'null';
+                    else
+                        return byte === 0xc4 ? this.bin(this.u8()) : 'true';
+                }
+                else {
+                    if (byte <= 0xc6)
+                        return byte === 0xc6 ? this.bin(this.u32()) : this.bin(this.u16());
+                    else
+                        return byte === 0xc8 ? this.ext(this.u16()) : this.ext(this.u8());
+                }
+            }
+            else {
+                return byte <= 0xcc
+                    ? byte <= 0xca
+                        ? byte === 0xca
+                            ? this.f32().toString()
+                            : this.ext(this.u32())
+                        : byte === 0xcc
+                            ? this.u8().toString()
+                            : this.f64().toString()
+                    : byte <= 0xce
+                        ? byte === 0xce
+                            ? this.u32().toString()
+                            : this.u16().toString()
+                        : byte === 0xd0
+                            ? this.i8().toString()
+                            : (this.u32() * 4294967296 + this.u32()).toString();
+            }
+        }
+        else if (byte <= 0xd8) {
+            return byte <= 0xd4
+                ? byte <= 0xd2
+                    ? byte === 0xd2
+                        ? this.i32().toString()
+                        : this.i16().toString()
+                    : byte === 0xd4
+                        ? this.ext(1)
+                        : (this.i32() * 4294967296 + this.i32()).toString()
+                : byte <= 0xd6
+                    ? byte === 0xd6
+                        ? this.ext(4)
+                        : this.ext(2)
+                    : byte === 0xd8
+                        ? this.ext(16)
+                        : this.ext(8);
+        }
+        else {
+            switch (byte) {
+                case 0xd9:
+                    return this.str(this.u8());
+                case 0xda:
+                    return this.str(this.u16());
+                case 0xdb:
+                    return this.str(this.u32());
+                case 0xdc:
+                    return this.arr(this.u16());
+                case 0xdd:
+                    return this.arr(this.u32());
+                case 0xde:
+                    return this.obj(this.u16());
+                case 0xdf:
+                    return this.obj(this.u32());
+            }
+        }
+        return '';
+    }
+    str(size) {
+        const uint8 = this.uint8;
+        const end = this.x + size;
+        let x = this.x;
+        let str = '';
+        while (x < end) {
+            const b1 = uint8[x++];
+            if ((b1 & 0x80) === 0) {
+                str += String.fromCharCode(b1);
+                continue;
+            }
+            else if ((b1 & 0xe0) === 0xc0) {
+                str += String.fromCharCode(((b1 & 0x1f) << 6) | (uint8[x++] & 0x3f));
+            }
+            else if ((b1 & 0xf0) === 0xe0) {
+                str += String.fromCharCode(((b1 & 0x1f) << 12) | ((uint8[x++] & 0x3f) << 6) | (uint8[x++] & 0x3f));
+            }
+            else if ((b1 & 0xf8) === 0xf0) {
+                const b2 = uint8[x++] & 0x3f;
+                const b3 = uint8[x++] & 0x3f;
+                const b4 = uint8[x++] & 0x3f;
+                let code = ((b1 & 0x07) << 0x12) | (b2 << 0x0c) | (b3 << 0x06) | b4;
+                if (code > 0xffff) {
+                    code -= 0x10000;
+                    str += String.fromCharCode(((code >>> 10) & 0x3ff) | 0xd800);
+                    code = 0xdc00 | (code & 0x3ff);
+                }
+                str += String.fromCharCode(code);
+            }
+            else {
+                str += String.fromCharCode(b1);
+            }
+        }
+        this.x = end;
+        return (0, asString_1.asString)(str);
+    }
+    obj(size) {
+        let str = '{';
+        for (let i = 0; i < size; i++) {
+            if (i > 0)
+                str += ',';
+            str += this.key();
+            str += ':';
+            str += this.val();
+        }
+        return (str + '}');
+    }
+    key() {
+        return this.val();
+    }
+    arr(size) {
+        let str = '[';
+        for (let i = 0; i < size; i++) {
+            if (i > 0)
+                str += ',';
+            str += this.val();
+        }
+        return (str + ']');
+    }
+    bin(size) {
+        const end = this.x + size;
+        const buf = this.uint8.subarray(this.x, end);
+        this.x = end;
+        return '"' + (0, toDataUri_1.toDataUri)(buf) + '"';
+    }
+    ext(size) {
+        const ext = this.u8();
+        const end = this.x + size;
+        const buf = this.uint8.subarray(this.x, end);
+        this.x = end;
+        return '"' + (0, toDataUri_1.toDataUri)(buf, { ext }) + '"';
+    }
+    u8() {
+        return this.view.getUint8(this.x++);
+    }
+    u16() {
+        const num = this.view.getUint16(this.x);
+        this.x += 2;
+        return num;
+    }
+    u32() {
+        const num = this.view.getUint32(this.x);
+        this.x += 4;
+        return num;
+    }
+    i8() {
+        return this.view.getInt8(this.x++);
+    }
+    i16() {
+        const num = this.view.getInt16(this.x);
+        this.x += 2;
+        return num;
+    }
+    i32() {
+        const num = this.view.getInt32(this.x);
+        this.x += 4;
+        return num;
+    }
+    f32() {
+        const pos = this.x;
+        this.x += 4;
+        return this.view.getFloat32(pos);
+    }
+    f64() {
+        const pos = this.x;
+        this.x += 8;
+        return this.view.getFloat64(pos);
+    }
+}
+exports.MsgPackToJsonConverter = MsgPackToJsonConverter;
+//# sourceMappingURL=MsgPackToJsonConverter.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const enum MSGPACK {
+    NULL = 192,
+    UNDEFINED = 193,
+    FALSE = 194,
+    TRUE = 195
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/constants.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=constants.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/msgpack/constants.ts"],"names":[],"mappings":""}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export { MsgPackEncoderFast } from './MsgPackEncoderFast';
+export { MsgPackEncoder } from './MsgPackEncoder';
+export { MsgPackEncoderStable } from './MsgPackEncoderStable';
+export { MsgPackDecoder } from './MsgPackDecoder';
+export { MsgPackDecoderFast } from './MsgPackDecoderFast';
+export { MsgPackToJsonConverter } from './MsgPackToJsonConverter';
+export { JsonPackValue } from '../JsonPackValue';
+export { JsonPackExtension } from '../JsonPackExtension';
+export { MsgPackEncoder as MessagePackEncoder } from './MsgPackEncoder';
+export { MsgPackDecoder as MessagePackDecoder } from './MsgPackDecoder';

node_modules/@jsonjoy.com/json-pack/lib/msgpack/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagePackDecoder = exports.MessagePackEncoder = exports.JsonPackExtension = exports.JsonPackValue = exports.MsgPackToJsonConverter = exports.MsgPackDecoderFast = exports.MsgPackDecoder = exports.MsgPackEncoderStable = exports.MsgPackEncoder = exports.MsgPackEncoderFast = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+var MsgPackEncoderFast_1 = require("./MsgPackEncoderFast");
+Object.defineProperty(exports, "MsgPackEncoderFast", { enumerable: true, get: function () { return MsgPackEncoderFast_1.MsgPackEncoderFast; } });
+var MsgPackEncoder_1 = require("./MsgPackEncoder");
+Object.defineProperty(exports, "MsgPackEncoder", { enumerable: true, get: function () { return MsgPackEncoder_1.MsgPackEncoder; } });
+var MsgPackEncoderStable_1 = require("./MsgPackEncoderStable");
+Object.defineProperty(exports, "MsgPackEncoderStable", { enumerable: true, get: function () { return MsgPackEncoderStable_1.MsgPackEncoderStable; } });
+var MsgPackDecoder_1 = require("./MsgPackDecoder");
+Object.defineProperty(exports, "MsgPackDecoder", { enumerable: true, get: function () { return MsgPackDecoder_1.MsgPackDecoder; } });
+var MsgPackDecoderFast_1 = require("./MsgPackDecoderFast");
+Object.defineProperty(exports, "MsgPackDecoderFast", { enumerable: true, get: function () { return MsgPackDecoderFast_1.MsgPackDecoderFast; } });
+var MsgPackToJsonConverter_1 = require("./MsgPackToJsonConverter");
+Object.defineProperty(exports, "MsgPackToJsonConverter", { enumerable: true, get: function () { return MsgPackToJsonConverter_1.MsgPackToJsonConverter; } });
+var JsonPackValue_1 = require("../JsonPackValue");
+Object.defineProperty(exports, "JsonPackValue", { enumerable: true, get: function () { return JsonPackValue_1.JsonPackValue; } });
+var JsonPackExtension_1 = require("../JsonPackExtension");
+Object.defineProperty(exports, "JsonPackExtension", { enumerable: true, get: function () { return JsonPackExtension_1.JsonPackExtension; } });
+var MsgPackEncoder_2 = require("./MsgPackEncoder");
+Object.defineProperty(exports, "MessagePackEncoder", { enumerable: true, get: function () { return MsgPackEncoder_2.MsgPackEncoder; } });
+var MsgPackDecoder_2 = require("./MsgPackDecoder");
+Object.defineProperty(exports, "MessagePackDecoder", { enumerable: true, get: function () { return MsgPackDecoder_2.MsgPackDecoder; } });
+//# sourceMappingURL=index.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/msgpack/index.ts"],"names":[],"mappings":";;;;AA8BA,kDAAwB;AACxB,2DAAwD;AAAhD,wHAAA,kBAAkB,OAAA;AAC1B,mDAAgD;AAAxC,gHAAA,cAAc,OAAA;AACtB,+DAA4D;AAApD,4HAAA,oBAAoB,OAAA;AAC5B,mDAAgD;AAAxC,gHAAA,cAAc,OAAA;AACtB,2DAAwD;AAAhD,wHAAA,kBAAkB,OAAA;AAC1B,mEAAgE;AAAxD,gIAAA,sBAAsB,OAAA;AAC9B,kDAA+C;AAAvC,8GAAA,aAAa,OAAA;AACrB,0DAAuD;AAA/C,sHAAA,iBAAiB,OAAA;AAGzB,mDAAsE;AAA9D,oHAAA,cAAc,OAAsB;AAC5C,mDAAsE;AAA9D,oHAAA,cAAc,OAAsB"}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/shallow-read.d.ts

@@ -0,0 +1,6 @@
+import type { Path } from '@jsonjoy.com/json-pointer';
+import type { MsgPackDecoder } from './MsgPackDecoder';
+type Decoder = Pick<MsgPackDecoder, 'readObjHdr' | 'readStrHdr' | 'readArrHdr' | 'skipAny'>;
+type Fn = (decoder: Decoder) => number;
+export declare const genShallowReader: (path: Path) => Fn;
+export {};

node_modules/@jsonjoy.com/json-pack/lib/msgpack/shallow-read.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genShallowReader = void 0;
+const Codegen_1 = require("@jsonjoy.com/codegen/lib/Codegen");
+const toUtf8 = (str) => {
+    const arr = [];
+    const length = str.length;
+    let curr = 0;
+    while (curr < length) {
+        let value = str.charCodeAt(curr++);
+        if ((value & 0xffffff80) === 0) {
+            arr.push(value);
+            continue;
+        }
+        else if ((value & 0xfffff800) === 0) {
+            arr.push(((value >> 6) & 0x1f) | 0xc0);
+        }
+        else {
+            if (value >= 0xd800 && value <= 0xdbff) {
+                if (curr < length) {
+                    const extra = str.charCodeAt(curr);
+                    if ((extra & 0xfc00) === 0xdc00) {
+                        curr++;
+                        value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                    }
+                }
+            }
+            if ((value & 0xffff0000) === 0) {
+                arr.push(((value >> 12) & 0x0f) | 0xe0);
+                arr.push(((value >> 6) & 0x3f) | 0x80);
+            }
+            else {
+                arr.push(((value >> 18) & 0x07) | 0xf0);
+                arr.push(((value >> 12) & 0x3f) | 0x80);
+                arr.push(((value >> 6) & 0x3f) | 0x80);
+            }
+        }
+        arr.push((value & 0x3f) | 0x80);
+    }
+    return arr;
+};
+const genShallowReader = (path) => {
+    const codegen = new Codegen_1.Codegen({
+        args: ['dec'],
+        name: 'readShallow',
+        prologue: 'var r = dec.reader;',
+        epilogue: 'return r.x;',
+    });
+    for (let i = 0; i < path.length; i++) {
+        const step = path[i];
+        switch (typeof step) {
+            case 'string': {
+                const rObj = codegen.getRegister();
+                const rIter = codegen.getRegister();
+                const rFound = codegen.getRegister();
+                codegen.js(`var ${rObj} = dec.readObjHdr();`);
+                codegen.js(`var ${rFound} = false;`);
+                codegen.js(`for(var ${rIter} = 0; ${rIter} < ${rObj}; ${rIter}++) {`);
+                const utf8Arr = toUtf8(step);
+                const length = utf8Arr.length;
+                const rKey = codegen.getRegister();
+                codegen.js(`var ${rKey} = dec.readStrHdr();`);
+                codegen.js(`if (${rKey} !== ${length}) { r.x += ${rKey}; dec.skipAny(); continue; };`);
+                while (utf8Arr.length > 0) {
+                    if (utf8Arr.length >= 4) {
+                        const word = utf8Arr.splice(0, 4);
+                        const utf8Chunk = '0x' + word.map((x) => x.toString(16)).join('');
+                        codegen.js(`if (r.u32() !== ${utf8Chunk}) { ${utf8Arr.length ? `r.x += ${utf8Arr.length}; ` : ''}dec.skipAny(); continue; }`);
+                    }
+                    else if (utf8Arr.length >= 2) {
+                        const word = utf8Arr.splice(0, 2);
+                        const utf8Chunk = '0x' + word.map((x) => x.toString(16)).join('');
+                        codegen.js(`if (r.u16() !== ${utf8Chunk}) { ${utf8Arr.length ? `r.x += ${utf8Arr.length}; ` : ''}dec.skipAny(); continue; }`);
+                    }
+                    else {
+                        const [octet] = utf8Arr.splice(0, 1);
+                        codegen.js(`if (r.u8() !== ${octet}) { ${utf8Arr.length ? `r.x += ${utf8Arr.length}; ` : ''}dec.skipAny(); continue; }`);
+                    }
+                }
+                codegen.js(`${rFound} = true;`);
+                codegen.js(`break;`);
+                codegen.js(`}`);
+                codegen.js(`if (!${rFound}) throw new Error('KEY_NOT_FOUND');`);
+                break;
+            }
+            case 'number': {
+                const rObj = codegen.getRegister();
+                codegen.js(`var ${rObj} = dec.readArrHdr();`);
+                codegen.js(`if(${rObj} <= ${step}) throw new Error('INDEX_OUT_OF_BOUNDS');`);
+                for (let i = 0; i < step; i++)
+                    codegen.js(`dec.skipAny();`);
+                break;
+            }
+            default: {
+                throw new Error('INVALID_PATH_STEP');
+            }
+        }
+    }
+    return codegen.compile();
+};
+exports.genShallowReader = genShallowReader;
+//# sourceMappingURL=shallow-read.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/shallow-read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shallow-read.js","sourceRoot":"","sources":["../../src/msgpack/shallow-read.ts"],"names":[],"mappings":"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"}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/types.d.ts

@@ -0,0 +1,15 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+export type MsgPack<T> = Uint8Array & {
+    __BRAND__: 'msgpack';
+    __TYPE__: T;
+};
+export interface IMessagePackEncoder {
+    writer: IWriter & IWriterGrowable;
+    encodeAny(value: unknown): void;
+    encodeNumber(num: number): void;
+    encodeString(str: string): void;
+    encodeArray(arr: unknown[]): void;
+    encodeArrayHeader(length: number): void;
+    encodeObject(obj: Record<string, unknown>): void;
+    encodeObjectHeader(length: number): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/msgpack/types.ts"],"names":[],"mappings":""}

node_modules/@jsonjoy.com/json-pack/lib/msgpack/util.d.ts

@@ -0,0 +1,11 @@
+import { MsgPackEncoderFast } from './MsgPackEncoderFast';
+import { MsgPackEncoder } from './MsgPackEncoder';
+import { MsgPackDecoderFast } from './MsgPackDecoderFast';
+import { MsgPack } from './types';
+export declare const encoder: MsgPackEncoderFast<import("@jsonjoy.com/buffers").IWriter & import("@jsonjoy.com/buffers").IWriterGrowable>;
+export declare const encoderFull: MsgPackEncoder<import("@jsonjoy.com/buffers").IWriter & import("@jsonjoy.com/buffers").IWriterGrowable>;
+export declare const decoder: MsgPackDecoderFast<import("@jsonjoy.com/buffers/lib/Reader").Reader>;
+export declare const encode: <T>(data: T) => MsgPack<T>;
+export declare const encodeFull: <T>(data: T) => MsgPack<T>;
+export declare const decode: <T>(blob: MsgPack<T>) => T;
+export type { MsgPack };

node_modules/@jsonjoy.com/json-pack/lib/msgpack/util.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encodeFull = exports.encode = exports.decoder = exports.encoderFull = exports.encoder = void 0;
+const MsgPackEncoderFast_1 = require("./MsgPackEncoderFast");
+const MsgPackEncoder_1 = require("./MsgPackEncoder");
+const MsgPackDecoderFast_1 = require("./MsgPackDecoderFast");
+exports.encoder = new MsgPackEncoderFast_1.MsgPackEncoderFast();
+exports.encoderFull = new MsgPackEncoder_1.MsgPackEncoder();
+exports.decoder = new MsgPackDecoderFast_1.MsgPackDecoderFast();
+const encode = (data) => exports.encoder.encode(data);
+exports.encode = encode;
+const encodeFull = (data) => exports.encoderFull.encode(data);
+exports.encodeFull = encodeFull;
+const decode = (blob) => exports.decoder.decode(blob);
+exports.decode = decode;
+//# sourceMappingURL=util.js.map

node_modules/@jsonjoy.com/json-pack/lib/msgpack/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../../src/msgpack/util.ts"],"names":[],"mappings":";;;AAAA,6DAAwD;AACxD,qDAAgD;AAChD,6DAAwD;AAG3C,QAAA,OAAO,GAAG,IAAI,uCAAkB,EAAE,CAAC;AACnC,QAAA,WAAW,GAAG,IAAI,+BAAc,EAAE,CAAC;AACnC,QAAA,OAAO,GAAG,IAAI,uCAAkB,EAAE,CAAC;AAEzC,MAAM,MAAM,GAAG,CAAI,IAAO,EAAc,EAAE,CAAC,eAAO,CAAC,MAAM,CAAC,IAAI,CAAe,CAAC;AAAxE,QAAA,MAAM,UAAkE;AAC9E,MAAM,UAAU,GAAG,CAAI,IAAO,EAAc,EAAE,CAAC,mBAAW,CAAC,MAAM,CAAC,IAAI,CAAe,CAAC;AAAhF,QAAA,UAAU,cAAsE;AACtF,MAAM,MAAM,GAAG,CAAI,IAAgB,EAAK,EAAE,CAAC,eAAO,CAAC,MAAM,CAAC,IAAI,CAAM,CAAC;AAA/D,QAAA,MAAM,UAAyD"}