Initial commit

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

@@ -0,0 +1,5 @@
+export declare class JsonPackExtension<T = Uint8Array> {
+    readonly tag: number;
+    readonly val: T;
+    constructor(tag: number, val: T);
+}

node_modules/@jsonjoy.com/json-pack/lib/JsonPackExtension.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonPackExtension = void 0;
+class JsonPackExtension {
+    constructor(tag, val) {
+        this.tag = tag;
+        this.val = val;
+    }
+}
+exports.JsonPackExtension = JsonPackExtension;
+//# sourceMappingURL=JsonPackExtension.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JsonPackExtension.js","sourceRoot":"","sources":["../src/JsonPackExtension.ts"],"names":[],"mappings":";;;AAQA,MAAa,iBAAiB;IAC5B,YACkB,GAAW,EACX,GAAM;QADN,QAAG,GAAH,GAAG,CAAQ;QACX,QAAG,GAAH,GAAG,CAAG;IACrB,CAAC;CACL;AALD,8CAKC"}

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

@@ -0,0 +1,4 @@
+export declare class JsonPackValue<T = Uint8Array> {
+    readonly val: T;
+    constructor(val: T);
+}

node_modules/@jsonjoy.com/json-pack/lib/JsonPackValue.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonPackValue = void 0;
+class JsonPackValue {
+    constructor(val) {
+        this.val = val;
+    }
+}
+exports.JsonPackValue = JsonPackValue;
+//# sourceMappingURL=JsonPackValue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JsonPackValue.js","sourceRoot":"","sources":["../src/JsonPackValue.ts"],"names":[],"mappings":";;;AAUA,MAAa,aAAa;IACxB,YAA4B,GAAM;QAAN,QAAG,GAAH,GAAG,CAAG;IAAG,CAAC;CACvC;AAFD,sCAEC"}

node_modules/@jsonjoy.com/json-pack/lib/bencode/BencodeDecoder.d.ts

@@ -0,0 +1,18 @@
+import { Reader } from '@jsonjoy.com/util/lib/buffers/Reader';
+import type { BinaryJsonDecoder, PackValue } from '../types';
+export declare class BencodeDecoder implements BinaryJsonDecoder {
+    reader: Reader;
+    read(uint8: Uint8Array): unknown;
+    decode(uint8: Uint8Array): unknown;
+    readAny(): unknown;
+    readNull(): null;
+    readUndef(): undefined;
+    readTrue(): true;
+    readFalse(): false;
+    readBool(): unknown;
+    readNum(): number;
+    readStr(): string;
+    readBin(): Uint8Array;
+    readArr(): unknown[];
+    readObj(): PackValue | Record<string, unknown> | unknown;
+}

