first 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/JsonPackMpint.d.ts

@@ -0,0 +1,8 @@
+export declare class JsonPackMpint {
+    readonly data: Uint8Array;
+    constructor(data: Uint8Array);
+    static fromBigInt(value: bigint): JsonPackMpint;
+    toBigInt(): bigint;
+    static fromNumber(value: number): JsonPackMpint;
+    toNumber(): number;
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonPackMpint = void 0;
+class JsonPackMpint {
+    constructor(data) {
+        this.data = data;
+    }
+    static fromBigInt(value) {
+        if (value === BigInt(0)) {
+            return new JsonPackMpint(new Uint8Array(0));
+        }
+        const negative = value < BigInt(0);
+        const bytes = [];
+        if (negative) {
+            const absValue = -value;
+            const bitLength = absValue.toString(2).length;
+            const byteLength = Math.ceil((bitLength + 1) / 8);
+            const twoComplement = (BigInt(1) << BigInt(byteLength * 8)) + value;
+            for (let i = byteLength - 1; i >= 0; i--) {
+                bytes.push(Number((twoComplement >> BigInt(i * 8)) & BigInt(0xff)));
+            }
+            while (bytes.length > 0 && bytes[0] === 0xff && bytes.length > 1 && (bytes[1] & 0x80) !== 0) {
+                bytes.shift();
+            }
+        }
+        else {
+            let tempValue = value;
+            while (tempValue > BigInt(0)) {
+                bytes.unshift(Number(tempValue & BigInt(0xff)));
+                tempValue >>= BigInt(8);
+            }
+            if (bytes[0] & 0x80) {
+                bytes.unshift(0);
+            }
+        }
+        return new JsonPackMpint(new Uint8Array(bytes));
+    }
+    toBigInt() {
+        if (this.data.length === 0) {
+            return BigInt(0);
+        }
+        const negative = (this.data[0] & 0x80) !== 0;
+        if (negative) {
+            let value = BigInt(0);
+            for (let i = 0; i < this.data.length; i++) {
+                value = (value << BigInt(8)) | BigInt(this.data[i]);
+            }
+            const bitLength = this.data.length * 8;
+            return value - (BigInt(1) << BigInt(bitLength));
+        }
+        else {
+            let value = BigInt(0);
+            for (let i = 0; i < this.data.length; i++) {
+                value = (value << BigInt(8)) | BigInt(this.data[i]);
+            }
+            return value;
+        }
+    }
+    static fromNumber(value) {
+        if (!Number.isInteger(value)) {
+            throw new Error('Value must be an integer');
+        }
+        return JsonPackMpint.fromBigInt(BigInt(value));
+    }
+    toNumber() {
+        const bigIntValue = this.toBigInt();
+        if (bigIntValue > BigInt(Number.MAX_SAFE_INTEGER) || bigIntValue < BigInt(Number.MIN_SAFE_INTEGER)) {
+            throw new Error('Value is outside safe integer range');
+        }
+        return Number(bigIntValue);
+    }
+}
+exports.JsonPackMpint = JsonPackMpint;
+//# sourceMappingURL=JsonPackMpint.js.map

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

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

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/avro/AvroDecoder.d.ts

@@ -0,0 +1,29 @@
+import { Reader } from '@jsonjoy.com/buffers/lib/Reader';
+import type { BinaryJsonDecoder } from '../types';
+export declare class AvroDecoder implements BinaryJsonDecoder {
+    reader: Reader;
+    read(uint8: Uint8Array): unknown;
+    decode(uint8: Uint8Array): unknown;
+    readAny(): unknown;
+    readNull(): null;
+    readBoolean(): boolean;
+    readInt(): number;
+    readLong(): number | bigint;
+    readFloat(): number;
+    readDouble(): number;
+    readBytes(): Uint8Array;
+    readString(): string;
+    readArray<T>(itemReader: () => T): T[];
+    readMap<T>(valueReader: () => T): Record<string, T>;
+    readUnion<T>(schemaReaders: Array<() => T>): {
+        index: number;
+        value: T;
+    };
+    readEnum(): number;
+    readFixed(size: number): Uint8Array;
+    readRecord<T>(fieldReaders: Array<() => any>): T;
+    private readVarIntUnsigned;
+    private readVarLong;
+    private decodeZigZag32;
+    private decodeZigZag64;
+}

node_modules/@jsonjoy.com/json-pack/lib/avro/AvroDecoder.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvroDecoder = void 0;
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+class AvroDecoder {
+    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() {
+        throw new Error('readAny() requires schema information. Use readNull, readBoolean, etc. directly.');
+    }
+    readNull() {
+        return null;
+    }
+    readBoolean() {
+        return this.reader.u8() === 1;
+    }
+    readInt() {
+        const zigzag = this.readVarIntUnsigned();
+        return this.decodeZigZag32(zigzag);
+    }
+    readLong() {
+        const zigzag = this.readVarLong();
+        const decoded = this.decodeZigZag64(zigzag);
+        if (decoded >= BigInt(Number.MIN_SAFE_INTEGER) && decoded <= BigInt(Number.MAX_SAFE_INTEGER)) {
+            return Number(decoded);
+        }
+        return decoded;
+    }
+    readFloat() {
+        const reader = this.reader;
+        const value = reader.view.getFloat32(reader.x, true);
+        reader.x += 4;
+        return value;
+    }
+    readDouble() {
+        const reader = this.reader;
+        const value = reader.view.getFloat64(reader.x, true);
+        reader.x += 8;
+        return value;
+    }
+    readBytes() {
+        const length = this.readVarIntUnsigned();
+        return this.reader.buf(length);
+    }
+    readString() {
+        const length = this.readVarIntUnsigned();
+        const bytes = this.reader.buf(length);
+        return new TextDecoder().decode(bytes);
+    }
+    readArray(itemReader) {
+        const result = [];
+        while (true) {
+            const count = this.readVarIntUnsigned();
+            if (count === 0)
+                break;
+            for (let i = 0; i < count; i++) {
+                result.push(itemReader());
+            }
+        }
+        return result;
+    }
+    readMap(valueReader) {
+        const result = {};
+        while (true) {
+            const count = this.readVarIntUnsigned();
+            if (count === 0)
+                break;
+            for (let i = 0; i < count; i++) {
+                const key = this.readString();
+                if (key === '__proto__')
+                    throw new Error('INVALID_KEY');
+                result[key] = valueReader();
+            }
+        }
+        return result;
+    }
+    readUnion(schemaReaders) {
+        const index = this.decodeZigZag32(this.readVarIntUnsigned());
+        if (index < 0 || index >= schemaReaders.length) {
+            throw new Error(`Invalid union index: ${index}`);
+        }
+        const value = schemaReaders[index]();
+        return { index, value };
+    }
+    readEnum() {
+        return this.decodeZigZag32(this.readVarIntUnsigned());
+    }
+    readFixed(size) {
+        return this.reader.buf(size);
+    }
+    readRecord(fieldReaders) {
+        const result = {};
+        for (let i = 0; i < fieldReaders.length; i++) {
+            const fieldValue = fieldReaders[i]();
+            result[`field${i}`] = fieldValue;
+        }
+        return result;
+    }
+    readVarIntUnsigned() {
+        const reader = this.reader;
+        let result = 0;
+        let shift = 0;
+        while (true) {
+            const byte = reader.u8();
+            result |= (byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0)
+                break;
+            shift += 7;
+            if (shift >= 32) {
+                throw new Error('Variable-length integer is too long');
+            }
+        }
+        return result >>> 0;
+    }
+    readVarLong() {
+        const reader = this.reader;
+        let result = BigInt(0);
+        let shift = BigInt(0);
+        while (true) {
+            const byte = BigInt(reader.u8());
+            result |= (byte & BigInt(0x7f)) << shift;
+            if ((byte & BigInt(0x80)) === BigInt(0))
+                break;
+            shift += BigInt(7);
+            if (shift >= BigInt(64)) {
+                throw new Error('Variable-length long is too long');
+            }
+        }
+        return result;
+    }
+    decodeZigZag32(value) {
+        return (value >>> 1) ^ -(value & 1);
+    }
+    decodeZigZag64(value) {
+        return (value >> BigInt(1)) ^ -(value & BigInt(1));
+    }
+}
+exports.AvroDecoder = AvroDecoder;
+//# sourceMappingURL=AvroDecoder.js.map

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

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

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

@@ -0,0 +1,30 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+import type { BinaryJsonEncoder } from '../types';
+export declare class AvroEncoder implements BinaryJsonEncoder {
+    readonly writer: IWriter & IWriterGrowable;
+    constructor(writer: IWriter & IWriterGrowable);
+    encode(value: unknown): Uint8Array;
+    writeUnknown(value: unknown): void;
+    writeAny(value: unknown): void;
+    writeNull(): void;
+    writeBoolean(bool: boolean): void;
+    writeInt(int: number): void;
+    writeLong(long: number | bigint): void;
+    writeFloatAvro(float: number): void;
+    writeDouble(double: number): void;
+    writeBin(bytes: Uint8Array): void;
+    writeStr(str: string): void;
+    writeArr(arr: unknown[]): void;
+    writeObj(obj: Record<string, unknown>): void;
+    writeNumber(num: number): void;
+    writeInteger(int: number): void;
+    writeUInteger(uint: number): void;
+    writeFloat(float: number): void;
+    private writeFloatValue;
+    writeAsciiStr(str: string): void;
+    private writeVarIntSigned;
+    private writeVarIntUnsigned;
+    private writeVarLong;
+    private encodeZigZag32;
+    private encodeZigZag64;
+}

node_modules/@jsonjoy.com/json-pack/lib/avro/AvroEncoder.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvroEncoder = void 0;
+class AvroEncoder {
+    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);
+                    default:
+                        return this.writeUnknown(value);
+                }
+            }
+            case 'bigint':
+                return this.writeLong(value);
+            case 'undefined':
+                return this.writeNull();
+            default:
+                return this.writeUnknown(value);
+        }
+    }
+    writeNull() {
+    }
+    writeBoolean(bool) {
+        this.writer.u8(bool ? 1 : 0);
+    }
+    writeInt(int) {
+        this.writeVarIntSigned(this.encodeZigZag32(Math.trunc(int)));
+    }
+    writeLong(long) {
+        if (typeof long === 'bigint') {
+            this.writeVarLong(this.encodeZigZag64(long));
+        }
+        else {
+            this.writeVarLong(this.encodeZigZag64(BigInt(Math.trunc(long))));
+        }
+    }
+    writeFloatAvro(float) {
+        const writer = this.writer;
+        writer.ensureCapacity(4);
+        writer.view.setFloat32(writer.x, float, true);
+        writer.move(4);
+    }
+    writeDouble(double) {
+        const writer = this.writer;
+        writer.ensureCapacity(8);
+        writer.view.setFloat64(writer.x, double, true);
+        writer.move(8);
+    }
+    writeBin(bytes) {
+        this.writeVarIntUnsigned(bytes.length);
+        this.writer.buf(bytes, bytes.length);
+    }
+    writeStr(str) {
+        const writer = this.writer;
+        const maxSize = str.length * 4;
+        writer.ensureCapacity(5 + maxSize);
+        const lengthOffset = writer.x;
+        writer.x += 5;
+        const bytesWritten = writer.utf8(str);
+        const endPos = writer.x;
+        writer.x = lengthOffset;
+        this.writeVarIntUnsigned(bytesWritten);
+        const actualLengthSize = writer.x - lengthOffset;
+        if (actualLengthSize < 5) {
+            const stringStart = lengthOffset + 5;
+            const stringData = writer.uint8.slice(stringStart, endPos);
+            writer.x = lengthOffset + actualLengthSize;
+            writer.buf(stringData, stringData.length);
+        }
+        else {
+            writer.x = endPos;
+        }
+    }
+    writeArr(arr) {
+        this.writeVarIntUnsigned(arr.length);
+        const length = arr.length;
+        for (let i = 0; i < length; i++) {
+            this.writeAny(arr[i]);
+        }
+        this.writeVarIntUnsigned(0);
+    }
+    writeObj(obj) {
+        const entries = Object.entries(obj);
+        const length = entries.length;
+        this.writeVarIntUnsigned(length);
+        for (let i = 0; i < length; i++) {
+            const entry = entries[i];
+            this.writeStr(entry[0]);
+            this.writeAny(entry[1]);
+        }
+        this.writeVarIntUnsigned(0);
+    }
+    writeNumber(num) {
+        if (Number.isInteger(num)) {
+            if (num >= -2147483648 && num <= 2147483647) {
+                this.writeInt(num);
+            }
+            else {
+                this.writeLong(num);
+            }
+        }
+        else {
+            this.writeDouble(num);
+        }
+    }
+    writeInteger(int) {
+        this.writeInt(int);
+    }
+    writeUInteger(uint) {
+        this.writeInt(uint);
+    }
+    writeFloat(float) {
+        this.writeFloatValue(float);
+    }
+    writeFloatValue(float) {
+        const writer = this.writer;
+        writer.ensureCapacity(4);
+        writer.view.setFloat32(writer.x, float, true);
+        writer.move(4);
+    }
+    writeAsciiStr(str) {
+        const writer = this.writer;
+        this.writeVarIntUnsigned(str.length);
+        writer.ascii(str);
+    }
+    writeVarIntSigned(value) {
+        const writer = this.writer;
+        let n = value >>> 0;
+        while (n >= 0x80) {
+            writer.u8((n & 0x7f) | 0x80);
+            n >>>= 7;
+        }
+        writer.u8(n & 0x7f);
+    }
+    writeVarIntUnsigned(value) {
+        const writer = this.writer;
+        let n = value >>> 0;
+        while (n >= 0x80) {
+            writer.u8((n & 0x7f) | 0x80);
+            n >>>= 7;
+        }
+        writer.u8(n & 0x7f);
+    }
+    writeVarLong(value) {
+        const writer = this.writer;
+        let n = value;
+        const mask = BigInt(0x7f);
+        const shift = BigInt(7);
+        while (n >= BigInt(0x80)) {
+            writer.u8(Number((n & mask) | BigInt(0x80)));
+            n >>= shift;
+        }
+        writer.u8(Number(n & mask));
+    }
+    encodeZigZag32(value) {
+        return (value << 1) ^ (value >> 31);
+    }
+    encodeZigZag64(value) {
+        return (value << BigInt(1)) ^ (value >> BigInt(63));
+    }
+}
+exports.AvroEncoder = AvroEncoder;
+//# sourceMappingURL=AvroEncoder.js.map

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

