first commit

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 '@jsonjoy.com/json-pointer';
+import type { IReader, IReaderResettable } from '@jsonjoy.com/buffers/lib';
+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.readAny();
+            const value = this.readAny();
+            map.set(key, value);
+        }
+        return map;
+    }
+    readMapIndef() {
+        const map = new Map();
+        while (this.reader.peak() !== 255) {
+            const key = this.readAny();
+            if (this.reader.peak() === 255)
+                throw 7;
+            const value = this.readAny();
+            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.readAny();
+        }
+    }
+    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,35 @@
+import { JsonPackExtension } from '../JsonPackExtension';
+import { JsonPackValue } from '../JsonPackValue';
+import type { CachedUtf8Decoder } from '@jsonjoy.com/buffers/lib/utf8/CachedUtf8Decoder';
+import type { IReader, IReaderResettable } from '@jsonjoy.com/buffers/lib';
+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;
+    readAny(): 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,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CborDecoderBase = void 0;
+const tslib_1 = require("tslib");
+const f16_1 = require("@jsonjoy.com/buffers/lib/f16");
+const JsonPackExtension_1 = require("../JsonPackExtension");
+const JsonPackValue_1 = require("../JsonPackValue");
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const sharedCachedUtf8Decoder_1 = tslib_1.__importDefault(require("@jsonjoy.com/buffers/lib/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.readAny();
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.readAny();
+    }
+    val() {
+        return this.readAny();
+    }
+    readAny() {
+        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.readAny());
+        return arr;
+    }
+    readArrIndef() {
+        const arr = [];
+        while (this.reader.peak() !== 255)
+            arr.push(this.readAny());
+        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.readAny();
+                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.readAny();
+            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.readAny();
+            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.readAny());
+    }
+    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.readAny();
+        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,OAAO,EAAE,CAAC;QAC7B,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/buffers/lib';
+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/buffers/lib/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/buffers/lib';
+import type { BinaryJsonEncoder, StreamingBinaryJsonEncoder, TlvBinaryJsonEncoder } from '../types';
+import type { Slice } from '@jsonjoy.com/buffers/lib/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/buffers/lib/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/buffers").IWriter & import("@jsonjoy.com/buffers").IWriterGrowable>;
+export declare const decoder: CborDecoder<import("@jsonjoy.com/buffers").IReader & import("@jsonjoy.com/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":""}