node_modules/@jsonjoy.com/json-pack/lib/bencode/BencodeDecoder.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BencodeDecoder = void 0;
+const Reader_1 = require("@jsonjoy.com/util/lib/buffers/Reader");
+class BencodeDecoder {
+    constructor() {
+        this.reader = new Reader_1.Reader();
+    }
+    read(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    readAny() {
+        const reader = this.reader;
+        const x = reader.x;
+        const uint8 = reader.uint8;
+        const char = uint8[x];
+        switch (char) {
+            case 0x69:
+                return this.readNum();
+            case 0x64:
+                return this.readObj();
+            case 0x6c:
+                return this.readArr();
+            case 0x66:
+                return this.readFalse();
+            case 0x74:
+                return this.readTrue();
+            case 110:
+                return this.readNull();
+            case 117:
+                return this.readUndef();
+            default:
+                if (char >= 48 && char <= 57)
+                    return this.readBin();
+        }
+        throw new Error('INVALID_BENCODE');
+    }
+    readNull() {
+        if (this.reader.u8() !== 0x6e)
+            throw new Error('INVALID_BENCODE');
+        return null;
+    }
+    readUndef() {
+        if (this.reader.u8() !== 117)
+            throw new Error('INVALID_BENCODE');
+        return undefined;
+    }
+    readTrue() {
+        if (this.reader.u8() !== 0x74)
+            throw new Error('INVALID_BENCODE');
+        return true;
+    }
+    readFalse() {
+        if (this.reader.u8() !== 0x66)
+            throw new Error('INVALID_BENCODE');
+        return false;
+    }
+    readBool() {
+        const reader = this.reader;
+        switch (reader.uint8[reader.x]) {
+            case 0x66:
+                return this.readFalse();
+            case 0x74:
+                return this.readTrue();
+            default:
+                throw new Error('INVALID_BENCODE');
+        }
+    }
+    readNum() {
+        const reader = this.reader;
+        const startChar = reader.u8();
+        if (startChar !== 0x69)
+            throw new Error('INVALID_BENCODE');
+        const u8 = reader.uint8;
+        let x = reader.x;
+        let numStr = '';
+        let c = u8[x++];
+        let i = 0;
+        while (c !== 0x65) {
+            numStr += String.fromCharCode(c);
+            c = u8[x++];
+            if (i > 25)
+                throw new Error('INVALID_BENCODE');
+            i++;
+        }
+        if (!numStr)
+            throw new Error('INVALID_BENCODE');
+        reader.x = x;
+        return +numStr;
+    }
+    readStr() {
+        const bin = this.readBin();
+        return new TextDecoder().decode(bin);
+    }
+    readBin() {
+        const reader = this.reader;
+        const u8 = reader.uint8;
+        let lenStr = '';
+        let x = reader.x;
+        let c = u8[x++];
+        let i = 0;
+        while (c !== 0x3a) {
+            if (c < 48 || c > 57)
+                throw new Error('INVALID_BENCODE');
+            lenStr += String.fromCharCode(c);
+            c = u8[x++];
+            if (i > 10)
+                throw new Error('INVALID_BENCODE');
+            i++;
+        }
+        reader.x = x;
+        const len = +lenStr;
+        const bin = reader.buf(len);
+        return bin;
+    }
+    readArr() {
+        const reader = this.reader;
+        if (reader.u8() !== 0x6c)
+            throw new Error('INVALID_BENCODE');
+        const arr = [];
+        const uint8 = reader.uint8;
+        while (true) {
+            const char = uint8[reader.x];
+            if (char === 0x65) {
+                reader.x++;
+                return arr;
+            }
+            arr.push(this.readAny());
+        }
+    }
+    readObj() {
+        const reader = this.reader;
+        if (reader.u8() !== 0x64)
+            throw new Error('INVALID_BENCODE');
+        const obj = {};
+        const uint8 = reader.uint8;
+        while (true) {
+            const char = uint8[reader.x];
+            if (char === 0x65) {
+                reader.x++;
+                return obj;
+            }
+            const key = this.readStr();
+            if (key === '__proto__')
+                throw new Error('INVALID_KEY');
+            obj[key] = this.readAny();
+        }
+    }
+}
+exports.BencodeDecoder = BencodeDecoder;
+//# sourceMappingURL=BencodeDecoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/bencode/BencodeDecoder.js.map

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

node_modules/@jsonjoy.com/json-pack/lib/bencode/BencodeEncoder.d.ts

@@ -0,0 +1,24 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/util/lib/buffers';
+import type { BinaryJsonEncoder } from '../types';
+export declare class BencodeEncoder implements BinaryJsonEncoder {
+    readonly writer: IWriter & IWriterGrowable;
+    constructor(writer: IWriter & IWriterGrowable);
+    encode(value: unknown): Uint8Array;
+    writeUnknown(value: unknown): void;
+    writeAny(value: unknown): void;
+    writeNull(): void;
+    writeUndef(): void;
+    writeBoolean(bool: boolean): void;
+    writeNumber(num: number): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    writeFloat(float: number): void;
+    writeBigint(int: bigint): void;
+    writeBin(buf: Uint8Array): void;
+    writeStr(str: string): void;
+    writeAsciiStr(str: string): void;
+    writeArr(arr: unknown[]): void;
+    writeObj(obj: Record<string, unknown>): void;
+    writeMap(obj: Map<unknown, unknown>): void;
+    writeSet(set: Set<unknown>): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/bencode/BencodeEncoder.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BencodeEncoder = void 0;
+const utf8_1 = require("@jsonjoy.com/util/lib/strings/utf8");
+const insertion_1 = require("@jsonjoy.com/util/lib/sort/insertion");
+class BencodeEncoder {
+    constructor(writer) {
+        this.writer = writer;
+    }
+    encode(value) {
+        const writer = this.writer;
+        writer.reset();
+        this.writeAny(value);
+        return writer.flush();
+    }
+    writeUnknown(value) {
+        this.writeNull();
+    }
+    writeAny(value) {
+        switch (typeof value) {
+            case 'boolean':
+                return this.writeBoolean(value);
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                return this.writeStr(value);
+            case 'object': {
+                if (value === null)
+                    return this.writeNull();
+                const constructor = value.constructor;
+                switch (constructor) {
+                    case Object:
+                        return this.writeObj(value);
+                    case Array:
+                        return this.writeArr(value);
+                    case Uint8Array:
+                        return this.writeBin(value);
+                    case Map:
+                        return this.writeMap(value);
+                    case Set:
+                        return this.writeSet(value);
+                    default:
+                        return this.writeUnknown(value);
+                }
+            }
+            case 'bigint': {
+                return this.writeBigint(value);
+            }
+            case 'undefined': {
+                return this.writeUndef();
+            }
+            default:
+                return this.writeUnknown(value);
+        }
+    }
+    writeNull() {
+        this.writer.u8(110);
+    }
+    writeUndef() {
+        this.writer.u8(117);
+    }
+    writeBoolean(bool) {
+        this.writer.u8(bool ? 0x74 : 0x66);
+    }
+    writeNumber(num) {
+        const writer = this.writer;
+        writer.u8(0x69);
+        writer.ascii(Math.round(num) + '');
+        writer.u8(0x65);
+    }
+    writeInteger(int) {
+        const writer = this.writer;
+        writer.u8(0x69);
+        writer.ascii(int + '');
+        writer.u8(0x65);
+    }
+    writeUInteger(uint) {
+        this.writeInteger(uint);
+    }
+    writeFloat(float) {
+        this.writeNumber(float);
+    }
+    writeBigint(int) {
+        const writer = this.writer;
+        writer.u8(0x69);
+        writer.ascii(int + '');
+        writer.u8(0x65);
+    }
+    writeBin(buf) {
+        const writer = this.writer;
+        const length = buf.length;
+        writer.ascii(length + '');
+        writer.u8(0x3a);
+        writer.buf(buf, length);
+    }
+    writeStr(str) {
+        const writer = this.writer;
+        const length = (0, utf8_1.utf8Size)(str);
+        writer.ascii(length + '');
+        writer.u8(0x3a);
+        writer.ensureCapacity(length);
+        writer.utf8(str);
+    }
+    writeAsciiStr(str) {
+        const writer = this.writer;
+        writer.ascii(str.length + '');
+        writer.u8(0x3a);
+        writer.ascii(str);
+    }
+    writeArr(arr) {
+        const writer = this.writer;
+        writer.u8(0x6c);
+        const length = arr.length;
+        for (let i = 0; i < length; i++)
+            this.writeAny(arr[i]);
+        writer.u8(0x65);
+    }
+    writeObj(obj) {
+        const writer = this.writer;
+        writer.u8(0x64);
+        const keys = (0, insertion_1.sort)(Object.keys(obj));
+        const length = keys.length;
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key);
+            this.writeAny(obj[key]);
+        }
+        writer.u8(0x65);
+    }
+    writeMap(obj) {
+        const writer = this.writer;
+        writer.u8(0x64);
+        const keys = (0, insertion_1.sort)([...obj.keys()]);
+        const length = keys.length;
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            this.writeStr(key + '');
+            this.writeAny(obj.get(key));
+        }
+        writer.u8(0x65);
+    }
+    writeSet(set) {
+        this.writeArr([...set.values()]);
+    }
+}
+exports.BencodeEncoder = BencodeEncoder;
+//# sourceMappingURL=BencodeEncoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/bencode/BencodeEncoder.js.map

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

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

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './BencodeEncoder';
+export * from './BencodeDecoder';

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./BencodeEncoder"), exports);
+tslib_1.__exportStar(require("./BencodeDecoder"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bencode/index.ts"],"names":[],"mappings":";;;AAAA,kDAAwB;AACxB,2DAAiC;AACjC,2DAAiC"}

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

@@ -0,0 +1,4 @@
+export type BencodeUint8Array<T> = Uint8Array & {
+    __BRAND__: 'bencode';
+    __TYPE__: T;
+};

node_modules/@jsonjoy.com/json-pack/lib/bencode/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/bencode/types.js.map

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

node_modules/@jsonjoy.com/json-pack/lib/bson/BsonEncoder.d.ts

@@ -0,0 +1,27 @@
+import { BsonObjectId } from './values';
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/util/lib/buffers';
+import type { BinaryJsonEncoder } from '../types';
+export declare class BsonEncoder implements BinaryJsonEncoder {
+    readonly writer: IWriter & IWriterGrowable;
+    constructor(writer: IWriter & IWriterGrowable);
+    encode(value: unknown): Uint8Array;
+    writeAny(value: unknown): void;
+    writeNull(): void;
+    writeUndef(): void;
+    writeBoolean(bool: boolean): void;
+    writeNumber(num: number): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    writeInt32(int: number): void;
+    writeInt64(int: number | bigint): void;
+    writeFloat(float: number): void;
+    writeBigInt(int: bigint): void;
+    writeBin(buf: Uint8Array): void;
+    writeStr(str: string): void;
+    writeAsciiStr(str: string): void;
+    writeArr(arr: unknown[]): void;
+    writeObj(obj: Record<string, unknown>): void;
+    writeCString(str: string): void;
+    writeObjectId(id: BsonObjectId): void;
+    writeKey(key: string, value: unknown): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/bson/BsonEncoder.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BsonEncoder = void 0;
+const values_1 = require("./values");
+class BsonEncoder {
+    constructor(writer) {
+        this.writer = writer;
+    }
+    encode(value) {
+        const writer = this.writer;
+        writer.reset();
+        this.writeAny(value);
+        return writer.flush();
+    }
+    writeAny(value) {
+        switch (typeof value) {
+            case 'object': {
+                if (value === null)
+                    throw new Error('NOT_OBJ');
+                return this.writeObj(value);
+            }
+        }
+        throw new Error('NOT_OBJ');
+    }
+    writeNull() {
+        throw new Error('Method not implemented.');
+    }
+    writeUndef() {
+        throw new Error('Method not implemented.');
+    }
+    writeBoolean(bool) {
+        throw new Error('Method not implemented.');
+    }
+    writeNumber(num) {
+        throw new Error('Method not implemented.');
+    }
+    writeInteger(int) {
+        throw new Error('Method not implemented.');
+    }
+    writeUInteger(uint) {
+        throw new Error('Method not implemented.');
+    }
+    writeInt32(int) {
+        const writer = this.writer;
+        writer.ensureCapacity(4);
+        writer.view.setInt32(writer.x, int, true);
+        writer.x += 4;
+    }
+    writeInt64(int) {
+        const writer = this.writer;
+        writer.ensureCapacity(8);
+        writer.view.setBigInt64(writer.x, BigInt(int), true);
+        writer.x += 8;
+    }
+    writeFloat(float) {
+        const writer = this.writer;
+        writer.ensureCapacity(4);
+        writer.view.setFloat64(writer.x, float, true);
+        writer.x += 8;
+    }
+    writeBigInt(int) {
+        throw new Error('Method not implemented.');
+    }
+    writeBin(buf) {
+        const length = buf.length;
+        this.writeInt32(length);
+        const writer = this.writer;
+        writer.u8(0);
+        writer.buf(buf, length);
+    }
+    writeStr(str) {
+        const writer = this.writer;
+        const length = str.length;
+        const maxSize = 4 + 1 + 4 * length;
+        writer.ensureCapacity(maxSize);
+        const x = writer.x;
+        this.writeInt32(length + 1);
+        const bytesWritten = writer.utf8(str);
+        writer.u8(0);
+        if (bytesWritten !== length) {
+            writer.view.setInt32(x, bytesWritten + 1, true);
+        }
+    }
+    writeAsciiStr(str) {
+        throw new Error('Method not implemented.');
+    }
+    writeArr(arr) {
+        this.writeObj(arr);
+    }
+    writeObj(obj) {
+        const writer = this.writer;
+        writer.ensureCapacity(8);
+        const x0 = writer.x0;
+        const dx = writer.x - x0;
+        writer.x += 4;
+        const keys = Object.keys(obj);
+        const length = keys.length;
+        for (let i = 0; i < length; i++) {
+            const key = keys[i];
+            const value = obj[key];
+            this.writeKey(key, value);
+        }
+        writer.u8(0);
+        const x = writer.x0 + dx;
+        const size = writer.x - x;
+        writer.view.setUint32(x, size, true);
+    }
+    writeCString(str) {
+        const writer = this.writer;
+        const length = str.length;
+        writer.ensureCapacity(1 + 4 * length);
+        const uint8 = writer.uint8;
+        let x = writer.x;
+        let pos = 0;
+        while (pos < length) {
+            let value = str.charCodeAt(pos++);
+            if ((value & 0xffffff80) === 0) {
+                if (!value)
+                    break;
+                uint8[x++] = value;
+                continue;
+            }
+            else if ((value & 0xfffff800) === 0) {
+                const octet = ((value >> 6) & 0x1f) | 0xc0;
+                if (!octet)
+                    break;
+                uint8[x++] = octet;
+            }
+            else {
+                if (value >= 0xd800 && value <= 0xdbff) {
+                    if (pos < length) {
+                        const extra = str.charCodeAt(pos);
+                        if ((extra & 0xfc00) === 0xdc00) {
+                            pos++;
+                            value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                        }
+                    }
+                }
+                if ((value & 0xffff0000) === 0) {
+                    const octet1 = ((value >> 12) & 0x0f) | 0xe0;
+                    const octet2 = ((value >> 6) & 0x3f) | 0x80;
+                    if (!octet1 || !octet2)
+                        throw new Error('INVALID_CSTRING');
+                    uint8[x++] = octet1;
+                    uint8[x++] = octet2;
+                }
+                else {
+                    const octet1 = ((value >> 18) & 0x07) | 0xf0;
+                    const octet2 = ((value >> 12) & 0x3f) | 0x80;
+                    const octet3 = ((value >> 6) & 0x3f) | 0x80;
+                    if (!octet1 || !octet2 || !octet3)
+                        throw new Error('INVALID_CSTRING');
+                    uint8[x++] = octet1;
+                    uint8[x++] = octet2;
+                    uint8[x++] = octet3;
+                }
+            }
+            const octet = (value & 0x3f) | 0x80;
+            if (!octet)
+                break;
+            uint8[x++] = octet;
+        }
+        uint8[x++] = 0;
+        writer.x = x;
+    }
+    writeObjectId(id) {
+        const writer = this.writer;
+        writer.ensureCapacity(12);
+        const uint8 = writer.uint8;
+        const x = writer.x;
+        const { timestamp, process, counter } = id;
+        uint8[x + 0] = timestamp >>> 24;
+        uint8[x + 1] = (timestamp >>> 16) & 0xff;
+        uint8[x + 2] = (timestamp >>> 8) & 0xff;
+        uint8[x + 3] = timestamp & 0xff;
+        uint8[x + 4] = process & 0xff;
+        uint8[x + 5] = (process >>> 8) & 0xff;
+        uint8[x + 6] = (process >>> 16) & 0xff;
+        uint8[x + 7] = (process >>> 24) & 0xff;
+        let lo32 = process | 0;
+        if (lo32 < 0)
+            lo32 += 4294967296;
+        const hi32 = (process - lo32) / 4294967296;
+        uint8[x + 8] = hi32 & 0xff;
+        uint8[x + 9] = counter >>> 16;
+        uint8[x + 10] = (counter >>> 8) & 0xff;
+        uint8[x + 11] = counter & 0xff;
+        writer.x += 12;
+    }
+    writeKey(key, value) {
+        const writer = this.writer;
+        switch (typeof value) {
+            case 'number': {
+                const isFloat = Math.floor(value) !== value;
+                if (isFloat) {
+                    writer.u8(0x01);
+                    this.writeCString(key);
+                    this.writeFloat(value);
+                    break;
+                }
+                if (value <= 2147483647 && value >= -2147483648) {
+                    writer.u8(0x10);
+                    this.writeCString(key);
+                    this.writeInt32(value);
+                    break;
+                }
+                writer.u8(0x12);
+                this.writeCString(key);
+                this.writeInt64(value);
+                break;
+            }
+            case 'string': {
+                writer.u8(0x02);
+                this.writeCString(key);
+                this.writeStr(value);
+                break;
+            }
+            case 'object': {
+                if (value === null) {
+                    writer.u8(0x0a);
+                    this.writeCString(key);
+                    break;
+                }
+                const constructor = value.constructor;
+                switch (constructor) {
+                    case Object: {
+                        writer.u8(0x03);
+                        this.writeCString(key);
+                        this.writeObj(value);
+                        break;
+                    }
+                    case Array: {
+                        writer.u8(0x04);
+                        this.writeCString(key);
+                        this.writeObj(value);
+                        break;
+                    }
+                    case Uint8Array: {
+                        writer.u8(0x05);
+                        this.writeCString(key);
+                        this.writeBin(value);
+                        break;
+                    }
+                    case values_1.BsonObjectId: {
+                        writer.u8(0x07);
+                        this.writeCString(key);
+                        this.writeObjectId(value);
+                        break;
+                    }
+                    case Date: {
+                        writer.u8(0x09);
+                        this.writeCString(key);
+                        writer.ensureCapacity(8);
+                        writer.view.setBigUint64(writer.x, BigInt(value.getTime()), true);
+                        writer.x += 8;
+                        break;
+                    }
+                    case RegExp: {
+                        writer.u8(0x0b);
+                        this.writeCString(key);
+                        this.writeCString(value.source);
+                        this.writeCString(value.flags);
+                        break;
+                    }
+                    case values_1.BsonDbPointer: {
+                        writer.u8(0x0c);
+                        this.writeCString(key);
+                        const pointer = value;
+                        this.writeStr(pointer.name);
+                        this.writeObjectId(pointer.id);
+                        break;
+                    }
+                    case values_1.BsonJavascriptCode: {
+                        writer.u8(0x0d);
+                        this.writeCString(key);
+                        this.writeStr(value.code);
+                        break;
+                    }
+                    case values_1.BsonInt32: {
+                        writer.u8(0x10);
+                        this.writeCString(key);
+                        this.writeInt32(value.value);
+                        break;
+                    }
+                    case values_1.BsonInt64: {
+                        writer.u8(0x12);
+                        this.writeCString(key);
+                        this.writeInt64(value.value);
+                        break;
+                    }
+                    case values_1.BsonFloat: {
+                        writer.u8(0x01);
+                        this.writeCString(key);
+                        this.writeFloat(value.value);
+                        break;
+                    }
+                    case values_1.BsonTimestamp: {
+                        writer.u8(0x11);
+                        this.writeCString(key);
+                        const ts = value;
+                        this.writeInt32(ts.increment);
+                        this.writeInt32(ts.timestamp);
+                        break;
+                    }
+                    case values_1.BsonDecimal128: {
+                        writer.u8(0x13);
+                        this.writeCString(key);
+                        const dec = value;
+                        if (dec.data.length !== 16)
+                            throw new Error('INVALID_DECIMAL128');
+                        writer.buf(dec.data, 16);
+                        break;
+                    }
+                    case values_1.BsonMinKey: {
+                        writer.u8(0xff);
+                        this.writeCString(key);
+                        break;
+                    }
+                    case values_1.BsonMaxKey: {
+                        writer.u8(0x7f);
+                        this.writeCString(key);
+                        break;
+                    }
+                    case values_1.BsonBinary: {
+                        writer.u8(0x05);
+                        this.writeCString(key);
+                        const bin = value;
+                        const length = bin.data.length;
+                        this.writeInt32(length);
+                        writer.u8(bin.subtype);
+                        writer.buf(bin.data, length);
+                        break;
+                    }
+                    default: {
+                        writer.u8(0x03);
+                        this.writeCString(key);
+                        this.writeObj(value);
+                        break;
+                    }
+                }
+                break;
+            }
+            case 'boolean': {
+                writer.u8(0x08);
+                this.writeCString(key);
+                writer.u8(+value);
+                break;
+            }
+            case 'undefined': {
+                writer.u8(0x06);
+                this.writeCString(key);
+                break;
+            }
+            case 'symbol': {
+                writer.u8(0x0e);
+                this.writeCString(key);
+                this.writeStr(value.description || '');
+                break;
+            }
+        }
+    }
+}
+exports.BsonEncoder = BsonEncoder;
+//# sourceMappingURL=BsonEncoder.js.map

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

@@ -0,0 +1,2 @@
+export * from './values';
+export * from './BsonEncoder';

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./values"), exports);
+tslib_1.__exportStar(require("./BsonEncoder"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bson/index.ts"],"names":[],"mappings":";;;AAAA,mDAAyB;AACzB,wDAA8B"}

node_modules/@jsonjoy.com/json-pack/lib/bson/values.d.ts

@@ -0,0 +1,54 @@
+export declare class BsonObjectId {
+    timestamp: number;
+    process: number;
+    counter: number;
+    constructor(timestamp: number, process: number, counter: number);
+}
+export declare class BsonDbPointer {
+    name: string;
+    id: BsonObjectId;
+    constructor(name: string, id: BsonObjectId);
+}
+export declare class BsonJavascriptCode {
+    code: string;
+    constructor(code: string);
+}
+export declare class BsonSymbol {
+    symbol: string;
+    constructor(symbol: string);
+}
+export declare class BsonJavascriptCodeWithScope {
+    code: string;
+    scope: Record<string, unknown>;
+    constructor(code: string, scope: Record<string, unknown>);
+}
+export declare class BsonInt32 {
+    value: number;
+    constructor(value: number);
+}
+export declare class BsonInt64 {
+    value: number;
+    constructor(value: number);
+}
+export declare class BsonFloat {
+    value: number;
+    constructor(value: number);
+}
+export declare class BsonTimestamp {
+    increment: number;
+    timestamp: number;
+    constructor(increment: number, timestamp: number);
+}
+export declare class BsonDecimal128 {
+    data: Uint8Array;
+    constructor(data: Uint8Array);
+}
+export declare class BsonMinKey {
+}
+export declare class BsonMaxKey {
+}
+export declare class BsonBinary {
+    subtype: number;
+    data: Uint8Array;
+    constructor(subtype: number, data: Uint8Array);
+}

node_modules/@jsonjoy.com/json-pack/lib/bson/values.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BsonBinary = exports.BsonMaxKey = exports.BsonMinKey = exports.BsonDecimal128 = exports.BsonTimestamp = exports.BsonFloat = exports.BsonInt64 = exports.BsonInt32 = exports.BsonJavascriptCodeWithScope = exports.BsonSymbol = exports.BsonJavascriptCode = exports.BsonDbPointer = exports.BsonObjectId = void 0;
+class BsonObjectId {
+    constructor(timestamp, process, counter) {
+        this.timestamp = timestamp;
+        this.process = process;
+        this.counter = counter;
+    }
+}
+exports.BsonObjectId = BsonObjectId;
+class BsonDbPointer {
+    constructor(name, id) {
+        this.name = name;
+        this.id = id;
+    }
+}
+exports.BsonDbPointer = BsonDbPointer;
+class BsonJavascriptCode {
+    constructor(code) {
+        this.code = code;
+    }
+}
+exports.BsonJavascriptCode = BsonJavascriptCode;
+class BsonSymbol {
+    constructor(symbol) {
+        this.symbol = symbol;
+    }
+}
+exports.BsonSymbol = BsonSymbol;
+class BsonJavascriptCodeWithScope {
+    constructor(code, scope) {
+        this.code = code;
+        this.scope = scope;
+    }
+}
+exports.BsonJavascriptCodeWithScope = BsonJavascriptCodeWithScope;
+class BsonInt32 {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.BsonInt32 = BsonInt32;
+class BsonInt64 {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.BsonInt64 = BsonInt64;
+class BsonFloat {
+    constructor(value) {
+        this.value = value;
+    }
+}
+exports.BsonFloat = BsonFloat;
+class BsonTimestamp {
+    constructor(increment, timestamp) {
+        this.increment = increment;
+        this.timestamp = timestamp;
+    }
+}
+exports.BsonTimestamp = BsonTimestamp;
+class BsonDecimal128 {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.BsonDecimal128 = BsonDecimal128;
+class BsonMinKey {
+}
+exports.BsonMinKey = BsonMinKey;
+class BsonMaxKey {
+}
+exports.BsonMaxKey = BsonMaxKey;
+class BsonBinary {
+    constructor(subtype, data) {
+        this.subtype = subtype;
+        this.data = data;
+    }
+}
+exports.BsonBinary = BsonBinary;
+//# sourceMappingURL=values.js.map

node_modules/@jsonjoy.com/json-pack/lib/bson/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","sourceRoot":"","sources":["../../src/bson/values.ts"],"names":[],"mappings":";;;AAAA,MAAa,YAAY;IACvB,YACS,SAAiB,EACjB,OAAe,EACf,OAAe;QAFf,cAAS,GAAT,SAAS,CAAQ;QACjB,YAAO,GAAP,OAAO,CAAQ;QACf,YAAO,GAAP,OAAO,CAAQ;IACrB,CAAC;CACL;AAND,oCAMC;AAED,MAAa,aAAa;IACxB,YACS,IAAY,EACZ,EAAgB;QADhB,SAAI,GAAJ,IAAI,CAAQ;QACZ,OAAE,GAAF,EAAE,CAAc;IACtB,CAAC;CACL;AALD,sCAKC;AAED,MAAa,kBAAkB;IAC7B,YAA0B,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;CAC3C;AAFD,gDAEC;AAED,MAAa,UAAU;IACrB,YAA0B,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IAAG,CAAC;CAC7C;AAFD,gCAEC;AAED,MAAa,2BAA2B;IACtC,YACS,IAAY,EACZ,KAA8B;QAD9B,SAAI,GAAJ,IAAI,CAAQ;QACZ,UAAK,GAAL,KAAK,CAAyB;IACpC,CAAC;CACL;AALD,kEAKC;AAED,MAAa,SAAS;IACpB,YAA0B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;CAC5C;AAFD,8BAEC;AAED,MAAa,SAAS;IACpB,YAA0B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;CAC5C;AAFD,8BAEC;AAED,MAAa,SAAS;IACpB,YAA0B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;CAC5C;AAFD,8BAEC;AAED,MAAa,aAAa;IACxB,YACS,SAAiB,EACjB,SAAiB;QADjB,cAAS,GAAT,SAAS,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAQ;IACvB,CAAC;CACL;AALD,sCAKC;AAED,MAAa,cAAc;IACzB,YAA0B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;CAC/C;AAFD,wCAEC;AAED,MAAa,UAAU;CAAG;AAA1B,gCAA0B;AAE1B,MAAa,UAAU;CAAG;AAA1B,gCAA0B;AAE1B,MAAa,UAAU;IACrB,YACS,OAAe,EACf,IAAgB;QADhB,YAAO,GAAP,OAAO,CAAQ;QACf,SAAI,GAAJ,IAAI,CAAY;IACtB,CAAC;CACL;AALD,gCAKC"}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoder.d.ts

@@ -0,0 +1,41 @@
+import { CborDecoderBase } from './CborDecoderBase';
+import { JsonPackValue } from '../JsonPackValue';
+import type { Path } from '../json-pointer';
+import type { IReader, IReaderResettable } from '@jsonjoy.com/util/lib/buffers';
+export declare class CborDecoder<R extends IReader & IReaderResettable = IReader & IReaderResettable> extends CborDecoderBase<R> {
+    readAsMap(): Map<unknown, unknown>;
+    readMap(minor: number): Map<unknown, unknown>;
+    readMapRaw(length: number): Map<unknown, unknown>;
+    readMapIndef(): Map<unknown, unknown>;
+    skipN(n: number): void;
+    skipAny(): void;
+    skipAnyRaw(octet: number): void;
+    skipMinorLen(minor: number): number;
+    skipUNint(minor: number): void;
+    skipBin(minor: number): void;
+    skipBinChunk(): void;
+    skipStr(minor: number): void;
+    skipStrChunk(): void;
+    skipArr(minor: number): void;
+    skipObj(minor: number): void;
+    skipTag(minor: number): void;
+    skipTkn(minor: number): void;
+    validate(value: Uint8Array, offset?: number, size?: number): void;
+    decodeLevel(value: Uint8Array): unknown;
+    readLevel(): unknown;
+    readPrimitiveOrVal(): unknown | JsonPackValue;
+    readAsValue(): JsonPackValue;
+    readObjLevel(minor: number): Record<string, unknown>;
+    readObjRawLevel(length: number): Record<string, unknown>;
+    readObjIndefLevel(): Record<string, unknown>;
+    readArrLevel(minor: number): unknown[];
+    readArrRawLevel(length: number): unknown[];
+    readArrIndefLevel(): unknown[];
+    readHdr(expectedMajor: number): number;
+    readStrHdr(): number;
+    readObjHdr(): number;
+    readArrHdr(): number;
+    findKey(key: string): this;
+    findIndex(index: number): this;
+    find(path: Path): this;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoder.js

@@ -0,0 +1,356 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborDecoder = void 0;
+const CborDecoderBase_1 = require("./CborDecoderBase");
+const JsonPackValue_1 = require("../JsonPackValue");
+class CborDecoder extends CborDecoderBase_1.CborDecoderBase {
+    readAsMap() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        switch (major) {
+            case 5:
+                return this.readMap(minor);
+            default:
+                throw 0;
+        }
+    }
+    readMap(minor) {
+        const length = this.readMinorLen(minor);
+        if (length >= 0)
+            return this.readMapRaw(length);
+        else
+            return this.readMapIndef();
+    }
+    readMapRaw(length) {
+        const map = new Map();
+        for (let i = 0; i < length; i++) {
+            const key = this.val();
+            const value = this.val();
+            map.set(key, value);
+        }
+        return map;
+    }
+    readMapIndef() {
+        const map = new Map();
+        while (this.reader.peak() !== 255) {
+            const key = this.val();
+            if (this.reader.peak() === 255)
+                throw 7;
+            const value = this.val();
+            map.set(key, value);
+        }
+        this.reader.x++;
+        return map;
+    }
+    skipN(n) {
+        for (let i = 0; i < n; i++)
+            this.skipAny();
+    }
+    skipAny() {
+        this.skipAnyRaw(this.reader.u8());
+    }
+    skipAnyRaw(octet) {
+        const major = octet >> 5;
+        const minor = octet & 31;
+        switch (major) {
+            case 0:
+            case 1:
+                this.skipUNint(minor);
+                break;
+            case 2:
+                this.skipBin(minor);
+                break;
+            case 3:
+                this.skipStr(minor);
+                break;
+            case 4:
+                this.skipArr(minor);
+                break;
+            case 5:
+                this.skipObj(minor);
+                break;
+            case 7:
+                this.skipTkn(minor);
+                break;
+            case 6:
+                this.skipTag(minor);
+                break;
+        }
+    }
+    skipMinorLen(minor) {
+        if (minor <= 23)
+            return minor;
+        switch (minor) {
+            case 24:
+                return this.reader.u8();
+            case 25:
+                return this.reader.u16();
+            case 26:
+                return this.reader.u32();
+            case 27:
+                return Number(this.reader.u64());
+            case 31:
+                return -1;
+            default:
+                throw 1;
+        }
+    }
+    skipUNint(minor) {
+        if (minor <= 23)
+            return;
+        switch (minor) {
+            case 24:
+                return this.reader.skip(1);
+            case 25:
+                return this.reader.skip(2);
+            case 26:
+                return this.reader.skip(4);
+            case 27:
+                return this.reader.skip(8);
+            default:
+                throw 1;
+        }
+    }
+    skipBin(minor) {
+        const length = this.skipMinorLen(minor);
+        if (length >= 0)
+            this.reader.skip(length);
+        else {
+            while (this.reader.peak() !== 255)
+                this.skipBinChunk();
+            this.reader.x++;
+        }
+    }
+    skipBinChunk() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major !== 2)
+            throw 2;
+        if (minor > 27)
+            throw 3;
+        this.skipBin(minor);
+    }
+    skipStr(minor) {
+        const length = this.skipMinorLen(minor);
+        if (length >= 0)
+            this.reader.skip(length);
+        else {
+            while (this.reader.peak() !== 255)
+                this.skipStrChunk();
+            this.reader.x++;
+        }
+    }
+    skipStrChunk() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major !== 3)
+            throw 4;
+        if (minor > 27)
+            throw 5;
+        this.skipStr(minor);
+    }
+    skipArr(minor) {
+        const length = this.skipMinorLen(minor);
+        if (length >= 0)
+            this.skipN(length);
+        else {
+            while (this.reader.peak() !== 255)
+                this.skipAny();
+            this.reader.x++;
+        }
+    }
+    skipObj(minor) {
+        const length = this.readMinorLen(minor);
+        if (length >= 0)
+            return this.skipN(length * 2);
+        else {
+            while (this.reader.peak() !== 255) {
+                this.skipAny();
+                if (this.reader.peak() === 255)
+                    throw 7;
+                this.skipAny();
+            }
+            this.reader.x++;
+        }
+    }
+    skipTag(minor) {
+        const length = this.skipMinorLen(minor);
+        if (length < 0)
+            throw 1;
+        this.skipAny();
+    }
+    skipTkn(minor) {
+        switch (minor) {
+            case 0xf8 & 31:
+                this.reader.skip(1);
+                return;
+            case 0xf9 & 31:
+                this.reader.skip(2);
+                return;
+            case 0xfa & 31:
+                this.reader.skip(4);
+                return;
+            case 0xfb & 31:
+                this.reader.skip(8);
+                return;
+        }
+        if (minor <= 23)
+            return;
+        throw 1;
+    }
+    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 8;
+    }
+    decodeLevel(value) {
+        this.reader.reset(value);
+        return this.readLevel();
+    }
+    readLevel() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        switch (major) {
+            case 4:
+                return this.readArrLevel(minor);
+            case 5:
+                return this.readObjLevel(minor);
+            default:
+                return super.readAnyRaw(octet);
+        }
+    }
+    readPrimitiveOrVal() {
+        const octet = this.reader.peak();
+        const major = octet >> 5;
+        switch (major) {
+            case 4:
+            case 5:
+                return this.readAsValue();
+            default:
+                return this.val();
+        }
+    }
+    readAsValue() {
+        const reader = this.reader;
+        const start = reader.x;
+        this.skipAny();
+        const end = reader.x;
+        return new JsonPackValue_1.JsonPackValue(reader.uint8.subarray(start, end));
+    }
+    readObjLevel(minor) {
+        const length = this.readMinorLen(minor);
+        if (length >= 0)
+            return this.readObjRawLevel(length);
+        else
+            return this.readObjIndefLevel();
+    }
+    readObjRawLevel(length) {
+        const obj = {};
+        for (let i = 0; i < length; i++) {
+            const key = this.key();
+            const value = this.readPrimitiveOrVal();
+            obj[key] = value;
+        }
+        return obj;
+    }
+    readObjIndefLevel() {
+        const obj = {};
+        while (this.reader.peak() !== 255) {
+            const key = this.key();
+            if (this.reader.peak() === 255)
+                throw 7;
+            const value = this.readPrimitiveOrVal();
+            obj[key] = value;
+        }
+        this.reader.x++;
+        return obj;
+    }
+    readArrLevel(minor) {
+        const length = this.readMinorLen(minor);
+        if (length >= 0)
+            return this.readArrRawLevel(length);
+        return this.readArrIndefLevel();
+    }
+    readArrRawLevel(length) {
+        const arr = [];
+        for (let i = 0; i < length; i++)
+            arr.push(this.readPrimitiveOrVal());
+        return arr;
+    }
+    readArrIndefLevel() {
+        const arr = [];
+        while (this.reader.peak() !== 255)
+            arr.push(this.readPrimitiveOrVal());
+        this.reader.x++;
+        return arr;
+    }
+    readHdr(expectedMajor) {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        if (major !== expectedMajor)
+            throw 0;
+        const minor = octet & 31;
+        if (minor < 24)
+            return minor;
+        switch (minor) {
+            case 24:
+                return this.reader.u8();
+            case 25:
+                return this.reader.u16();
+            case 26:
+                return this.reader.u32();
+            case 27:
+                return Number(this.reader.u64());
+            case 31:
+                return -1;
+        }
+        throw 1;
+    }
+    readStrHdr() {
+        return this.readHdr(3);
+    }
+    readObjHdr() {
+        return this.readHdr(5);
+    }
+    readArrHdr() {
+        return this.readHdr(4);
+    }
+    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 9;
+    }
+    findIndex(index) {
+        const size = this.readArrHdr();
+        if (index >= size)
+            throw 10;
+        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.CborDecoder = CborDecoder;
+//# sourceMappingURL=CborDecoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoderBase.d.ts

@@ -0,0 +1,34 @@
+import { JsonPackExtension } from '../JsonPackExtension';
+import { JsonPackValue } from '../JsonPackValue';
+import type { CachedUtf8Decoder } from '@jsonjoy.com/util/lib/buffers/utf8/CachedUtf8Decoder';
+import type { IReader, IReaderResettable } from '@jsonjoy.com/util/lib/buffers';
+import type { BinaryJsonDecoder, PackValue } from '../types';
+export declare class CborDecoderBase<R extends IReader & IReaderResettable = IReader & IReaderResettable> implements BinaryJsonDecoder {
+    reader: R;
+    readonly keyDecoder: CachedUtf8Decoder;
+    constructor(reader?: R, keyDecoder?: CachedUtf8Decoder);
+    read(uint8: Uint8Array): PackValue;
+    decode(uint8: Uint8Array): unknown;
+    val(): unknown;
+    readAnyRaw(octet: number): unknown;
+    readMinorLen(minor: number): number;
+    readUint(minor: number): number | bigint;
+    readNint(minor: number): number | bigint;
+    readBin(minor: number): Uint8Array;
+    readBinChunk(): Uint8Array;
+    readAsStr(): string;
+    readStr(minor: number): string;
+    readStrLen(minor: number): number;
+    readStrChunk(): string;
+    readArr(minor: number): unknown[];
+    readArrRaw(length: number): unknown[];
+    readArrIndef(): unknown[];
+    readObj(minor: number): Record<string, unknown>;
+    readObjRaw(length: number): Record<string, unknown>;
+    readObjIndef(): Record<string, unknown>;
+    key(): string;
+    readTag(minor: number): JsonPackExtension<unknown> | unknown;
+    readTagRaw(tag: number): JsonPackExtension<unknown> | unknown;
+    readTkn(minor: number): number | true | false | null | undefined | JsonPackValue<number>;
+    f16(): number;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoderBase.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborDecoderBase = void 0;
+const tslib_1 = require("tslib");
+const f16_1 = require("@jsonjoy.com/util/lib/buffers/f16");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const JsonPackValue_1 = require("../JsonPackValue");
+const Reader_1 = require("@jsonjoy.com/util/lib/buffers/Reader");
+const sharedCachedUtf8Decoder_1 = tslib_1.__importDefault(require("@jsonjoy.com/util/lib/buffers/utf8/sharedCachedUtf8Decoder"));
+class CborDecoderBase {
+    constructor(reader = new Reader_1.Reader(), keyDecoder = sharedCachedUtf8Decoder_1.default) {
+        this.reader = reader;
+        this.keyDecoder = keyDecoder;
+    }
+    read(uint8) {
+        this.reader.reset(uint8);
+        return this.val();
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.val();
+    }
+    val() {
+        const reader = this.reader;
+        const octet = reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major < 4) {
+            if (major < 2)
+                return major === 0 ? this.readUint(minor) : this.readNint(minor);
+            else
+                return major === 2 ? this.readBin(minor) : this.readStr(minor);
+        }
+        else {
+            if (major < 6)
+                return major === 4 ? this.readArr(minor) : this.readObj(minor);
+            else
+                return major === 6 ? this.readTag(minor) : this.readTkn(minor);
+        }
+    }
+    readAnyRaw(octet) {
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major < 4) {
+            if (major < 2)
+                return major === 0 ? this.readUint(minor) : this.readNint(minor);
+            else
+                return major === 2 ? this.readBin(minor) : this.readStr(minor);
+        }
+        else {
+            if (major < 6)
+                return major === 4 ? this.readArr(minor) : this.readObj(minor);
+            else
+                return major === 6 ? this.readTag(minor) : this.readTkn(minor);
+        }
+    }
+    readMinorLen(minor) {
+        if (minor < 24)
+            return minor;
+        switch (minor) {
+            case 24:
+                return this.reader.u8();
+            case 25:
+                return this.reader.u16();
+            case 26:
+                return this.reader.u32();
+            case 27:
+                return Number(this.reader.u64());
+            case 31:
+                return -1;
+            default:
+                throw 1;
+        }
+    }
+    readUint(minor) {
+        if (minor < 25) {
+            return minor === 24 ? this.reader.u8() : minor;
+        }
+        else {
+            if (minor < 27) {
+                return minor === 25 ? this.reader.u16() : this.reader.u32();
+            }
+            else {
+                const num = this.reader.u64();
+                return num > 9007199254740991 ? num : Number(num);
+            }
+        }
+    }
+    readNint(minor) {
+        if (minor < 25) {
+            return minor === 24 ? -this.reader.u8() - 1 : -minor - 1;
+        }
+        else {
+            if (minor < 27) {
+                return minor === 25 ? -this.reader.u16() - 1 : -this.reader.u32() - 1;
+            }
+            else {
+                const num = this.reader.u64();
+                return num > 9007199254740991 - 1 ? -num - BigInt(1) : -Number(num) - 1;
+            }
+        }
+    }
+    readBin(minor) {
+        const reader = this.reader;
+        if (minor <= 23)
+            return reader.buf(minor);
+        switch (minor) {
+            case 24:
+                return reader.buf(reader.u8());
+            case 25:
+                return reader.buf(reader.u16());
+            case 26:
+                return reader.buf(reader.u32());
+            case 27:
+                return reader.buf(Number(reader.u64()));
+            case 31: {
+                let size = 0;
+                const list = [];
+                while (this.reader.peak() !== 255) {
+                    const uint8 = this.readBinChunk();
+                    size += uint8.length;
+                    list.push(uint8);
+                }
+                this.reader.x++;
+                const res = new Uint8Array(size);
+                let offset = 0;
+                const length = list.length;
+                for (let i = 0; i < length; i++) {
+                    const arr = list[i];
+                    res.set(arr, offset);
+                    offset += arr.length;
+                }
+                return res;
+            }
+            default:
+                throw 1;
+        }
+    }
+    readBinChunk() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major !== 2)
+            throw 2;
+        if (minor > 27)
+            throw 3;
+        return this.readBin(minor);
+    }
+    readAsStr() {
+        const reader = this.reader;
+        const octet = reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major !== 3)
+            throw 11;
+        return this.readStr(minor);
+    }
+    readStr(minor) {
+        const reader = this.reader;
+        if (minor <= 23)
+            return reader.utf8(minor);
+        switch (minor) {
+            case 24:
+                return reader.utf8(reader.u8());
+            case 25:
+                return reader.utf8(reader.u16());
+            case 26:
+                return reader.utf8(reader.u32());
+            case 27:
+                return reader.utf8(Number(reader.u64()));
+            case 31: {
+                let str = '';
+                while (reader.peak() !== 255)
+                    str += this.readStrChunk();
+                this.reader.x++;
+                return str;
+            }
+            default:
+                throw 1;
+        }
+    }
+    readStrLen(minor) {
+        if (minor <= 23)
+            return minor;
+        switch (minor) {
+            case 24:
+                return this.reader.u8();
+            case 25:
+                return this.reader.u16();
+            case 26:
+                return this.reader.u32();
+            case 27:
+                return Number(this.reader.u64());
+            default:
+                throw 1;
+        }
+    }
+    readStrChunk() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major !== 3)
+            throw 4;
+        if (minor > 27)
+            throw 5;
+        return this.readStr(minor);
+    }
+    readArr(minor) {
+        const length = this.readMinorLen(minor);
+        if (length >= 0)
+            return this.readArrRaw(length);
+        return this.readArrIndef();
+    }
+    readArrRaw(length) {
+        const arr = [];
+        for (let i = 0; i < length; i++)
+            arr.push(this.val());
+        return arr;
+    }
+    readArrIndef() {
+        const arr = [];
+        while (this.reader.peak() !== 255)
+            arr.push(this.val());
+        this.reader.x++;
+        return arr;
+    }
+    readObj(minor) {
+        if (minor < 28) {
+            let length = minor;
+            switch (minor) {
+                case 24:
+                    length = this.reader.u8();
+                    break;
+                case 25:
+                    length = this.reader.u16();
+                    break;
+                case 26:
+                    length = this.reader.u32();
+                    break;
+                case 27:
+                    length = Number(this.reader.u64());
+                    break;
+            }
+            const obj = {};
+            for (let i = 0; i < length; i++) {
+                const key = this.key();
+                if (key === '__proto__')
+                    throw 6;
+                const value = this.val();
+                obj[key] = value;
+            }
+            return obj;
+        }
+        else if (minor === 31)
+            return this.readObjIndef();
+        else
+            throw 1;
+    }
+    readObjRaw(length) {
+        const obj = {};
+        for (let i = 0; i < length; i++) {
+            const key = this.key();
+            const value = this.val();
+            obj[key] = value;
+        }
+        return obj;
+    }
+    readObjIndef() {
+        const obj = {};
+        while (this.reader.peak() !== 255) {
+            const key = this.key();
+            if (this.reader.peak() === 255)
+                throw 7;
+            const value = this.val();
+            obj[key] = value;
+        }
+        this.reader.x++;
+        return obj;
+    }
+    key() {
+        const octet = this.reader.u8();
+        const major = octet >> 5;
+        const minor = octet & 31;
+        if (major !== 3)
+            return String(this.readAnyRaw(octet));
+        const length = this.readStrLen(minor);
+        if (length > 31)
+            return this.reader.utf8(length);
+        const key = this.keyDecoder.decode(this.reader.uint8, this.reader.x, length);
+        this.reader.skip(length);
+        return key;
+    }
+    readTag(minor) {
+        if (minor <= 23)
+            return this.readTagRaw(minor);
+        switch (minor) {
+            case 24:
+                return this.readTagRaw(this.reader.u8());
+            case 25:
+                return this.readTagRaw(this.reader.u16());
+            case 26:
+                return this.readTagRaw(this.reader.u32());
+            case 27:
+                return this.readTagRaw(Number(this.reader.u64()));
+            default:
+                throw 1;
+        }
+    }
+    readTagRaw(tag) {
+        return new JsonPackExtension_1.JsonPackExtension(tag, this.val());
+    }
+    readTkn(minor) {
+        switch (minor) {
+            case 0xf4 & 31:
+                return false;
+            case 0xf5 & 31:
+                return true;
+            case 0xf6 & 31:
+                return null;
+            case 0xf7 & 31:
+                return undefined;
+            case 0xf8 & 31:
+                return new JsonPackValue_1.JsonPackValue(this.reader.u8());
+            case 0xf9 & 31:
+                return this.f16();
+            case 0xfa & 31:
+                return this.reader.f32();
+            case 0xfb & 31:
+                return this.reader.f64();
+        }
+        if (minor <= 23)
+            return new JsonPackValue_1.JsonPackValue(minor);
+        throw 1;
+    }
+    f16() {
+        return (0, f16_1.decodeF16)(this.reader.u16());
+    }
+}
+exports.CborDecoderBase = CborDecoderBase;
+//# sourceMappingURL=CborDecoderBase.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoderDag.d.ts