@@ -0,0 +1,29 @@
+import { Reader } from '@jsonjoy.com/buffers/lib/Reader';
+import type { AvroSchema } from './types';
+export declare class AvroSchemaDecoder {
+    readonly reader: Reader;
+    private decoder;
+    private validator;
+    private namedSchemas;
+    constructor(reader?: Reader);
+    decode(data: Uint8Array, schema: AvroSchema): unknown;
+    private readValue;
+    private readRecord;
+    private readEnum;
+    private readArray;
+    private readMap;
+    private readUnion;
+    private readFixed;
+    readNull(schema: AvroSchema): null;
+    readBoolean(schema: AvroSchema): boolean;
+    readInt(schema: AvroSchema): number;
+    readLong(schema: AvroSchema): number | bigint;
+    readFloat(schema: AvroSchema): number;
+    readDouble(schema: AvroSchema): number;
+    readBytes(schema: AvroSchema): Uint8Array;
+    readString(schema: AvroSchema): string;
+    private validateSchemaType;
+    private resolveSchema;
+    private collectNamedSchemas;
+    private getFullName;
+}

node_modules/@jsonjoy.com/json-pack/lib/avro/AvroSchemaDecoder.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvroSchemaDecoder = void 0;
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const AvroDecoder_1 = require("./AvroDecoder");
+const AvroSchemaValidator_1 = require("./AvroSchemaValidator");
+class AvroSchemaDecoder {
+    constructor(reader = new Reader_1.Reader()) {
+        this.reader = reader;
+        this.namedSchemas = new Map();
+        this.decoder = new AvroDecoder_1.AvroDecoder();
+        this.decoder.reader = reader;
+        this.validator = new AvroSchemaValidator_1.AvroSchemaValidator();
+    }
+    decode(data, schema) {
+        this.reader.reset(data);
+        this.namedSchemas.clear();
+        if (!this.validator.validateSchema(schema)) {
+            throw new Error('Invalid Avro schema');
+        }
+        this.collectNamedSchemas(schema);
+        return this.readValue(schema);
+    }
+    readValue(schema) {
+        const resolvedSchema = this.resolveSchema(schema);
+        if (typeof resolvedSchema === 'string') {
+            switch (resolvedSchema) {
+                case 'null':
+                    return this.decoder.readNull();
+                case 'boolean':
+                    return this.decoder.readBoolean();
+                case 'int':
+                    return this.decoder.readInt();
+                case 'long':
+                    return this.decoder.readLong();
+                case 'float':
+                    return this.decoder.readFloat();
+                case 'double':
+                    return this.decoder.readDouble();
+                case 'bytes':
+                    return this.decoder.readBytes();
+                case 'string':
+                    return this.decoder.readString();
+                default:
+                    throw new Error(`Unknown primitive type: ${resolvedSchema}`);
+            }
+        }
+        if (Array.isArray(resolvedSchema)) {
+            return this.readUnion(resolvedSchema);
+        }
+        switch (resolvedSchema.type) {
+            case 'record':
+                return this.readRecord(resolvedSchema);
+            case 'enum':
+                return this.readEnum(resolvedSchema);
+            case 'array':
+                return this.readArray(resolvedSchema);
+            case 'map':
+                return this.readMap(resolvedSchema);
+            case 'fixed':
+                return this.readFixed(resolvedSchema);
+            default:
+                throw new Error(`Unknown schema type: ${resolvedSchema.type}`);
+        }
+    }
+    readRecord(schema) {
+        const result = {};
+        for (let i = 0; i < schema.fields.length; i++) {
+            const field = schema.fields[i];
+            try {
+                result[field.name] = this.readValue(field.type);
+            }
+            catch (error) {
+                throw new Error(`Error reading field '${field.name}': ${error.message}`);
+            }
+        }
+        return result;
+    }
+    readEnum(schema) {
+        const index = this.decoder.readEnum();
+        if (index < 0 || index >= schema.symbols.length) {
+            throw new Error(`Invalid enum index ${index} for enum with ${schema.symbols.length} symbols`);
+        }
+        return schema.symbols[index];
+    }
+    readArray(schema) {
+        return this.decoder.readArray(() => this.readValue(schema.items));
+    }
+    readMap(schema) {
+        return this.decoder.readMap(() => this.readValue(schema.values));
+    }
+    readUnion(schema) {
+        const schemaReaders = schema.map((subSchema) => () => this.readValue(subSchema));
+        const result = this.decoder.readUnion(schemaReaders);
+        return result.value;
+    }
+    readFixed(schema) {
+        return this.decoder.readFixed(schema.size);
+    }
+    readNull(schema) {
+        this.validateSchemaType(schema, 'null');
+        return this.decoder.readNull();
+    }
+    readBoolean(schema) {
+        this.validateSchemaType(schema, 'boolean');
+        return this.decoder.readBoolean();
+    }
+    readInt(schema) {
+        this.validateSchemaType(schema, 'int');
+        const value = this.decoder.readInt();
+        if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) {
+            throw new Error('Decoded value is not a valid 32-bit integer');
+        }
+        return value;
+    }
+    readLong(schema) {
+        this.validateSchemaType(schema, 'long');
+        return this.decoder.readLong();
+    }
+    readFloat(schema) {
+        this.validateSchemaType(schema, 'float');
+        return this.decoder.readFloat();
+    }
+    readDouble(schema) {
+        this.validateSchemaType(schema, 'double');
+        return this.decoder.readDouble();
+    }
+    readBytes(schema) {
+        this.validateSchemaType(schema, 'bytes');
+        return this.decoder.readBytes();
+    }
+    readString(schema) {
+        this.validateSchemaType(schema, 'string');
+        return this.decoder.readString();
+    }
+    validateSchemaType(schema, expectedType) {
+        const resolvedSchema = this.resolveSchema(schema);
+        const actualType = typeof resolvedSchema === 'string'
+            ? resolvedSchema
+            : Array.isArray(resolvedSchema)
+                ? 'union'
+                : resolvedSchema.type;
+        if (actualType !== expectedType) {
+            throw new Error(`Expected schema type ${expectedType}, got ${actualType}`);
+        }
+    }
+    resolveSchema(schema) {
+        if (typeof schema === 'string') {
+            const namedSchema = this.namedSchemas.get(schema);
+            return namedSchema || schema;
+        }
+        return schema;
+    }
+    collectNamedSchemas(schema) {
+        if (typeof schema === 'string' || Array.isArray(schema)) {
+            return;
+        }
+        if (typeof schema === 'object' && schema !== null) {
+            switch (schema.type) {
+                case 'record':
+                    const recordSchema = schema;
+                    const recordFullName = this.getFullName(recordSchema.name, recordSchema.namespace);
+                    this.namedSchemas.set(recordFullName, recordSchema);
+                    recordSchema.fields.forEach((field) => this.collectNamedSchemas(field.type));
+                    break;
+                case 'enum':
+                    const enumSchema = schema;
+                    const enumFullName = this.getFullName(enumSchema.name, enumSchema.namespace);
+                    this.namedSchemas.set(enumFullName, enumSchema);
+                    break;
+                case 'fixed':
+                    const fixedSchema = schema;
+                    const fixedFullName = this.getFullName(fixedSchema.name, fixedSchema.namespace);
+                    this.namedSchemas.set(fixedFullName, fixedSchema);
+                    break;
+                case 'array':
+                    this.collectNamedSchemas(schema.items);
+                    break;
+                case 'map':
+                    this.collectNamedSchemas(schema.values);
+                    break;
+            }
+        }
+    }
+    getFullName(name, namespace) {
+        return namespace ? `${namespace}.${name}` : name;
+    }
+}
+exports.AvroSchemaDecoder = AvroSchemaDecoder;
+//# sourceMappingURL=AvroSchemaDecoder.js.map

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