@@ -0,0 +1,5 @@
+import { JsonPackExtension } from '../JsonPackExtension';
+import { CborDecoder } from './CborDecoder';
+export declare class CborDecoderDag extends CborDecoder {
+    readTagRaw(tag: number): JsonPackExtension<unknown> | unknown;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoderDag.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborDecoderDag = void 0;
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const CborDecoder_1 = require("./CborDecoder");
+class CborDecoderDag extends CborDecoder_1.CborDecoder {
+    readTagRaw(tag) {
+        const value = this.val();
+        return tag === 42 ? new JsonPackExtension_1.JsonPackExtension(tag, value) : value;
+    }
+}
+exports.CborDecoderDag = CborDecoderDag;
+//# sourceMappingURL=CborDecoderDag.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborDecoderDag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CborDecoderDag.js","sourceRoot":"","sources":["../../src/cbor/CborDecoderDag.ts"],"names":[],"mappings":";;;AAAA,4DAAuD;AACvD,+CAA0C;AAE1C,MAAa,cAAe,SAAQ,yBAAW;IACtC,UAAU,CAAC,GAAW;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACzB,OAAO,GAAG,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,qCAAiB,CAAU,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IACzE,CAAC;CACF;AALD,wCAKC"}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoder.d.ts

@@ -0,0 +1,9 @@
+import { CborEncoderFast } from './CborEncoderFast';
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/util/lib/buffers';
+export declare class CborEncoder<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> extends CborEncoderFast<W> {
+    writeUnknown(value: unknown): void;
+    writeAny(value: unknown): void;
+    writeFloat(float: number): void;
+    writeMap(map: Map<unknown, unknown>): void;
+    writeUndef(): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborEncoder = void 0;
+const isFloat32_1 = require("@jsonjoy.com/util/lib/buffers/isFloat32");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const CborEncoderFast_1 = require("./CborEncoderFast");
+const JsonPackValue_1 = require("../JsonPackValue");
+class CborEncoder extends CborEncoderFast_1.CborEncoderFast {
+    writeUnknown(value) {
+        this.writeNull();
+    }
+    writeAny(value) {
+        switch (typeof value) {
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                return this.writeStr(value);
+            case 'boolean':
+                return this.writer.u8(0xf4 + +value);
+            case 'object': {
+                if (!value)
+                    return this.writer.u8(0xf6);
+                const constructor = value.constructor;
+                switch (constructor) {
+                    case Object:
+                        return this.writeObj(value);
+                    case Array:
+                        return this.writeArr(value);
+                    case Uint8Array:
+                        return this.writeBin(value);
+                    case Map:
+                        return this.writeMap(value);
+                    case JsonPackExtension_1.JsonPackExtension:
+                        return this.writeTag(value.tag, value.val);
+                    case JsonPackValue_1.JsonPackValue:
+                        const buf = value.val;
+                        return this.writer.buf(buf, buf.length);
+                    default:
+                        if (value instanceof Uint8Array)
+                            return this.writeBin(value);
+                        if (Array.isArray(value))
+                            return this.writeArr(value);
+                        if (value instanceof Map)
+                            return this.writeMap(value);
+                        return this.writeUnknown(value);
+                }
+            }
+            case 'undefined':
+                return this.writeUndef();
+            case 'bigint':
+                return this.writeBigInt(value);
+            default:
+                return this.writeUnknown(value);
+        }
+    }
+    writeFloat(float) {
+        if ((0, isFloat32_1.isFloat32)(float))
+            this.writer.u8f32(0xfa, float);
+        else
+            this.writer.u8f64(0xfb, float);
+    }
+    writeMap(map) {
+        this.writeMapHdr(map.size);
+        map.forEach((value, key) => {
+            this.writeAny(key);
+            this.writeAny(value);
+        });
+    }
+    writeUndef() {
+        this.writer.u8(0xf7);
+    }
+}
+exports.CborEncoder = CborEncoder;
+//# sourceMappingURL=CborEncoder.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoder.js.map

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

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderDag.d.ts

@@ -0,0 +1,6 @@
+import { CborEncoderStable } from './CborEncoderStable';
+export declare class CborEncoderDag extends CborEncoderStable {
+    writeUndef(): void;
+    writeFloat(float: number): void;
+    writeTag(tag: number, value: unknown): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderDag.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborEncoderDag = void 0;
+const CborEncoderStable_1 = require("./CborEncoderStable");
+class CborEncoderDag extends CborEncoderStable_1.CborEncoderStable {
+    writeUndef() {
+        this.writeNull();
+    }
+    writeFloat(float) {
+        if (float !== float)
+            return this.writeNull();
+        if (!Number.isFinite(float))
+            return this.writeNull();
+        this.writer.u8f64(0xfb, float);
+    }
+    writeTag(tag, value) {
+        if (tag === 42)
+            this.writeTagHdr(tag);
+        this.writeAny(value);
+    }
+}
+exports.CborEncoderDag = CborEncoderDag;
+//# sourceMappingURL=CborEncoderDag.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderDag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CborEncoderDag.js","sourceRoot":"","sources":["../../src/cbor/CborEncoderDag.ts"],"names":[],"mappings":";;;AAAA,2DAAsD;AAEtD,MAAa,cAAe,SAAQ,qCAAiB;IAC5C,UAAU;QACf,IAAI,CAAC,SAAS,EAAE,CAAC;IACnB,CAAC;IAEM,UAAU,CAAC,KAAa;QAC7B,IAAI,KAAK,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;QAC7C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC,SAAS,EAAE,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC;IAEM,QAAQ,CAAC,GAAW,EAAE,KAAc;QACzC,IAAI,GAAG,KAAK,EAAE;YAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;CACF;AAfD,wCAeC"}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderFast.d.ts

@@ -0,0 +1,51 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/util/lib/buffers';
+import type { BinaryJsonEncoder, StreamingBinaryJsonEncoder, TlvBinaryJsonEncoder } from '../types';
+import type { Slice } from '@jsonjoy.com/util/lib/buffers/Slice';
+export declare class CborEncoderFast<W extends IWriter & IWriterGrowable = IWriter & IWriterGrowable> implements BinaryJsonEncoder, StreamingBinaryJsonEncoder, TlvBinaryJsonEncoder {
+    readonly writer: W;
+    constructor(writer?: W);
+    encode(value: unknown): Uint8Array;
+    encodeToSlice(value: unknown): Slice;
+    writeAny(value: unknown): void;
+    writeCbor(): void;
+    writeEnd(): void;
+    writeNull(): void;
+    writeBoolean(bool: boolean): void;
+    writeNumber(num: number): void;
+    writeBigInt(int: bigint): void;
+    writeBigUint(uint: bigint): void;
+    writeBigSint(int: bigint): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    encodeNumber(num: number): void;
+    encodeInteger(int: number): void;
+    encodeUint(uint: number): void;
+    encodeNint(int: number): void;
+    writeFloat(float: number): void;
+    writeBin(buf: Uint8Array): void;
+    writeBinHdr(length: number): void;
+    writeStr(str: string): void;
+    writeStrHdr(length: number): void;
+    writeAsciiStr(str: string): void;
+    writeArr(arr: unknown[]): void;
+    writeArrHdr(length: number): void;
+    writeObj(obj: Record<string, unknown>): void;
+    writeObjHdr(length: number): void;
+    writeMapHdr(length: number): void;
+    writeStartMap(): void;
+    writeTag(tag: number, value: unknown): void;
+    writeTagHdr(tag: number): void;
+    writeTkn(value: number): void;
+    writeStartStr(): void;
+    writeStrChunk(str: string): void;
+    writeEndStr(): void;
+    writeStartBin(): void;
+    writeBinChunk(buf: Uint8Array): void;
+    writeEndBin(): void;
+    writeStartArr(): void;
+    writeArrChunk(item: unknown): void;
+    writeEndArr(): void;
+    writeStartObj(): void;
+    writeObjChunk(key: string, value: unknown): void;
+    writeEndObj(): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderFast.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborEncoderFast = void 0;
+const Writer_1 = require("@jsonjoy.com/util/lib/buffers/Writer");
+const isSafeInteger = Number.isSafeInteger;
+class CborEncoderFast {
+    constructor(writer = new Writer_1.Writer()) {
+        this.writer = writer;
+    }
+    encode(value) {
+        this.writeAny(value);
+        return this.writer.flush();
+    }
+    encodeToSlice(value) {
+        this.writeAny(value);
+        return this.writer.flushSlice();
+    }
+    writeAny(value) {
+        switch (typeof value) {
+            case 'number':
+                return this.writeNumber(value);
+            case 'string':
+                return this.writeStr(value);
+            case 'boolean':
+                return this.writer.u8(0xf4 + +value);
+            case 'object': {
+                if (!value)
+                    return this.writer.u8(0xf6);
+                const constructor = value.constructor;
+                switch (constructor) {
+                    case Array:
+                        return this.writeArr(value);
+                    default:
+                        return this.writeObj(value);
+                }
+            }
+        }
+    }
+    writeCbor() {
+        this.writer.u8u16(0xd9, 0xd9f7);
+    }
+    writeEnd() {
+        this.writer.u8(255);
+    }
+    writeNull() {
+        this.writer.u8(0xf6);
+    }
+    writeBoolean(bool) {
+        if (bool)
+            this.writer.u8(0xf5);
+        else
+            this.writer.u8(0xf4);
+    }
+    writeNumber(num) {
+        if (isSafeInteger(num))
+            this.writeInteger(num);
+        else if (typeof num === 'bigint')
+            this.writeBigInt(num);
+        else
+            this.writeFloat(num);
+    }
+    writeBigInt(int) {
+        if (int >= 0)
+            this.writeBigUint(int);
+        else
+            this.writeBigSint(int);
+    }
+    writeBigUint(uint) {
+        if (uint <= Number.MAX_SAFE_INTEGER)
+            return this.writeUInteger(Number(uint));
+        this.writer.u8u64(0x1b, uint);
+    }
+    writeBigSint(int) {
+        if (int >= Number.MIN_SAFE_INTEGER)
+            return this.encodeNint(Number(int));
+        const uint = -BigInt(1) - int;
+        this.writer.u8u64(0x3b, uint);
+    }
+    writeInteger(int) {
+        if (int >= 0)
+            this.writeUInteger(int);
+        else
+            this.encodeNint(int);
+    }
+    writeUInteger(uint) {
+        const writer = this.writer;
+        writer.ensureCapacity(9);
+        const uint8 = writer.uint8;
+        let x = writer.x;
+        if (uint <= 23) {
+            uint8[x++] = 0 + uint;
+        }
+        else if (uint <= 0xff) {
+            uint8[x++] = 0x18;
+            uint8[x++] = uint;
+        }
+        else if (uint <= 0xffff) {
+            uint8[x++] = 0x19;
+            writer.view.setUint16(x, uint);
+            x += 2;
+        }
+        else if (uint <= 0xffffffff) {
+            uint8[x++] = 0x1a;
+            writer.view.setUint32(x, uint);
+            x += 4;
+        }
+        else {
+            uint8[x++] = 0x1b;
+            writer.view.setBigUint64(x, BigInt(uint));
+            x += 8;
+        }
+        writer.x = x;
+    }
+    encodeNumber(num) {
+        this.writeNumber(num);
+    }
+    encodeInteger(int) {
+        this.writeInteger(int);
+    }
+    encodeUint(uint) {
+        this.writeUInteger(uint);
+    }
+    encodeNint(int) {
+        const uint = -1 - int;
+        const writer = this.writer;
+        writer.ensureCapacity(9);
+        const uint8 = writer.uint8;
+        let x = writer.x;
+        if (uint < 24) {
+            uint8[x++] = 32 + uint;
+        }
+        else if (uint <= 0xff) {
+            uint8[x++] = 0x38;
+            uint8[x++] = uint;
+        }
+        else if (uint <= 0xffff) {
+            uint8[x++] = 0x39;
+            writer.view.setUint16(x, uint);
+            x += 2;
+        }
+        else if (uint <= 0xffffffff) {
+            uint8[x++] = 0x3a;
+            writer.view.setUint32(x, uint);
+            x += 4;
+        }
+        else {
+            uint8[x++] = 0x3b;
+            writer.view.setBigUint64(x, BigInt(uint));
+            x += 8;
+        }
+        writer.x = x;
+    }
+    writeFloat(float) {
+        this.writer.u8f64(0xfb, float);
+    }
+    writeBin(buf) {
+        const length = buf.length;
+        this.writeBinHdr(length);
+        this.writer.buf(buf, length);
+    }
+    writeBinHdr(length) {
+        const writer = this.writer;
+        if (length <= 23)
+            writer.u8(64 + length);
+        else if (length <= 0xff)
+            writer.u16((0x58 << 8) + length);
+        else if (length <= 0xffff)
+            writer.u8u16(0x59, length);
+        else if (length <= 0xffffffff)
+            writer.u8u32(0x5a, length);
+        else
+            writer.u8u64(0x5b, length);
+    }
+    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 <= 23)
+            writer.x++;
+        else if (maxSize <= 0xff) {
+            uint8[writer.x++] = 0x78;
+            lengthOffset = writer.x;
+            writer.x++;
+        }
+        else if (maxSize <= 0xffff) {
+            uint8[writer.x++] = 0x79;
+            lengthOffset = writer.x;
+            writer.x += 2;
+        }
+        else {
+            uint8[writer.x++] = 0x7a;
+            lengthOffset = writer.x;
+            writer.x += 4;
+        }
+        const bytesWritten = writer.utf8(str);
+        if (maxSize <= 23)
+            uint8[lengthOffset] = 96 + bytesWritten;
+        else if (maxSize <= 0xff)
+            uint8[lengthOffset] = bytesWritten;
+        else if (maxSize <= 0xffff)
+            writer.view.setUint16(lengthOffset, bytesWritten);
+        else
+            writer.view.setUint32(lengthOffset, bytesWritten);
+    }
+    writeStrHdr(length) {
+        const writer = this.writer;
+        if (length <= 23)
+            writer.u8(96 + length);
+        else if (length <= 0xff)
+            writer.u16((0x78 << 8) + length);
+        else if (length <= 0xffff)
+            writer.u8u16(0x79, length);
+        else
+            writer.u8u32(0x7a, length);
+    }
+    writeAsciiStr(str) {
+        this.writeStrHdr(str.length);
+        this.writer.ascii(str);
+    }
+    writeArr(arr) {
+        const length = arr.length;
+        this.writeArrHdr(length);
+        for (let i = 0; i < length; i++)
+            this.writeAny(arr[i]);
+    }
+    writeArrHdr(length) {
+        const writer = this.writer;
+        if (length <= 23)
+            writer.u8(128 + length);
+        else if (length <= 0xff)
+            writer.u16((0x98 << 8) + length);
+        else if (length <= 0xffff)
+            writer.u8u16(0x99, length);
+        else if (length <= 0xffffffff)
+            writer.u8u32(0x9a, length);
+        else
+            writer.u8u64(0x9b, 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]);
+        }
+    }
+    writeObjHdr(length) {
+        const writer = this.writer;
+        if (length <= 23)
+            writer.u8(160 + length);
+        else if (length <= 0xff)
+            writer.u16((0xb8 << 8) + length);
+        else if (length <= 0xffff)
+            writer.u8u16(0xb9, length);
+        else if (length <= 0xffffffff)
+            writer.u8u32(0xba, length);
+        else
+            writer.u8u64(0xbb, length);
+    }
+    writeMapHdr(length) {
+        this.writeObjHdr(length);
+    }
+    writeStartMap() {
+        this.writer.u8(0xbf);
+    }
+    writeTag(tag, value) {
+        this.writeTagHdr(tag);
+        this.writeAny(value);
+    }
+    writeTagHdr(tag) {
+        const writer = this.writer;
+        if (tag <= 23)
+            writer.u8(192 + tag);
+        else if (tag <= 0xff)
+            writer.u16((0xd8 << 8) + tag);
+        else if (tag <= 0xffff)
+            writer.u8u16(0xd9, tag);
+        else if (tag <= 0xffffffff)
+            writer.u8u32(0xda, tag);
+        else
+            writer.u8u64(0xdb, tag);
+    }
+    writeTkn(value) {
+        const writer = this.writer;
+        if (value <= 23)
+            writer.u8(224 + value);
+        else if (value <= 0xff)
+            writer.u16((0xf8 << 8) + value);
+    }
+    writeStartStr() {
+        this.writer.u8(0x7f);
+    }
+    writeStrChunk(str) {
+        throw new Error('Not implemented');
+    }
+    writeEndStr() {
+        throw new Error('Not implemented');
+    }
+    writeStartBin() {
+        this.writer.u8(0x5f);
+    }
+    writeBinChunk(buf) {
+        throw new Error('Not implemented');
+    }
+    writeEndBin() {
+        throw new Error('Not implemented');
+    }
+    writeStartArr() {
+        this.writer.u8(0x9f);
+    }
+    writeArrChunk(item) {
+        throw new Error('Not implemented');
+    }
+    writeEndArr() {
+        this.writer.u8(255);
+    }
+    writeStartObj() {
+        this.writer.u8(0xbf);
+    }
+    writeObjChunk(key, value) {
+        throw new Error('Not implemented');
+    }
+    writeEndObj() {
+        this.writer.u8(255);
+    }
+}
+exports.CborEncoderFast = CborEncoderFast;
+//# sourceMappingURL=CborEncoderFast.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderStable.d.ts

@@ -0,0 +1,6 @@
+import { CborEncoder } from './CborEncoder';
+export declare class CborEncoderStable extends CborEncoder {
+    writeObj(obj: Record<string, unknown>): void;
+    writeStr(str: string): void;
+    writeUndef(): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderStable.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborEncoderStable = void 0;
+const CborEncoder_1 = require("./CborEncoder");
+const insertion2_1 = require("@jsonjoy.com/util/lib/sort/insertion2");
+const objKeyCmp_1 = require("@jsonjoy.com/util/lib/objKeyCmp");
+const strHeaderLength = (strSize) => {
+    if (strSize <= 23)
+        return 1;
+    else if (strSize <= 0xff)
+        return 2;
+    else if (strSize <= 0xffff)
+        return 3;
+    else
+        return 5;
+};
+class CborEncoderStable extends CborEncoder_1.CborEncoder {
+    writeObj(obj) {
+        const keys = Object.keys(obj);
+        (0, insertion2_1.sort)(keys, objKeyCmp_1.objKeyCmp);
+        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]);
+        }
+    }
+    writeStr(str) {
+        const writer = this.writer;
+        const length = str.length;
+        const maxSize = length * 4;
+        writer.ensureCapacity(5 + maxSize);
+        const headerLengthGuess = strHeaderLength(length);
+        const x0 = writer.x;
+        const x1 = x0 + headerLengthGuess;
+        writer.x = x1;
+        const bytesWritten = writer.utf8(str);
+        const uint8 = writer.uint8;
+        const headerLength = strHeaderLength(bytesWritten);
+        if (headerLength !== headerLengthGuess) {
+            const shift = headerLength - headerLengthGuess;
+            uint8.copyWithin(x1 + shift, x1, x1 + bytesWritten);
+        }
+        switch (headerLength) {
+            case 1:
+                uint8[x0] = 96 + bytesWritten;
+                break;
+            case 2:
+                uint8[x0] = 0x78;
+                uint8[x0 + 1] = bytesWritten;
+                break;
+            case 3: {
+                uint8[x0] = 0x79;
+                writer.view.setUint16(x0 + 1, bytesWritten);
+                break;
+            }
+            case 5: {
+                uint8[x0] = 0x7a;
+                writer.view.setUint32(x0 + 1, bytesWritten);
+                break;
+            }
+        }
+        writer.x = x0 + headerLength + bytesWritten;
+    }
+    writeUndef() {
+        this.writeNull();
+    }
+}
+exports.CborEncoderStable = CborEncoderStable;
+//# sourceMappingURL=CborEncoderStable.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/CborEncoderStable.js.map

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

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