@@ -0,0 +1,33 @@
+import type { IWriter, IWriterGrowable } from '@jsonjoy.com/buffers/lib';
+import type { AvroSchema, AvroRecordSchema, AvroEnumSchema, AvroArraySchema, AvroMapSchema, AvroUnionSchema, AvroFixedSchema, AvroNullSchema } from './types';
+export declare class AvroSchemaEncoder {
+    readonly writer: IWriter & IWriterGrowable;
+    private encoder;
+    private validator;
+    private namedSchemas;
+    constructor(writer: IWriter & IWriterGrowable);
+    encode(value: unknown, schema: AvroSchema, selectedIndex?: number): Uint8Array;
+    writeNull(schema: AvroNullSchema | AvroSchema): void;
+    writeBoolean(value: boolean, schema: AvroSchema): void;
+    writeInt(value: number, schema: AvroSchema): void;
+    writeLong(value: number | bigint, schema: AvroSchema): void;
+    writeFloat(value: number, schema: AvroSchema): void;
+    writeDouble(value: number, schema: AvroSchema): void;
+    writeBytes(value: Uint8Array, schema: AvroSchema): void;
+    writeString(value: string, schema: AvroSchema): void;
+    writeRecord(value: Record<string, unknown>, schema: AvroRecordSchema): void;
+    writeEnum(value: string, schema: AvroEnumSchema): void;
+    writeArray(value: unknown[], schema: AvroArraySchema): void;
+    writeMap(value: Record<string, unknown>, schema: AvroMapSchema): void;
+    writeUnion(value: unknown, schema: AvroUnionSchema, selectedIndex?: number): void;
+    writeFixed(value: Uint8Array, schema: AvroFixedSchema): void;
+    writeNumber(value: number, schema: AvroSchema): void;
+    private writeValue;
+    private validateSchemaType;
+    private resolveSchema;
+    private collectNamedSchemas;
+    private getFullName;
+    private writeVarIntUnsigned;
+    private writeVarIntSigned;
+    private encodeZigZag32;
+}