@@ -0,0 +1,39 @@
+export declare const enum MAJOR {
+    UIN = 0,
+    NIN = 1,
+    BIN = 2,
+    STR = 3,
+    ARR = 4,
+    MAP = 5,
+    TAG = 6,
+    TKN = 7
+}
+export declare const enum MAJOR_OVERLAY {
+    UIN = 0,
+    NIN = 32,
+    BIN = 64,
+    STR = 96,
+    ARR = 128,
+    MAP = 160,
+    TAG = 192,
+    TKN = 224
+}
+export declare const enum CONST {
+    MINOR_MASK = 31,
+    MAX_UINT = 9007199254740991,
+    END = 255
+}
+export declare const enum ERROR {
+    UNEXPECTED_MAJOR = 0,
+    UNEXPECTED_MINOR = 1,
+    UNEXPECTED_BIN_CHUNK_MAJOR = 2,
+    UNEXPECTED_BIN_CHUNK_MINOR = 3,
+    UNEXPECTED_STR_CHUNK_MAJOR = 4,
+    UNEXPECTED_STR_CHUNK_MINOR = 5,
+    UNEXPECTED_OBJ_KEY = 6,
+    UNEXPECTED_OBJ_BREAK = 7,
+    INVALID_SIZE = 8,
+    KEY_NOT_FOUND = 9,
+    INDEX_OUT_OF_BOUNDS = 10,
+    UNEXPECTED_STR_MAJOR = 11
+}