node_modules/@jsonjoy.com/json-pack/lib/avro/AvroSchemaEncoder.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvroSchemaEncoder = void 0;
+const AvroEncoder_1 = require("./AvroEncoder");
+const AvroSchemaValidator_1 = require("./AvroSchemaValidator");
+class AvroSchemaEncoder {
+    constructor(writer) {
+        this.writer = writer;
+        this.namedSchemas = new Map();
+        this.encoder = new AvroEncoder_1.AvroEncoder(writer);
+        this.validator = new AvroSchemaValidator_1.AvroSchemaValidator();
+    }
+    encode(value, schema, selectedIndex) {
+        this.writer.reset();
+        this.namedSchemas.clear();
+        if (!this.validator.validateSchema(schema)) {
+            throw new Error('Invalid Avro schema');
+        }
+        if (!this.validator.validateValue(value, schema)) {
+            throw new Error('Value does not conform to schema');
+        }
+        this.collectNamedSchemas(schema);
+        if (Array.isArray(schema) && selectedIndex !== undefined) {
+            this.writeUnion(value, schema, selectedIndex);
+        }
+        else {
+            this.writeValue(value, schema);
+        }
+        return this.writer.flush();
+    }
+    writeNull(schema) {
+        this.validateSchemaType(schema, 'null');
+        this.encoder.writeNull();
+    }
+    writeBoolean(value, schema) {
+        this.validateSchemaType(schema, 'boolean');
+        this.encoder.writeBoolean(value);
+    }
+    writeInt(value, schema) {
+        this.validateSchemaType(schema, 'int');
+        if (!Number.isInteger(value) || value < -2147483648 || value > 2147483647) {
+            throw new Error('Value is not a valid 32-bit integer');
+        }
+        this.encoder.writeInt(value);
+    }
+    writeLong(value, schema) {
+        this.validateSchemaType(schema, 'long');
+        this.encoder.writeLong(value);
+    }
+    writeFloat(value, schema) {
+        this.validateSchemaType(schema, 'float');
+        this.encoder.writeFloat(value);
+    }
+    writeDouble(value, schema) {
+        this.validateSchemaType(schema, 'double');
+        this.encoder.writeDouble(value);
+    }
+    writeBytes(value, schema) {
+        this.validateSchemaType(schema, 'bytes');
+        this.encoder.writeBin(value);
+    }
+    writeString(value, schema) {
+        this.validateSchemaType(schema, 'string');
+        this.encoder.writeStr(value);
+    }
+    writeRecord(value, schema) {
+        if (typeof schema === 'object' && schema.type !== 'record') {
+            throw new Error('Schema is not a record schema');
+        }
+        const recordSchema = this.resolveSchema(schema);
+        if (recordSchema.type !== 'record') {
+            throw new Error('Schema is not a record schema');
+        }
+        for (let i = 0; i < recordSchema.fields.length; i++) {
+            const field = recordSchema.fields[i];
+            const fieldValue = value[field.name];
+            if (fieldValue !== undefined) {
+                this.writeValue(fieldValue, field.type);
+            }
+            else if (field.default !== undefined) {
+                this.writeValue(field.default, field.type);
+            }
+            else {
+                throw new Error(`Missing required field: ${field.name}`);
+            }
+        }
+    }
+    writeEnum(value, schema) {
+        if (typeof schema === 'object' && schema.type !== 'enum') {
+            throw new Error('Schema is not an enum schema');
+        }
+        const enumSchema = this.resolveSchema(schema);
+        if (enumSchema.type !== 'enum') {
+            throw new Error('Schema is not an enum schema');
+        }
+        const index = enumSchema.symbols.indexOf(value);
+        if (index === -1) {
+            throw new Error(`Invalid enum value: ${value}`);
+        }
+        this.writeVarIntSigned(this.encodeZigZag32(index));
+    }
+    writeArray(value, schema) {
+        if (typeof schema === 'object' && schema.type !== 'array') {
+            throw new Error('Schema is not an array schema');
+        }
+        const arraySchema = this.resolveSchema(schema);
+        if (arraySchema.type !== 'array') {
+            throw new Error('Schema is not an array schema');
+        }
+        this.writeVarIntUnsigned(value.length);
+        const length = value.length;
+        for (let i = 0; i < length; i++) {
+            this.writeValue(value[i], arraySchema.items);
+        }
+        this.writeVarIntUnsigned(0);
+    }
+    writeMap(value, schema) {
+        if (typeof schema === 'object' && schema.type !== 'map') {
+            throw new Error('Schema is not a map schema');
+        }
+        const mapSchema = this.resolveSchema(schema);
+        if (mapSchema.type !== 'map') {
+            throw new Error('Schema is not a map schema');
+        }
+        const entries = Object.entries(value);
+        this.writeVarIntUnsigned(entries.length);
+        const length = entries.length;
+        for (let i = 0; i < length; i++) {
+            const entry = entries[i];
+            this.encoder.writeStr(entry[0]);
+            this.writeValue(entry[1], mapSchema.values);
+        }
+        this.writeVarIntUnsigned(0);
+    }
+    writeUnion(value, schema, selectedIndex) {
+        if (!Array.isArray(schema)) {
+            throw new Error('Schema is not a union schema');
+        }
+        let index = selectedIndex;
+        if (index === undefined) {
+            index = schema.findIndex((subSchema) => this.validator.validateValue(value, subSchema));
+            if (index === -1) {
+                throw new Error('Value does not match any schema in the union');
+            }
+        }
+        if (index < 0 || index >= schema.length) {
+            throw new Error('Invalid union index');
+        }
+        this.writeVarIntSigned(this.encodeZigZag32(index));
+        this.writeValue(value, schema[index]);
+    }
+    writeFixed(value, schema) {
+        if (typeof schema === 'object' && schema.type !== 'fixed') {
+            throw new Error('Schema is not a fixed schema');
+        }
+        const fixedSchema = this.resolveSchema(schema);
+        if (fixedSchema.type !== 'fixed') {
+            throw new Error('Schema is not a fixed schema');
+        }
+        if (value.length !== fixedSchema.size) {
+            throw new Error(`Fixed value length ${value.length} does not match schema size ${fixedSchema.size}`);
+        }
+        this.writer.buf(value, value.length);
+    }
+    writeNumber(value, schema) {
+        const resolvedSchema = this.resolveSchema(schema);
+        const schemaType = typeof resolvedSchema === 'string'
+            ? resolvedSchema
+            : Array.isArray(resolvedSchema)
+                ? 'union'
+                : resolvedSchema.type;
+        switch (schemaType) {
+            case 'int':
+                this.writeInt(value, schema);
+                break;
+            case 'long':
+                this.writeLong(value, schema);
+                break;
+            case 'float':
+                this.writeFloat(value, schema);
+                break;
+            case 'double':
+                this.writeDouble(value, schema);
+                break;
+            default:
+                throw new Error(`Schema type ${schemaType} is not a numeric type`);
+        }
+    }
+    writeValue(value, schema) {
+        const resolvedSchema = this.resolveSchema(schema);
+        if (typeof resolvedSchema === 'string') {
+            switch (resolvedSchema) {
+                case 'null':
+                    this.encoder.writeNull();
+                    break;
+                case 'boolean':
+                    this.encoder.writeBoolean(value);
+                    break;
+                case 'int':
+                    this.encoder.writeInt(value);
+                    break;
+                case 'long':
+                    this.encoder.writeLong(value);
+                    break;
+                case 'float':
+                    this.encoder.writeFloat(value);
+                    break;
+                case 'double':
+                    this.encoder.writeDouble(value);
+                    break;
+                case 'bytes':
+                    this.encoder.writeBin(value);
+                    break;
+                case 'string':
+                    this.encoder.writeStr(value);
+                    break;
+                default:
+                    throw new Error(`Unknown primitive type: ${resolvedSchema}`);
+            }
+            return;
+        }
+        if (Array.isArray(resolvedSchema)) {
+            this.writeUnion(value, resolvedSchema);
+            return;
+        }
+        switch (resolvedSchema.type) {
+            case 'record':
+                this.writeRecord(value, resolvedSchema);
+                break;
+            case 'enum':
+                this.writeEnum(value, resolvedSchema);
+                break;
+            case 'array':
+                this.writeArray(value, resolvedSchema);
+                break;
+            case 'map':
+                this.writeMap(value, resolvedSchema);
+                break;
+            case 'fixed':
+                this.writeFixed(value, resolvedSchema);
+                break;
+            default:
+                throw new Error(`Unknown schema type: ${resolvedSchema.type}`);
+        }
+    }
+    validateSchemaType(schema, expectedType) {
+        const resolvedSchema = this.resolveSchema(schema);
+        const actualType = typeof resolvedSchema === 'string'
+            ? resolvedSchema
+            : Array.isArray(resolvedSchema)
+                ? 'union'
+                : resolvedSchema.type;
+        if (actualType !== expectedType) {
+            throw new Error(`Expected schema type ${expectedType}, got ${actualType}`);
+        }
+    }
+    resolveSchema(schema) {
+        if (typeof schema === 'string') {
+            const namedSchema = this.namedSchemas.get(schema);
+            return namedSchema || schema;
+        }
+        return schema;
+    }
+    collectNamedSchemas(schema) {
+        if (typeof schema === 'string' || Array.isArray(schema)) {
+            return;
+        }
+        if (typeof schema === 'object' && schema !== null) {
+            switch (schema.type) {
+                case 'record':
+                    const recordSchema = schema;
+                    const recordFullName = this.getFullName(recordSchema.name, recordSchema.namespace);
+                    this.namedSchemas.set(recordFullName, recordSchema);
+                    recordSchema.fields.forEach((field) => this.collectNamedSchemas(field.type));
+                    break;
+                case 'enum':
+                    const enumSchema = schema;
+                    const enumFullName = this.getFullName(enumSchema.name, enumSchema.namespace);
+                    this.namedSchemas.set(enumFullName, enumSchema);
+                    break;
+                case 'fixed':
+                    const fixedSchema = schema;
+                    const fixedFullName = this.getFullName(fixedSchema.name, fixedSchema.namespace);
+                    this.namedSchemas.set(fixedFullName, fixedSchema);
+                    break;
+                case 'array':
+                    this.collectNamedSchemas(schema.items);
+                    break;
+                case 'map':
+                    this.collectNamedSchemas(schema.values);
+                    break;
+            }
+        }
+    }
+    getFullName(name, namespace) {
+        return namespace ? `${namespace}.${name}` : name;
+    }
+    writeVarIntUnsigned(value) {
+        const writer = this.writer;
+        let n = value >>> 0;
+        while (n >= 0x80) {
+            writer.u8((n & 0x7f) | 0x80);
+            n >>>= 7;
+        }
+        writer.u8(n & 0x7f);
+    }
+    writeVarIntSigned(value) {
+        const writer = this.writer;
+        let n = value >>> 0;
+        while (n >= 0x80) {
+            writer.u8((n & 0x7f) | 0x80);
+            n >>>= 7;
+        }
+        writer.u8(n & 0x7f);
+    }
+    encodeZigZag32(value) {
+        return (value << 1) ^ (value >> 31);
+    }
+}
+exports.AvroSchemaEncoder = AvroSchemaEncoder;
+//# sourceMappingURL=AvroSchemaEncoder.js.map

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