node_modules/@jsonjoy.com/json-pack/lib/cbor/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/cbor/constants.js.map

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

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

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './CborEncoderFast';
+export * from './CborEncoder';
+export * from './CborEncoderStable';
+export * from './CborEncoderDag';
+export * from './CborDecoderBase';
+export * from './CborDecoder';
+export * from './CborDecoderDag';

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./CborEncoderFast"), exports);
+tslib_1.__exportStar(require("./CborEncoder"), exports);
+tslib_1.__exportStar(require("./CborEncoderStable"), exports);
+tslib_1.__exportStar(require("./CborEncoderDag"), exports);
+tslib_1.__exportStar(require("./CborDecoderBase"), exports);
+tslib_1.__exportStar(require("./CborDecoder"), exports);
+tslib_1.__exportStar(require("./CborDecoderDag"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cbor/index.ts"],"names":[],"mappings":";;;AAAA,kDAAwB;AACxB,4DAAkC;AAClC,wDAA8B;AAC9B,8DAAoC;AACpC,2DAAiC;AACjC,4DAAkC;AAClC,wDAA8B;AAC9B,2DAAiC"}

node_modules/@jsonjoy.com/json-pack/lib/cbor/shared.d.ts

@@ -0,0 +1,8 @@
+import { CborEncoder } from './CborEncoder';
+import { CborDecoder } from './CborDecoder';
+import { CborUint8Array } from './types';
+export type { CborUint8Array };
+export declare const encoder: CborEncoder<import("@jsonjoy.com/util/lib/buffers").IWriter & import("@jsonjoy.com/util/lib/buffers").IWriterGrowable>;
+export declare const decoder: CborDecoder<import("@jsonjoy.com/util/lib/buffers").IReader & import("@jsonjoy.com/util/lib/buffers").IReaderResettable>;
+export declare const encode: <T>(data: T) => CborUint8Array<T>;
+export declare const decode: <T>(blob: CborUint8Array<T>) => T;

node_modules/@jsonjoy.com/json-pack/lib/cbor/shared.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decode = exports.encode = exports.decoder = exports.encoder = void 0;
+const CborEncoder_1 = require("./CborEncoder");
+const CborDecoder_1 = require("./CborDecoder");
+exports.encoder = new CborEncoder_1.CborEncoder();
+exports.decoder = new CborDecoder_1.CborDecoder();
+const encode = (data) => exports.encoder.encode(data);
+exports.encode = encode;
+const decode = (blob) => exports.decoder.read(blob);
+exports.decode = decode;
+//# sourceMappingURL=shared.js.map

node_modules/@jsonjoy.com/json-pack/lib/cbor/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../src/cbor/shared.ts"],"names":[],"mappings":";;;AAAA,+CAA0C;AAC1C,+CAA0C;AAK7B,QAAA,OAAO,GAAG,IAAI,yBAAW,EAAE,CAAC;AAC5B,QAAA,OAAO,GAAG,IAAI,yBAAW,EAAE,CAAC;AAElC,MAAM,MAAM,GAAG,CAAI,IAAO,EAAqB,EAAE,CAAC,eAAO,CAAC,MAAM,CAAC,IAAI,CAAsB,CAAC;AAAtF,QAAA,MAAM,UAAgF;AAC5F,MAAM,MAAM,GAAG,CAAI,IAAuB,EAAK,EAAE,CAAC,eAAO,CAAC,IAAI,CAAC,IAAI,CAAM,CAAC;AAApE,QAAA,MAAM,UAA8D"}

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

@@ -0,0 +1,4 @@
+export type CborUint8Array<T> = Uint8Array & {
+    __BRAND__: 'cbor';
+    __TYPE__: T;
+};

node_modules/@jsonjoy.com/json-pack/lib/cbor/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/cbor/types.js.map

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

node_modules/@jsonjoy.com/json-pack/lib/codecs/Codecs.d.ts

@@ -0,0 +1,11 @@
+import { Writer } from '@jsonjoy.com/util/lib/buffers/Writer';
+import { CborJsonValueCodec } from './cbor';
+import { JsonJsonValueCodec } from './json';
+import { MsgPackJsonValueCodec } from './msgpack';
+export declare class Codecs {
+    readonly writer: Writer;
+    readonly cbor: CborJsonValueCodec;
+    readonly msgpack: MsgPackJsonValueCodec;
+    readonly json: JsonJsonValueCodec;
+    constructor(writer: Writer);
+}

node_modules/@jsonjoy.com/json-pack/lib/codecs/Codecs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Codecs = void 0;
+const cbor_1 = require("./cbor");
+const json_1 = require("./json");
+const msgpack_1 = require("./msgpack");
+class Codecs {
+    constructor(writer) {
+        this.writer = writer;
+        this.cbor = new cbor_1.CborJsonValueCodec(this.writer);
+        this.msgpack = new msgpack_1.MsgPackJsonValueCodec(this.writer);
+        this.json = new json_1.JsonJsonValueCodec(this.writer);
+    }
+}
+exports.Codecs = Codecs;
+//# sourceMappingURL=Codecs.js.map

node_modules/@jsonjoy.com/json-pack/lib/codecs/Codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Codecs.js","sourceRoot":"","sources":["../../src/codecs/Codecs.ts"],"names":[],"mappings":";;;AACA,iCAA0C;AAC1C,iCAA0C;AAC1C,uCAAgD;AAEhD,MAAa,MAAM;IAKjB,YAA4B,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;QACxC,IAAI,CAAC,IAAI,GAAG,IAAI,yBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,GAAG,IAAI,+BAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,GAAG,IAAI,yBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;CACF;AAVD,wBAUC"}

node_modules/@jsonjoy.com/json-pack/lib/codecs/cbor.d.ts

@@ -0,0 +1,12 @@
+import { CborDecoder } from '../cbor/CborDecoder';
+import { CborEncoder } from '../cbor/CborEncoder';
+import { EncodingFormat } from '../constants';
+import type { Writer } from '@jsonjoy.com/util/lib/buffers/Writer';
+import type { JsonValueCodec } from './types';
+export declare class CborJsonValueCodec implements JsonValueCodec {
+    readonly id = "cbor";
+    readonly format = EncodingFormat.Cbor;
+    readonly encoder: CborEncoder;
+    readonly decoder: CborDecoder;
+    constructor(writer: Writer);
+}

node_modules/@jsonjoy.com/json-pack/lib/codecs/cbor.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborJsonValueCodec = void 0;
+const CborDecoder_1 = require("../cbor/CborDecoder");
+const CborEncoder_1 = require("../cbor/CborEncoder");
+class CborJsonValueCodec {
+    constructor(writer) {
+        this.id = 'cbor';
+        this.format = 0;
+        this.encoder = new CborEncoder_1.CborEncoder(writer);
+        this.decoder = new CborDecoder_1.CborDecoder();
+    }
+}
+exports.CborJsonValueCodec = CborJsonValueCodec;
+//# sourceMappingURL=cbor.js.map

node_modules/@jsonjoy.com/json-pack/lib/codecs/cbor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cbor.js","sourceRoot":"","sources":["../../src/codecs/cbor.ts"],"names":[],"mappings":";;;AAAA,qDAAgD;AAChD,qDAAgD;AAKhD,MAAa,kBAAkB;IAM7B,YAAY,MAAc;QALV,OAAE,GAAG,MAAM,CAAC;QACZ,WAAM,KAAuB;QAK3C,IAAI,CAAC,OAAO,GAAG,IAAI,yBAAW,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,GAAG,IAAI,yBAAW,EAAE,CAAC;IACnC,CAAC;CACF;AAVD,gDAUC"}

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

@@ -0,0 +1,12 @@
+import { EncodingFormat } from '../constants';
+import { JsonEncoder } from '../json/JsonEncoder';
+import { JsonDecoder } from '../json/JsonDecoder';
+import type { Writer } from '@jsonjoy.com/util/lib/buffers/Writer';
+import type { JsonValueCodec } from './types';
+export declare class JsonJsonValueCodec implements JsonValueCodec {
+    readonly id = "json";
+    readonly format = EncodingFormat.Json;
+    readonly encoder: JsonEncoder;
+    readonly decoder: JsonDecoder;
+    constructor(writer: Writer);
+}

node_modules/@jsonjoy.com/json-pack/lib/codecs/json.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonJsonValueCodec = void 0;
+const JsonEncoder_1 = require("../json/JsonEncoder");
+const JsonDecoder_1 = require("../json/JsonDecoder");
+class JsonJsonValueCodec {
+    constructor(writer) {
+        this.id = 'json';
+        this.format = 2;
+        this.encoder = new JsonEncoder_1.JsonEncoder(writer);
+        this.decoder = new JsonDecoder_1.JsonDecoder();
+    }
+}
+exports.JsonJsonValueCodec = JsonJsonValueCodec;
+//# sourceMappingURL=json.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/codecs/json.ts"],"names":[],"mappings":";;;AACA,qDAAgD;AAChD,qDAAgD;AAIhD,MAAa,kBAAkB;IAM7B,YAAY,MAAc;QALV,OAAE,GAAG,MAAM,CAAC;QACZ,WAAM,KAAuB;QAK3C,IAAI,CAAC,OAAO,GAAG,IAAI,yBAAW,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,GAAG,IAAI,yBAAW,EAAE,CAAC;IACnC,CAAC;CACF;AAVD,gDAUC"}

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

@@ -0,0 +1,12 @@
+import { EncodingFormat } from '../constants';
+import { MsgPackEncoder } from '../msgpack';
+import { MsgPackDecoder } from '../msgpack/MsgPackDecoder';
+import type { Writer } from '@jsonjoy.com/util/lib/buffers/Writer';
+import type { JsonValueCodec } from './types';
+export declare class MsgPackJsonValueCodec implements JsonValueCodec {
+    readonly id = "msgpack";
+    readonly format = EncodingFormat.MsgPack;
+    readonly encoder: MsgPackEncoder;
+    readonly decoder: MsgPackDecoder;
+    constructor(writer: Writer);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgPackJsonValueCodec = void 0;
+const msgpack_1 = require("../msgpack");
+const MsgPackDecoder_1 = require("../msgpack/MsgPackDecoder");
+class MsgPackJsonValueCodec {
+    constructor(writer) {
+        this.id = 'msgpack';
+        this.format = 1;
+        this.encoder = new msgpack_1.MsgPackEncoder(writer);
+        this.decoder = new MsgPackDecoder_1.MsgPackDecoder();
+    }
+}
+exports.MsgPackJsonValueCodec = MsgPackJsonValueCodec;
+//# sourceMappingURL=msgpack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"msgpack.js","sourceRoot":"","sources":["../../src/codecs/msgpack.ts"],"names":[],"mappings":";;;AACA,wCAA0C;AAC1C,8DAAyD;AAIzD,MAAa,qBAAqB;IAMhC,YAAY,MAAc;QALV,OAAE,GAAG,SAAS,CAAC;QACf,WAAM,KAA0B;QAK9C,IAAI,CAAC,OAAO,GAAG,IAAI,wBAAc,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,IAAI,+BAAc,EAAE,CAAC;IACtC,CAAC;CACF;AAVD,sDAUC"}

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

@@ -0,0 +1,8 @@
+import type { EncodingFormat } from '../constants';
+import type { BinaryJsonDecoder, BinaryJsonEncoder } from '../types';
+export interface JsonValueCodec {
+    id: string;
+    format: EncodingFormat;
+    encoder: BinaryJsonEncoder;
+    decoder: BinaryJsonDecoder;
+}

node_modules/@jsonjoy.com/json-pack/lib/codecs/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/codecs/types.js.map

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

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

@@ -0,0 +1,5 @@
+export declare const enum EncodingFormat {
+    Cbor = 0,
+    MsgPack = 1,
+    Json = 2
+}

node_modules/@jsonjoy.com/json-pack/lib/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/constants.js.map

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

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

@@ -0,0 +1 @@
+export type * from './types';

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

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

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

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

node_modules/@jsonjoy.com/json-pack/lib/ion/Import.d.ts

@@ -0,0 +1,14 @@
+import { ObjAstNode } from './ast';
+import { SymbolTable } from './types';
+export declare class Import {
+    readonly parent: Import | null;
+    readonly symbols: SymbolTable;
+    readonly offset: number;
+    length: number;
+    protected readonly byText: Map<string, number>;
+    constructor(parent: Import | null, symbols: SymbolTable);
+    getId(symbol: string): number | undefined;
+    getText(id: number): string | undefined;
+    add(symbol: string): number;
+    toAst(): ObjAstNode;
+}

node_modules/@jsonjoy.com/json-pack/lib/ion/Import.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Import = void 0;
+const ast_1 = require("./ast");
+class Import {
+    constructor(parent, symbols) {
+        this.parent = parent;
+        this.symbols = symbols;
+        this.byText = new Map();
+        this.offset = parent ? parent.offset + parent.length : 1;
+        this.length = symbols.length;
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            this.byText.set(symbol, this.offset + i);
+        }
+    }
+    getId(symbol) {
+        const id = this.byText.get(symbol);
+        if (id !== undefined)
+            return id;
+        if (this.parent)
+            this.parent.getId(symbol);
+        return undefined;
+    }
+    getText(id) {
+        if (id < this.offset)
+            return this.parent ? this.parent.getText(id) : undefined;
+        return this.symbols[id - this.offset];
+    }
+    add(symbol) {
+        let id = this.byText.get(symbol);
+        if (id !== undefined)
+            return id;
+        const length = this.symbols.length;
+        id = this.offset + length;
+        this.symbols.push(symbol);
+        this.length++;
+        this.byText.set(symbol, id);
+        return id;
+    }
+    toAst() {
+        const map = new Map();
+        map.set(7, (0, ast_1.toAst)(this.symbols, this));
+        return new ast_1.ObjAstNode(map);
+    }
+}
+exports.Import = Import;
+//# sourceMappingURL=Import.js.map

node_modules/@jsonjoy.com/json-pack/lib/ion/Import.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Import.js","sourceRoot":"","sources":["../../src/ion/Import.ts"],"names":[],"mappings":";;;AAAA,+BAAiD;AAGjD,MAAa,MAAM;IAKjB,YACkB,MAAqB,EACrB,OAAoB;QADpB,WAAM,GAAN,MAAM,CAAe;QACrB,YAAO,GAAP,OAAO,CAAa;QAJnB,WAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;QAMpD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC1B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,MAAc;QACzB,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnC,IAAI,EAAE,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QAChC,IAAI,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3C,OAAO,SAAS,CAAC;IACnB,CAAC;IAEM,OAAO,CAAC,EAAU;QACvB,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC/E,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAEM,GAAG,CAAC,MAAc;QACvB,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACjC,IAAI,EAAE,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QACnC,EAAE,GAAG,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1B,IAAI,CAAC,MAAM,EAAE,CAAC;QACd,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAC5B,OAAO,EAAE,CAAC;IACZ,CAAC;IAEM,KAAK;QACV,MAAM,GAAG,GAAG,IAAI,GAAG,EAA4B,CAAC;QAChD,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,IAAA,WAAK,EAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;QACtC,OAAO,IAAI,gBAAU,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;CACF;AA7CD,wBA6CC"}

node_modules/@jsonjoy.com/json-pack/lib/ion/IonEncoderFast.d.ts

@@ -0,0 +1,22 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/util/lib/buffers';
+import { AnnotationAstNode, ArrAstNode, AstNode, BinAstNode, BoolAstNode, FloatAstNode, NintAstNode, ObjAstNode, StrAstNode, UintAstNode } from './ast';
+import { Import } from './Import';
+export declare class IonEncoderFast {
+    readonly writer: IWriter & IWriterGrowable;
+    protected symbols?: Import;
+    constructor(writer?: IWriter & IWriterGrowable);
+    encode(value: unknown): Uint8Array;
+    writeAny(value: AstNode<unknown>): void;
+    writeIvm(): void;
+    writeSymbolTable(): void;
+    writeAnnotations(node: AnnotationAstNode): void;
+    writeBool(node: BoolAstNode): void;
+    encodeUint(node: UintAstNode): void;
+    encodeNint(node: NintAstNode): void;
+    writeFloat(node: FloatAstNode): void;
+    writeVUint(num: number): void;
+    writeStr(node: StrAstNode): void;
+    writeBin(node: BinAstNode): void;
+    writeArr(node: ArrAstNode): void;
+    writeObj(node: ObjAstNode): void;
+}

node_modules/@jsonjoy.com/json-pack/lib/ion/IonEncoderFast.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IonEncoderFast = void 0;
+const Writer_1 = require("@jsonjoy.com/util/lib/buffers/Writer");
+const ast_1 = require("./ast");
+const Import_1 = require("./Import");
+const symbols_1 = require("./symbols");
+class IonEncoderFast {
+    constructor(writer = new Writer_1.Writer()) {
+        this.writer = writer;
+    }
+    encode(value) {
+        this.writer.reset();
+        this.symbols = new Import_1.Import(symbols_1.systemSymbolImport, []);
+        const ast = (0, ast_1.toAst)(value, this.symbols);
+        this.writeIvm();
+        this.writeSymbolTable();
+        this.writeAny(ast);
+        return this.writer.flush();
+    }
+    writeAny(value) {
+        if (value instanceof ast_1.NullAstNode)
+            this.writer.u8(0 + 15);
+        else if (value instanceof ast_1.StrAstNode)
+            this.writeStr(value);
+        else if (value instanceof ast_1.UintAstNode)
+            this.encodeUint(value);
+        else if (value instanceof ast_1.NintAstNode)
+            this.encodeNint(value);
+        else if (value instanceof ast_1.ObjAstNode)
+            this.writeObj(value);
+        else if (value instanceof ast_1.ArrAstNode)
+            this.writeArr(value);
+        else if (value instanceof ast_1.FloatAstNode)
+            this.writeFloat(value);
+        else if (value instanceof ast_1.BoolAstNode)
+            this.writeBool(value);
+        else if (value instanceof ast_1.BinAstNode)
+            this.writeBin(value);
+    }
+    writeIvm() {
+        this.writer.u32(0xe00100ea);
+    }
+    writeSymbolTable() {
+        if (!this.symbols?.length)
+            return;
+        const node = new ast_1.AnnotationAstNode(this.symbols.toAst(), [3]);
+        this.writeAnnotations(node);
+    }
+    writeAnnotations(node) {
+        const writer = this.writer;
+        if (node.len < 14)
+            writer.u8(224 + node.len);
+        else {
+            writer.u8(224 + 14);
+            this.writeVUint(node.len);
+        }
+        this.writeVUint(node.annotationLen);
+        for (let i = 0; i < node.annotations.length; i++)
+            this.writeVUint(node.annotations[i]);
+        this.writeAny(node.val);
+    }
+    writeBool(node) {
+        this.writer.u8(16 + (node.val ? 1 : 0));
+    }
+    encodeUint(node) {
+        const uint = node.val;
+        if (!uint)
+            this.writer.u8(32);
+        else if (uint <= 0xff)
+            this.writer.u16(((32 + 1) << 8) + uint);
+        else if (uint <= 0xffff)
+            this.writer.u8u16(32 + 2, uint);
+        else if (uint <= 0xffffff)
+            this.writer.u32(((32 + 3) << 24) + uint);
+        else if (uint <= 0xffffffff)
+            this.writer.u8u32(32 + 4, uint);
+        else {
+            let lo = uint | 0;
+            if (lo < 0)
+                lo += 4294967296;
+            let hi = uint - lo;
+            hi /= 4294967296;
+            if (uint <= 0xffffffffff) {
+                this.writer.u16(((32 + 5) << 8) + hi);
+                this.writer.u32(lo);
+            }
+            else if (uint <= 0xffffffffffff) {
+                this.writer.u8u16(32 + 6, hi);
+                this.writer.u32(lo);
+            }
+            else {
+                this.writer.u16(((32 + 7) << 8) + (hi >> 16));
+                this.writer.u16(hi & 0xffff);
+                this.writer.u32(lo);
+            }
+        }
+    }
+    encodeNint(node) {
+        const uint = -node.val;
+        if (uint <= 0xff)
+            this.writer.u16(((48 + 1) << 8) + uint);
+        else if (uint <= 0xffff)
+            this.writer.u8u16(48 + 2, uint);
+        else if (uint <= 0xffffff)
+            this.writer.u32(((48 + 3) << 24) + uint);
+        else if (uint <= 0xffffffff)
+            this.writer.u8u32(48 + 4, uint);
+        else {
+            let lo = uint | 0;
+            if (lo < 0)
+                lo += 4294967296;
+            let hi = uint - lo;
+            hi /= 4294967296;
+            if (uint <= 0xffffffffff) {
+                this.writer.u16(((48 + 5) << 8) + hi);
+                this.writer.u32(lo);
+            }
+            else if (uint <= 0xffffffffffff) {
+                this.writer.u8u16(48 + 6, hi);
+                this.writer.u32(lo);
+            }
+            else {
+                this.writer.u16(((48 + 7) << 8) + (hi >> 16));
+                this.writer.u16(hi & 0xffff);
+                this.writer.u32(lo);
+            }
+        }
+    }
+    writeFloat(node) {
+        this.writer.u8f64(64 + 8, node.val);
+    }
+    writeVUint(num) {
+        const writer = this.writer;
+        if (num <= 0b1111111) {
+            writer.u8(0b10000000 + num);
+        }
+        else if (num <= 16383) {
+            writer.ensureCapacity(2);
+            const uint8 = writer.uint8;
+            uint8[writer.x++] = num >>> 7;
+            uint8[writer.x++] = 0b10000000 + (num & 0b01111111);
+        }
+        else if (num <= 2097151) {
+            writer.ensureCapacity(3);
+            const uint8 = writer.uint8;
+            uint8[writer.x++] = num >>> 14;
+            uint8[writer.x++] = (num >>> 7) & 0b01111111;
+            uint8[writer.x++] = 0b10000000 + (num & 0b01111111);
+        }
+        else if (num <= 268435455) {
+            writer.ensureCapacity(4);
+            const uint8 = writer.uint8;
+            uint8[writer.x++] = num >>> 21;
+            uint8[writer.x++] = (num >>> 14) & 0b01111111;
+            uint8[writer.x++] = (num >>> 7) & 0b01111111;
+            uint8[writer.x++] = 0b10000000 + (num & 0b01111111);
+        }
+        else {
+            let lo32 = num | 0;
+            if (lo32 < 0)
+                lo32 += 4294967296;
+            const hi32 = (num - lo32) / 4294967296;
+            if (num <= 34359738367) {
+                writer.ensureCapacity(5);
+                const uint8 = writer.uint8;
+                uint8[writer.x++] = (hi32 << 4) | (num >>> 28);
+                uint8[writer.x++] = (num >>> 21) & 0b01111111;
+                uint8[writer.x++] = (num >>> 14) & 0b01111111;
+                uint8[writer.x++] = (num >>> 7) & 0b01111111;
+                uint8[writer.x++] = 0b10000000 + (num & 0b01111111);
+            }
+            else if (num <= 4398046511103) {
+                writer.ensureCapacity(6);
+                const uint8 = writer.uint8;
+                uint8[writer.x++] = (hi32 >>> 3) & 0b1111;
+                uint8[writer.x++] = ((hi32 & 0b111) << 4) | (num >>> 28);
+                uint8[writer.x++] = (num >>> 21) & 0b01111111;
+                uint8[writer.x++] = (num >>> 14) & 0b01111111;
+                uint8[writer.x++] = (num >>> 7) & 0b01111111;
+                uint8[writer.x++] = 0b10000000 + (num & 0b01111111);
+            }
+        }
+    }
+    writeStr(node) {
+        const str = node.val;
+        const length = node.len;
+        const writer = this.writer;
+        if (length < 14)
+            writer.u8(128 + length);
+        else {
+            writer.u8(128 + 14);
+            this.writeVUint(length);
+        }
+        writer.utf8(str);
+    }
+    writeBin(node) {
+        const buf = node.val;
+        const length = node.len;
+        const writer = this.writer;
+        if (length < 14)
+            writer.u8(160 + length);
+        else {
+            writer.u8(160 + 14);
+            this.writeVUint(length);
+        }
+        writer.buf(buf, length);
+    }
+    writeArr(node) {
+        const writer = this.writer;
+        const arr = node.val;
+        if (arr === null) {
+            writer.u8(176 + 15);
+            return;
+        }
+        const length = node.len;
+        if (length < 14)
+            writer.u8(176 + length);
+        else {
+            writer.u8(176 + 14);
+            this.writeVUint(length);
+        }
+        for (let i = 0; i < length; i++)
+            this.writeAny(arr[i]);
+    }
+    writeObj(node) {
+        const writer = this.writer;
+        const arr = node.val;
+        if (arr === null) {
+            writer.u8(176 + 15);
+            return;
+        }
+        const length = node.len;
+        if (length < 14)
+            writer.u8(208 + length);
+        else {
+            writer.u8(208 + 14);
+            this.writeVUint(length);
+        }
+        node.val.forEach((n, symbolId) => {
+            this.writeVUint(symbolId);
+            this.writeAny(n);
+        });
+    }
+}
+exports.IonEncoderFast = IonEncoderFast;
+//# sourceMappingURL=IonEncoderFast.js.map

node_modules/@jsonjoy.com/json-pack/lib/ion/ast.d.ts

@@ -0,0 +1,68 @@
+import { Import } from './Import';
+export interface AstNode<T> {
+    readonly val: T;
+    readonly len: number;
+    byteLength(): number;
+}
+export declare class NullAstNode implements AstNode<null> {
+    readonly val: null;
+    readonly len = 1;
+    byteLength(): number;
+}
+export declare class BoolAstNode implements AstNode<boolean> {
+    readonly val: boolean;
+    readonly len = 1;
+    constructor(val: boolean);
+    byteLength(): number;
+}
+export declare class UintAstNode implements AstNode<number> {
+    readonly val: number;
+    readonly len: number;
+    constructor(val: number);
+    byteLength(): number;
+}
+export declare class NintAstNode implements AstNode<number> {
+    readonly val: number;
+    readonly len: number;
+    constructor(val: number);
+    byteLength(): number;
+}
+export declare class FloatAstNode implements AstNode<number> {
+    readonly val: number;
+    readonly len: number;
+    constructor(val: number);
+    byteLength(): number;
+}
+export declare class StrAstNode implements AstNode<string> {
+    readonly val: string;
+    readonly len: number;
+    constructor(val: string);
+    byteLength(): number;
+}
+export declare class BinAstNode implements AstNode<Uint8Array> {
+    readonly val: Uint8Array;
+    readonly len: number;
+    constructor(val: Uint8Array);
+    byteLength(): number;
+}
+export declare class ArrAstNode implements AstNode<AstNode<unknown>[] | null> {
+    readonly val: AstNode<unknown>[] | null;
+    readonly len: number;
+    constructor(val: AstNode<unknown>[] | null);
+    byteLength(): number;
+}
+export declare class ObjAstNode implements AstNode<Map<number, AstNode<unknown>> | null> {
+    readonly val: Map<number, AstNode<unknown>> | null;
+    readonly len: number;
+    constructor(val: Map<number, AstNode<unknown>> | null);
+    byteLength(): number;
+}
+export declare class AnnotationAstNode implements AstNode<AstNode<unknown>> {
+    readonly val: AstNode<unknown>;
+    readonly annotations: number[];
+    readonly len: number;
+    readonly annotationLen: number;
+    constructor(val: AstNode<unknown>, annotations: number[]);
+    byteLength(): number;
+}
+export declare const toAst: (val: unknown, symbols: Import) => AstNode<unknown>;

node_modules/@jsonjoy.com/json-pack/lib/ion/ast.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAst = exports.AnnotationAstNode = exports.ObjAstNode = exports.ArrAstNode = exports.BinAstNode = exports.StrAstNode = exports.FloatAstNode = exports.NintAstNode = exports.UintAstNode = exports.BoolAstNode = exports.NullAstNode = void 0;
+const utf8_1 = require("@jsonjoy.com/util/lib/strings/utf8");
+class NullAstNode {
+    constructor() {
+        this.val = null;
+        this.len = 1;
+    }
+    byteLength() {
+        return 1;
+    }
+}
+exports.NullAstNode = NullAstNode;
+class BoolAstNode {
+    constructor(val) {
+        this.val = val;
+        this.len = 1;
+    }
+    byteLength() {
+        return 1;
+    }
+}
+exports.BoolAstNode = BoolAstNode;
+class UintAstNode {
+    constructor(val) {
+        this.val = val;
+        if (!val)
+            this.len = 0;
+        else if (val <= 0xff)
+            this.len = 1;
+        else if (val <= 0xffff)
+            this.len = 2;
+        else if (val <= 0xffffff)
+            this.len = 3;
+        else if (val <= 0xffffffff)
+            this.len = 4;
+        else if (val <= 0xffffffffff)
+            this.len = 5;
+        else if (val <= 0xffffffffffff)
+            this.len = 6;
+        else
+            this.len = 7;
+    }
+    byteLength() {
+        return 1 + this.len;
+    }
+}
+exports.UintAstNode = UintAstNode;
+class NintAstNode {
+    constructor(val) {
+        this.val = val;
+        const uint = -val;
+        if (!uint)
+            this.len = 0;
+        else if (uint <= 0xff)
+            this.len = 1;
+        else if (uint <= 0xffff)
+            this.len = 2;
+        else if (uint <= 0xffffff)
+            this.len = 3;
+        else if (uint <= 0xffffffff)
+            this.len = 4;
+        else if (uint <= 0xffffffffff)
+            this.len = 5;
+        else if (uint <= 0xffffffffffff)
+            this.len = 6;
+        else
+            this.len = 7;
+    }
+    byteLength() {
+        return 1 + this.len;
+    }
+}
+exports.NintAstNode = NintAstNode;
+class FloatAstNode {
+    constructor(val) {
+        this.val = val;
+        this.len = 8;
+    }
+    byteLength() {
+        return 1 + this.len;
+    }
+}
+exports.FloatAstNode = FloatAstNode;
+const vUintLen = (num) => {
+    if (num <= 0b1111111)
+        return 1;
+    else if (num <= 16383)
+        return 2;
+    else if (num <= 2097151)
+        return 3;
+    else if (num <= 268435455)
+        return 4;
+    else if (num <= 34359738367)
+        return 5;
+    else
+        return 6;
+};
+class StrAstNode {
+    constructor(val) {
+        this.val = val;
+        this.len = (0, utf8_1.utf8Size)(val);
+    }
+    byteLength() {
+        return this.len < 14 ? 1 + this.len : 1 + vUintLen(this.len) + this.len;
+    }
+}
+exports.StrAstNode = StrAstNode;
+class BinAstNode {
+    constructor(val) {
+        this.val = val;
+        this.len = val.length;
+    }
+    byteLength() {
+        return this.len < 14 ? 1 + this.len : 1 + vUintLen(this.len) + this.len;
+    }
+}
+exports.BinAstNode = BinAstNode;
+class ArrAstNode {
+    constructor(val) {
+        this.val = val;
+        if (val === null) {
+            this.len = 1;
+        }
+        else {
+            if (!val.length)
+                this.len = 0;
+            else {
+                let elementLength = 0;
+                for (let i = 0; i < val.length; i++)
+                    elementLength += val[i].byteLength();
+                this.len = elementLength;
+            }
+        }
+    }
+    byteLength() {
+        return this.len < 14 ? 1 + this.len : 1 + vUintLen(this.len) + this.len;
+    }
+}
+exports.ArrAstNode = ArrAstNode;
+class ObjAstNode {
+    constructor(val) {
+        this.val = val;
+        if (val === null) {
+            this.len = 1;
+        }
+        else {
+            if (!val.size)
+                this.len = 0;
+            else {
+                let len = 0;
+                val.forEach((node, symbolId) => {
+                    len += vUintLen(symbolId) + node.byteLength();
+                });
+                this.len = len;
+            }
+        }
+    }
+    byteLength() {
+        return this.len < 14 ? 1 + this.len : 1 + vUintLen(this.len) + this.len;
+    }
+}
+exports.ObjAstNode = ObjAstNode;
+class AnnotationAstNode {
+    constructor(val, annotations) {
+        this.val = val;
+        this.annotations = annotations;
+        let len = 0;
+        for (let i = 0; i < annotations.length; i++)
+            len += vUintLen(annotations[i]);
+        this.annotationLen = len;
+        len += vUintLen(len);
+        len += val.byteLength();
+        this.len = len;
+    }
+    byteLength() {
+        return this.len < 14 ? 1 + this.len : 1 + vUintLen(this.len) + this.len;
+    }
+}
+exports.AnnotationAstNode = AnnotationAstNode;
+const isSafeInteger = Number.isSafeInteger;
+const toAst = (val, symbols) => {
+    if (val === null)
+        return new NullAstNode();
+    if (val instanceof Array)
+        return new ArrAstNode(val.map((el) => (0, exports.toAst)(el, symbols)));
+    if (val instanceof Uint8Array)
+        return new BinAstNode(val);
+    switch (typeof val) {
+        case 'boolean':
+            return new BoolAstNode(val);
+        case 'number': {
+            if (isSafeInteger(val))
+                return val >= 0 ? new UintAstNode(val) : new NintAstNode(val);
+            else
+                return new FloatAstNode(val);
+        }
+        case 'string':
+            return new StrAstNode(val);
+        case 'object': {
+            const struct = new Map();
+            for (const key in val) {
+                const symbolId = symbols.add(key);
+                struct.set(symbolId, (0, exports.toAst)(val[key], symbols));
+            }
+            return new ObjAstNode(struct);
+        }
+    }
+    throw new Error('UNKNOWN_TYPE');
+};
+exports.toAst = toAst;
+//# sourceMappingURL=ast.js.map

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

@@ -0,0 +1,24 @@
+export declare const enum TYPE {
+    NULL = 0,
+    BOOL = 1,
+    UINT = 2,
+    NINT = 3,
+    FLOT = 4,
+    STRI = 8,
+    LIST = 11,
+    BINA = 10,
+    STRU = 13,
+    ANNO = 14
+}
+export declare const enum TYPE_OVERLAY {
+    NULL = 0,
+    BOOL = 16,
+    UINT = 32,
+    NINT = 48,
+    FLOT = 64,
+    STRI = 128,
+    LIST = 176,
+    BINA = 160,
+    STRU = 208,
+    ANNO = 224
+}

node_modules/@jsonjoy.com/json-pack/lib/ion/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/ion/constants.js.map

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

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

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './constants';
+export * from './Import';
+export * from './IonEncoderFast';
+export * from './symbols';

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./Import"), exports);
+tslib_1.__exportStar(require("./IonEncoderFast"), exports);
+tslib_1.__exportStar(require("./symbols"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ion/index.ts"],"names":[],"mappings":";;;AAAA,kDAAwB;AACxB,sDAA4B;AAC5B,mDAAyB;AACzB,2DAAiC;AACjC,oDAA0B"}

node_modules/@jsonjoy.com/json-pack/lib/ion/symbols.d.ts

@@ -0,0 +1,4 @@
+import { Import } from './Import';
+import { SymbolTable } from './types';
+export declare const systemSymbolTable: SymbolTable;
+export declare const systemSymbolImport: Import;

node_modules/@jsonjoy.com/json-pack/lib/ion/symbols.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemSymbolImport = exports.systemSymbolTable = void 0;
+const Import_1 = require("./Import");
+exports.systemSymbolTable = [
+    '$ion',
+    '$ion_1_0',
+    '$ion_symbol_table',
+    'name',
+    'version',
+    'imports',
+    'symbols',
+    'max_id',
+    '$ion_shared_symbol_table',
+];
+exports.systemSymbolImport = new Import_1.Import(null, exports.systemSymbolTable);
+//# sourceMappingURL=symbols.js.map

node_modules/@jsonjoy.com/json-pack/lib/ion/symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../src/ion/symbols.ts"],"names":[],"mappings":";;;AAAA,qCAAgC;AAGnB,QAAA,iBAAiB,GAAgB;IAC5C,MAAM;IACN,UAAU;IACV,mBAAmB;IACnB,MAAM;IACN,SAAS;IACT,SAAS;IACT,SAAS;IACT,QAAQ;IACR,0BAA0B;CAC3B,CAAC;AAEW,QAAA,kBAAkB,GAAG,IAAI,eAAM,CAAC,IAAI,EAAE,yBAAiB,CAAC,CAAC"}

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

@@ -0,0 +1 @@
+export type SymbolTable = string[];