@@ -0,0 +1,32 @@
+import type { AvroSchema } from './types';
+export declare class AvroSchemaValidator {
+    private namedSchemas;
+    validateSchema(schema: AvroSchema): boolean;
+    validateValue(value: unknown, schema: AvroSchema): boolean;
+    private validateSchemaInternal;
+    private validateStringSchema;
+    private validateUnionSchema;
+    private validateNullSchema;
+    private validateBooleanSchema;
+    private validateIntSchema;
+    private validateLongSchema;
+    private validateFloatSchema;
+    private validateDoubleSchema;
+    private validateBytesSchema;
+    private validateStringTypeSchema;
+    private validateRecordSchema;
+    private validateRecordField;
+    private validateEnumSchema;
+    private validateArraySchema;
+    private validateMapSchema;
+    private validateFixedSchema;
+    private validateValueAgainstSchema;
+    private validateValueAgainstStringSchema;
+    private validateValueAgainstRecord;
+    private validateValueAgainstEnum;
+    private validateValueAgainstArray;
+    private validateValueAgainstMap;
+    private validateValueAgainstFixed;
+    private getSchemaTypeName;
+    private getFullName;
+}

node_modules/@jsonjoy.com/json-pack/lib/avro/AvroSchemaValidator.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvroSchemaValidator = void 0;
+class AvroSchemaValidator {
+    constructor() {
+        this.namedSchemas = new Map();
+    }
+    validateSchema(schema) {
+        this.namedSchemas.clear();
+        return this.validateSchemaInternal(schema);
+    }
+    validateValue(value, schema) {
+        this.namedSchemas.clear();
+        this.validateSchemaInternal(schema);
+        return this.validateValueAgainstSchema(value, schema);
+    }
+    validateSchemaInternal(schema) {
+        if (typeof schema === 'string') {
+            return this.validateStringSchema(schema);
+        }
+        if (Array.isArray(schema)) {
+            return this.validateUnionSchema(schema);
+        }
+        if (typeof schema === 'object' && schema !== null) {
+            switch (schema.type) {
+                case 'null':
+                    return this.validateNullSchema(schema);
+                case 'boolean':
+                    return this.validateBooleanSchema(schema);
+                case 'int':
+                    return this.validateIntSchema(schema);
+                case 'long':
+                    return this.validateLongSchema(schema);
+                case 'float':
+                    return this.validateFloatSchema(schema);
+                case 'double':
+                    return this.validateDoubleSchema(schema);
+                case 'bytes':
+                    return this.validateBytesSchema(schema);
+                case 'string':
+                    return this.validateStringTypeSchema(schema);
+                case 'record':
+                    return this.validateRecordSchema(schema);
+                case 'enum':
+                    return this.validateEnumSchema(schema);
+                case 'array':
+                    return this.validateArraySchema(schema);
+                case 'map':
+                    return this.validateMapSchema(schema);
+                case 'fixed':
+                    return this.validateFixedSchema(schema);
+                default:
+                    return false;
+            }
+        }
+        return false;
+    }
+    validateStringSchema(schema) {
+        const primitiveTypes = ['null', 'boolean', 'int', 'long', 'float', 'double', 'bytes', 'string'];
+        return primitiveTypes.includes(schema) || this.namedSchemas.has(schema);
+    }
+    validateUnionSchema(schema) {
+        if (schema.length === 0)
+            return false;
+        const typeSet = new Set();
+        for (const subSchema of schema) {
+            if (!this.validateSchemaInternal(subSchema))
+                return false;
+            const typeName = this.getSchemaTypeName(subSchema);
+            if (typeSet.has(typeName))
+                return false;
+            typeSet.add(typeName);
+        }
+        return true;
+    }
+    validateNullSchema(schema) {
+        return schema.type === 'null';
+    }
+    validateBooleanSchema(schema) {
+        return schema.type === 'boolean';
+    }
+    validateIntSchema(schema) {
+        return schema.type === 'int';
+    }
+    validateLongSchema(schema) {
+        return schema.type === 'long';
+    }
+    validateFloatSchema(schema) {
+        return schema.type === 'float';
+    }
+    validateDoubleSchema(schema) {
+        return schema.type === 'double';
+    }
+    validateBytesSchema(schema) {
+        return schema.type === 'bytes';
+    }
+    validateStringTypeSchema(schema) {
+        return schema.type === 'string';
+    }
+    validateRecordSchema(schema) {
+        if (schema.type !== 'record' || !schema.name || !Array.isArray(schema.fields))
+            return false;
+        const fullName = this.getFullName(schema.name, schema.namespace);
+        if (this.namedSchemas.has(fullName))
+            return false;
+        this.namedSchemas.set(fullName, schema);
+        const fieldNames = new Set();
+        for (const field of schema.fields) {
+            if (!this.validateRecordField(field))
+                return false;
+            if (fieldNames.has(field.name))
+                return false;
+            fieldNames.add(field.name);
+        }
+        return true;
+    }
+    validateRecordField(field) {
+        return typeof field.name === 'string' && field.name.length > 0 && this.validateSchemaInternal(field.type);
+    }
+    validateEnumSchema(schema) {
+        if (schema.type !== 'enum' || !schema.name || !Array.isArray(schema.symbols))
+            return false;
+        const fullName = this.getFullName(schema.name, schema.namespace);
+        if (this.namedSchemas.has(fullName))
+            return false;
+        this.namedSchemas.set(fullName, schema);
+        if (schema.symbols.length === 0)
+            return false;
+        const symbolSet = new Set();
+        for (const symbol of schema.symbols) {
+            if (typeof symbol !== 'string' || symbolSet.has(symbol))
+                return false;
+            symbolSet.add(symbol);
+        }
+        if (schema.default !== undefined && !schema.symbols.includes(schema.default))
+            return false;
+        return true;
+    }
+    validateArraySchema(schema) {
+        return schema.type === 'array' && this.validateSchemaInternal(schema.items);
+    }
+    validateMapSchema(schema) {
+        return schema.type === 'map' && this.validateSchemaInternal(schema.values);
+    }
+    validateFixedSchema(schema) {
+        if (schema.type !== 'fixed' || !schema.name || typeof schema.size !== 'number')
+            return false;
+        if (schema.size < 0)
+            return false;
+        const fullName = this.getFullName(schema.name, schema.namespace);
+        if (this.namedSchemas.has(fullName))
+            return false;
+        this.namedSchemas.set(fullName, schema);
+        return true;
+    }
+    validateValueAgainstSchema(value, schema) {
+        if (typeof schema === 'string') {
+            return this.validateValueAgainstStringSchema(value, schema);
+        }
+        if (Array.isArray(schema)) {
+            return schema.some((subSchema) => this.validateValueAgainstSchema(value, subSchema));
+        }
+        if (typeof schema === 'object' && schema !== null) {
+            switch (schema.type) {
+                case 'null':
+                    return value === null;
+                case 'boolean':
+                    return typeof value === 'boolean';
+                case 'int':
+                    return typeof value === 'number' && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+                case 'long':
+                    return (typeof value === 'number' && Number.isInteger(value)) || typeof value === 'bigint';
+                case 'float':
+                case 'double':
+                    return typeof value === 'number';
+                case 'bytes':
+                    return value instanceof Uint8Array;
+                case 'string':
+                    return typeof value === 'string';
+                case 'record':
+                    return this.validateValueAgainstRecord(value, schema);
+                case 'enum':
+                    return this.validateValueAgainstEnum(value, schema);
+                case 'array':
+                    return this.validateValueAgainstArray(value, schema);
+                case 'map':
+                    return this.validateValueAgainstMap(value, schema);
+                case 'fixed':
+                    return this.validateValueAgainstFixed(value, schema);
+                default:
+                    return false;
+            }
+        }
+        return false;
+    }
+    validateValueAgainstStringSchema(value, schema) {
+        switch (schema) {
+            case 'null':
+                return value === null;
+            case 'boolean':
+                return typeof value === 'boolean';
+            case 'int':
+                return typeof value === 'number' && Number.isInteger(value) && value >= -2147483648 && value <= 2147483647;
+            case 'long':
+                return (typeof value === 'number' && Number.isInteger(value)) || typeof value === 'bigint';
+            case 'float':
+            case 'double':
+                return typeof value === 'number';
+            case 'bytes':
+                return value instanceof Uint8Array;
+            case 'string':
+                return typeof value === 'string';
+            default:
+                const namedSchema = this.namedSchemas.get(schema);
+                return namedSchema ? this.validateValueAgainstSchema(value, namedSchema) : false;
+        }
+    }
+    validateValueAgainstRecord(value, schema) {
+        if (typeof value !== 'object' || value === null)
+            return false;
+        const obj = value;
+        for (const field of schema.fields) {
+            const fieldValue = obj[field.name];
+            if (fieldValue === undefined && field.default === undefined)
+                return false;
+            if (fieldValue !== undefined && !this.validateValueAgainstSchema(fieldValue, field.type))
+                return false;
+        }
+        return true;
+    }
+    validateValueAgainstEnum(value, schema) {
+        return typeof value === 'string' && schema.symbols.includes(value);
+    }
+    validateValueAgainstArray(value, schema) {
+        if (!Array.isArray(value))
+            return false;
+        return value.every((item) => this.validateValueAgainstSchema(item, schema.items));
+    }
+    validateValueAgainstMap(value, schema) {
+        if (typeof value !== 'object' || value === null)
+            return false;
+        const obj = value;
+        return Object.values(obj).every((val) => this.validateValueAgainstSchema(val, schema.values));
+    }
+    validateValueAgainstFixed(value, schema) {
+        return value instanceof Uint8Array && value.length === schema.size;
+    }
+    getSchemaTypeName(schema) {
+        if (typeof schema === 'string')
+            return schema;
+        if (Array.isArray(schema))
+            return 'union';
+        return schema.type;
+    }
+    getFullName(name, namespace) {
+        return namespace ? `${namespace}.${name}` : name;
+    }
+}
+exports.AvroSchemaValidator = AvroSchemaValidator;
+//# sourceMappingURL=AvroSchemaValidator.js.map

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

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './AvroSchemaValidator';
+export * from './AvroEncoder';
+export * from './AvroSchemaEncoder';
+export * from './AvroDecoder';
+export * from './AvroSchemaDecoder';

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./AvroSchemaValidator"), exports);
+tslib_1.__exportStar(require("./AvroEncoder"), exports);
+tslib_1.__exportStar(require("./AvroSchemaEncoder"), exports);
+tslib_1.__exportStar(require("./AvroDecoder"), exports);
+tslib_1.__exportStar(require("./AvroSchemaDecoder"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/avro/index.ts"],"names":[],"mappings":";;;AAAA,kDAAwB;AACxB,gEAAsC;AACtC,wDAA8B;AAC9B,8DAAoC;AACpC,wDAA8B;AAC9B,8DAAoC"}

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

@@ -0,0 +1,109 @@
+export interface AvroBaseSchema {
+    type: string;
+    doc?: string;
+    [key: string]: any;
+}
+export interface AvroNullSchema extends AvroBaseSchema {
+    type: 'null';
+}
+export interface AvroBooleanSchema extends AvroBaseSchema {
+    type: 'boolean';
+}
+export interface AvroIntSchema extends AvroBaseSchema {
+    type: 'int';
+}
+export interface AvroLongSchema extends AvroBaseSchema {
+    type: 'long';
+}
+export interface AvroFloatSchema extends AvroBaseSchema {
+    type: 'float';
+}
+export interface AvroDoubleSchema extends AvroBaseSchema {
+    type: 'double';
+}
+export interface AvroBytesSchema extends AvroBaseSchema {
+    type: 'bytes';
+}
+export interface AvroStringSchema extends AvroBaseSchema {
+    type: 'string';
+}
+export interface AvroRecordField {
+    name: string;
+    type: AvroSchema;
+    doc?: string;
+    default?: any;
+    order?: 'ascending' | 'descending' | 'ignore';
+    aliases?: string[];
+}
+export interface AvroRecordSchema extends AvroBaseSchema {
+    type: 'record';
+    name: string;
+    namespace?: string;
+    fields: AvroRecordField[];
+    aliases?: string[];
+}
+export interface AvroEnumSchema extends AvroBaseSchema {
+    type: 'enum';
+    name: string;
+    namespace?: string;
+    symbols: string[];
+    default?: string;
+    aliases?: string[];
+}
+export interface AvroArraySchema extends AvroBaseSchema {
+    type: 'array';
+    items: AvroSchema;
+}
+export interface AvroMapSchema extends AvroBaseSchema {
+    type: 'map';
+    values: AvroSchema;
+}
+export interface AvroUnionSchema extends Array<AvroSchema> {
+}
+export interface AvroFixedSchema extends AvroBaseSchema {
+    type: 'fixed';
+    name: string;
+    namespace?: string;
+    size: number;
+    aliases?: string[];
+}
+export type AvroPrimitiveSchema = AvroNullSchema | AvroBooleanSchema | AvroIntSchema | AvroLongSchema | AvroFloatSchema | AvroDoubleSchema | AvroBytesSchema | AvroStringSchema;
+export type AvroComplexSchema = AvroRecordSchema | AvroEnumSchema | AvroArraySchema | AvroMapSchema | AvroUnionSchema | AvroFixedSchema;
+export type AvroSchema = AvroPrimitiveSchema | AvroComplexSchema | string;
+export type AvroNamedSchema = AvroRecordSchema | AvroEnumSchema | AvroFixedSchema;
+export interface AvroLogicalTypeSchema extends AvroBaseSchema {
+    logicalType: string;
+}
+export interface AvroDecimalLogicalType extends AvroLogicalTypeSchema {
+    logicalType: 'decimal';
+    precision: number;
+    scale?: number;
+}
+export interface AvroUuidLogicalType extends AvroStringSchema {
+    logicalType: 'uuid';
+}
+export interface AvroDateLogicalType extends AvroIntSchema {
+    logicalType: 'date';
+}
+export interface AvroTimeMillisLogicalType extends AvroIntSchema {
+    logicalType: 'time-millis';
+}
+export interface AvroTimeMicrosLogicalType extends AvroLongSchema {
+    logicalType: 'time-micros';
+}
+export interface AvroTimestampMillisLogicalType extends AvroLongSchema {
+    logicalType: 'timestamp-millis';
+}
+export interface AvroTimestampMicrosLogicalType extends AvroLongSchema {
+    logicalType: 'timestamp-micros';
+}
+export interface AvroLocalTimestampMillisLogicalType extends AvroLongSchema {
+    logicalType: 'local-timestamp-millis';
+}
+export interface AvroLocalTimestampMicrosLogicalType extends AvroLongSchema {
+    logicalType: 'local-timestamp-micros';
+}
+export interface AvroDurationLogicalType extends AvroFixedSchema {
+    logicalType: 'duration';
+    size: 12;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { Reader } from '@jsonjoy.com/buffers/lib/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/buffers/lib/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/buffers/lib';
+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(str.length * 4);
+        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/BsonDecoder.d.ts

@@ -0,0 +1,22 @@
+import { BsonBinary, BsonDbPointer, BsonDecimal128, BsonJavascriptCodeWithScope, BsonObjectId, BsonTimestamp } from './values';
+import type { IReader, IReaderResettable } from '@jsonjoy.com/buffers/lib';
+import type { BinaryJsonDecoder } from '../types';
+export declare class BsonDecoder implements BinaryJsonDecoder {
+    reader: IReader & IReaderResettable;
+    constructor(reader?: IReader & IReaderResettable);
+    read(uint8: Uint8Array): unknown;
+    decode(uint8: Uint8Array): unknown;
+    readAny(): unknown;
+    readDocument(): Record<string, unknown>;
+    readCString(): string;
+    readString(): string;
+    readElementValue(type: number): unknown;
+    readArray(): unknown[];
+    readBinary(): BsonBinary | Uint8Array;
+    readObjectId(): BsonObjectId;
+    readRegex(): RegExp;
+    readDbPointer(): BsonDbPointer;
+    readCodeWithScope(): BsonJavascriptCodeWithScope;
+    readTimestamp(): BsonTimestamp;
+    readDecimal128(): BsonDecimal128;
+}

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

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BsonDecoder = void 0;
+const Reader_1 = require("@jsonjoy.com/buffers/lib/Reader");
+const values_1 = require("./values");
+class BsonDecoder {
+    constructor(reader = new Reader_1.Reader()) {
+        this.reader = reader;
+    }
+    read(uint8) {
+        this.reader.reset(uint8);
+        return this.readDocument();
+    }
+    decode(uint8) {
+        this.reader.reset(uint8);
+        return this.readDocument();
+    }
+    readAny() {
+        return this.readDocument();
+    }
+    readDocument() {
+        const reader = this.reader;
+        const documentSize = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const startPos = reader.x;
+        const endPos = startPos + documentSize - 4 - 1;
+        const obj = {};
+        while (reader.x < endPos) {
+            const elementType = reader.u8();
+            if (elementType === 0)
+                break;
+            const key = this.readCString();
+            const value = this.readElementValue(elementType);
+            obj[key] = value;
+        }
+        if (reader.x <= endPos) {
+            reader.x = startPos + documentSize - 4;
+        }
+        return obj;
+    }
+    readCString() {
+        const reader = this.reader;
+        const uint8 = reader.uint8;
+        const x = reader.x;
+        let length = 0;
+        while (uint8[x + length] !== 0) {
+            length++;
+        }
+        if (length === 0) {
+            reader.x++;
+            return '';
+        }
+        const str = reader.utf8(length);
+        reader.x++;
+        return str;
+    }
+    readString() {
+        const reader = this.reader;
+        const length = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        if (length <= 0) {
+            throw new Error('Invalid string length');
+        }
+        const str = reader.utf8(length - 1);
+        reader.x++;
+        return str;
+    }
+    readElementValue(type) {
+        const reader = this.reader;
+        switch (type) {
+            case 0x01:
+                const doubleVal = reader.view.getFloat64(reader.x, true);
+                reader.x += 8;
+                return doubleVal;
+            case 0x02:
+                return this.readString();
+            case 0x03:
+                return this.readDocument();
+            case 0x04:
+                return this.readArray();
+            case 0x05:
+                return this.readBinary();
+            case 0x06:
+                return undefined;
+            case 0x07:
+                return this.readObjectId();
+            case 0x08:
+                return reader.u8() === 1;
+            case 0x09:
+                const dateVal = reader.view.getBigInt64(reader.x, true);
+                reader.x += 8;
+                return new Date(Number(dateVal));
+            case 0x0a:
+                return null;
+            case 0x0b:
+                return this.readRegex();
+            case 0x0c:
+                return this.readDbPointer();
+            case 0x0d:
+                return new values_1.BsonJavascriptCode(this.readString());
+            case 0x0e:
+                return Symbol(this.readString());
+            case 0x0f:
+                return this.readCodeWithScope();
+            case 0x10:
+                const int32Val = reader.view.getInt32(reader.x, true);
+                reader.x += 4;
+                return int32Val;
+            case 0x11:
+                return this.readTimestamp();
+            case 0x12:
+                const int64Val = reader.view.getBigInt64(reader.x, true);
+                reader.x += 8;
+                return Number(int64Val);
+            case 0x13:
+                return this.readDecimal128();
+            case 0xff:
+                return new values_1.BsonMinKey();
+            case 0x7f:
+                return new values_1.BsonMaxKey();
+            default:
+                throw new Error(`Unsupported BSON type: 0x${type.toString(16)}`);
+        }
+    }
+    readArray() {
+        const doc = this.readDocument();
+        const keys = Object.keys(doc).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
+        return keys.map((key) => doc[key]);
+    }
+    readBinary() {
+        const reader = this.reader;
+        const length = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const subtype = reader.u8();
+        const data = reader.buf(length);
+        if (subtype === 0) {
+            return data;
+        }
+        return new values_1.BsonBinary(subtype, data);
+    }
+    readObjectId() {
+        const reader = this.reader;
+        const uint8 = reader.uint8;
+        const x = reader.x;
+        const timestamp = (uint8[x] << 24) | (uint8[x + 1] << 16) | (uint8[x + 2] << 8) | uint8[x + 3];
+        const processLo = uint8[x + 4] | (uint8[x + 5] << 8) | (uint8[x + 6] << 16) | (uint8[x + 7] << 24);
+        const processHi = uint8[x + 8];
+        const processLoUnsigned = processLo >>> 0;
+        const process = processLoUnsigned + processHi * 0x100000000;
+        const counter = (uint8[x + 9] << 16) | (uint8[x + 10] << 8) | uint8[x + 11];
+        reader.x += 12;
+        return new values_1.BsonObjectId(timestamp, process, counter);
+    }
+    readRegex() {
+        const pattern = this.readCString();
+        const flags = this.readCString();
+        return new RegExp(pattern, flags);
+    }
+    readDbPointer() {
+        const name = this.readString();
+        const id = this.readObjectId();
+        return new values_1.BsonDbPointer(name, id);
+    }
+    readCodeWithScope() {
+        const reader = this.reader;
+        const totalLength = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const code = this.readString();
+        const scope = this.readDocument();
+        return new values_1.BsonJavascriptCodeWithScope(code, scope);
+    }
+    readTimestamp() {
+        const reader = this.reader;
+        const increment = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        const timestamp = reader.view.getInt32(reader.x, true);
+        reader.x += 4;
+        return new values_1.BsonTimestamp(increment, timestamp);
+    }
+    readDecimal128() {
+        const reader = this.reader;
+        const data = reader.buf(16);
+        return new values_1.BsonDecimal128(data);
+    }
+}
+exports.BsonDecoder = BsonDecoder;
+//# sourceMappingURL=BsonDecoder.js.map

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/buffers/lib';
+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,376 @@
+"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('Use writeKey for BSON encoding');
+    }
+    writeUndef() {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeBoolean(bool) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeNumber(num) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeInteger(int) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    writeUInteger(uint) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    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(8);
+        writer.view.setFloat64(writer.x, float, true);
+        writer.x += 8;
+    }
+    writeBigInt(int) {
+        throw new Error('Use writeKey for BSON encoding');
+    }
+    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) {
+        this.writeStr(str);
+    }
+    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.BsonJavascriptCodeWithScope: {
+                        writer.u8(0x0f);
+                        this.writeCString(key);
+                        const codeWithScope = value;
+                        const x0 = writer.x;
+                        writer.x += 4;
+                        this.writeStr(codeWithScope.code);
+                        this.writeObj(codeWithScope.scope);
+                        const totalLength = writer.x - x0;
+                        writer.view.setInt32(x0, totalLength, true);
+                        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,3 @@
+export * from './values';
+export * from './BsonEncoder';
+export * from './BsonDecoder';

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

@@ -0,0 +1,7 @@
+"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);
+tslib_1.__exportStar(require("./BsonDecoder"), 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;AAC9B,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 '@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":""}

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

@@ -0,0 +1,11 @@
+import { Writer } from '@jsonjoy.com/buffers/lib/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/buffers/lib/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/buffers/lib/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/buffers/lib/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;
+}