microcbor 0.3.0 → 1.0.0

package/lib/Encoder.js

@@ -0,0 +1,291 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Encoder_instances, _Encoder_closed, _Encoder_flush;
+import { Precision, getFloat16Precision, getFloat32Precision, setFloat16 } from "fp16";
+import { assert } from "./utils.js";
+export const FloatSize = {
+    f16: 16,
+    f32: 32,
+    f64: 64,
+};
+export class Encoder {
+    constructor(options = {}) {
+        _Encoder_instances.add(this);
+        _Encoder_closed.set(this, void 0);
+        this.encoder = new TextEncoder();
+        this.minFloatSize = options.minFloatSize ?? 16;
+        this.chunkRecycling = options.chunkRecycling ?? false;
+        this.chunkSize = options.chunkSize ?? Encoder.defaultChunkSize;
+        assert(this.chunkSize >= 8, "expected chunkSize >= 8");
+        this.buffer = new ArrayBuffer(this.chunkSize);
+        this.view = new DataView(this.buffer);
+        this.array = new Uint8Array(this.buffer, 0, this.chunkSize);
+        this.offset = 0;
+        __classPrivateFieldSet(this, _Encoder_closed, false, "f");
+    }
+    get closed() {
+        return __classPrivateFieldGet(this, _Encoder_closed, "f");
+    }
+    *allocate(size) {
+        assert(size <= 8, "expected size <= 8");
+        if (this.buffer.byteLength < this.offset + size) {
+            yield __classPrivateFieldGet(this, _Encoder_instances, "m", _Encoder_flush).call(this);
+        }
+    }
+    *float16(value) {
+        yield* this.allocate(2);
+        setFloat16(this.view, this.offset, value);
+        this.offset += 2;
+    }
+    *float32(value) {
+        yield* this.allocate(4);
+        this.view.setFloat32(this.offset, value);
+        this.offset += 4;
+    }
+    *float64(value) {
+        yield* this.allocate(8);
+        this.view.setFloat64(this.offset, value);
+        this.offset += 8;
+    }
+    *uint8(value) {
+        yield* this.allocate(1);
+        this.view.setUint8(this.offset, value);
+        this.offset += 1;
+    }
+    *uint16(value) {
+        yield* this.allocate(2);
+        this.view.setUint16(this.offset, value);
+        this.offset += 2;
+    }
+    *uint32(value) {
+        yield* this.allocate(4);
+        this.view.setUint32(this.offset, value);
+        this.offset += 4;
+    }
+    *uint64(value) {
+        yield* this.allocate(8);
+        this.view.setBigUint64(this.offset, BigInt(value));
+        this.offset += 8;
+    }
+    *encodeTypeAndArgument(type, argument) {
+        const additionalInformation = Encoder.getAdditionalInformation(argument);
+        yield* this.uint8((type << 5) | additionalInformation);
+        switch (additionalInformation) {
+            case 24:
+                return yield* this.uint8(argument);
+            case 25:
+                return yield* this.uint16(argument);
+            case 26:
+                return yield* this.uint32(argument);
+            case 27:
+                return yield* this.uint64(argument);
+        }
+    }
+    *encodeNumber(value) {
+        if (Object.is(value, 0)) {
+            yield* this.encodeInteger(value);
+        }
+        else if (Object.is(value, -0)) {
+            yield* this.encodeFloat(value);
+        }
+        else if (Math.floor(value) === value && Number.MIN_SAFE_INTEGER <= value && value <= Number.MAX_SAFE_INTEGER) {
+            yield* this.encodeInteger(value);
+        }
+        else {
+            yield* this.encodeFloat(value);
+        }
+    }
+    *encodeInteger(value) {
+        if (value < 0) {
+            yield* this.encodeTypeAndArgument(1, -value - 1);
+        }
+        else {
+            yield* this.encodeTypeAndArgument(0, value);
+        }
+    }
+    *encodeFloat(value) {
+        if (this.minFloatSize === FloatSize.f16 && getFloat16Precision(value) === Precision.Exact) {
+            yield* this.uint8(0xe0 | 25);
+            yield* this.float16(value);
+        }
+        else if (this.minFloatSize <= FloatSize.f32 && getFloat32Precision(value) === Precision.Exact) {
+            yield* this.uint8(0xe0 | 26);
+            yield* this.float32(value);
+        }
+        else {
+            yield* this.uint8(0xe0 | 27);
+            yield* this.float64(value);
+        }
+    }
+    *encodeString(value) {
+        const bytes = this.encoder.encode(value);
+        yield* this.encodeTypeAndArgument(3, bytes.byteLength);
+        yield* this.writeBytes(bytes);
+        // const byteLength = getByteLength(value)
+        // let start = 0
+        // while (start < value.length) {
+        // 	if (this.offset + 4 > this.buffer.byteLength) {
+        // 		yield this.#flush()
+        // 	}
+        // 	const target = new Uint8Array(this.buffer, this.offset)
+        // 	const result = this.encoder.encodeInto(value.slice(start), target)
+        // 	start += result.read
+        // 	this.offset += result.written
+        // 	assert(this.offset <= this.buffer.byteLength, "expected this.offset <= this.buffer.byteLength")
+        // }
+    }
+    *encodeBytes(value) {
+        yield* this.encodeTypeAndArgument(2, value.byteLength);
+        yield* this.writeBytes(value);
+    }
+    *writeBytes(value) {
+        let start = 0;
+        while (start < value.byteLength) {
+            if (this.offset >= this.buffer.byteLength) {
+                yield __classPrivateFieldGet(this, _Encoder_instances, "m", _Encoder_flush).call(this);
+            }
+            const capacity = this.buffer.byteLength - this.offset;
+            const remaining = value.byteLength - start;
+            const chunkLength = Math.min(capacity, remaining);
+            this.array.set(value.subarray(start, start + chunkLength), this.offset);
+            start += chunkLength;
+            this.offset += chunkLength;
+        }
+    }
+    *encodeValue(value) {
+        if (__classPrivateFieldGet(this, _Encoder_closed, "f")) {
+            return;
+        }
+        if (value === false) {
+            yield* this.uint8(0xf4);
+        }
+        else if (value === true) {
+            yield* this.uint8(0xf5);
+        }
+        else if (value === null) {
+            yield* this.uint8(0xf6);
+        }
+        else if (value === undefined) {
+            yield* this.uint8(0xf7);
+        }
+        else if (typeof value === "number") {
+            yield* this.encodeNumber(value);
+        }
+        else if (typeof value === "string") {
+            yield* this.encodeString(value);
+        }
+        else if (value instanceof Uint8Array) {
+            yield* this.encodeBytes(value);
+        }
+        else if (Array.isArray(value)) {
+            yield* this.encodeTypeAndArgument(4, value.length);
+            for (const element of value) {
+                yield* this.encodeValue(element);
+            }
+        }
+        else {
+            const entries = Object.entries(value)
+                .map(([key, value]) => [this.encoder.encode(key), value])
+                .sort(Encoder.compareEntries);
+            yield* this.encodeTypeAndArgument(5, entries.length);
+            for (const [key, value] of entries) {
+                yield* this.encodeTypeAndArgument(3, key.byteLength);
+                yield* this.writeBytes(key);
+                yield* this.encodeValue(value);
+            }
+        }
+    }
+    *flush() {
+        if (__classPrivateFieldGet(this, _Encoder_closed, "f")) {
+            return;
+        }
+        if (this.offset > 0) {
+            yield __classPrivateFieldGet(this, _Encoder_instances, "m", _Encoder_flush).call(this);
+        }
+    }
+    // Per the deterministic CBOR spec, we're supposed to sort keys
+    // the byte-wise lexicographic order of the key's CBOR encoding
+    // - ie lower major types come before higher major types.
+    // One thing we know for sure about strings is that a string with
+    // a smaller length will sort byte-wise before a string
+    // with a longer length, since strings are encoded with a length
+    // prefix (either in the additionalInformation bits, if < 24, or
+    // in the next serveral bytes, but in all cases the order holds).
+    static compareEntries([a], [b]) {
+        if (a.byteLength < b.byteLength)
+            return -1;
+        if (b.byteLength < a.byteLength)
+            return 1;
+        for (let i = 0; i < a.byteLength; i++) {
+            if (a[i] < b[i])
+                return -1;
+            if (b[i] < a[i])
+                return 1;
+        }
+        return 0;
+    }
+    static getAdditionalInformation(argument) {
+        if (argument < 24) {
+            return argument;
+        }
+        else if (argument < 0x100) {
+            return 24;
+        }
+        else if (argument < 0x10000) {
+            return 25;
+        }
+        else if (argument < 0x100000000) {
+            return 26;
+        }
+        else {
+            return 27;
+        }
+    }
+}
+_Encoder_closed = new WeakMap(), _Encoder_instances = new WeakSet(), _Encoder_flush = function _Encoder_flush() {
+    if (this.chunkRecycling) {
+        const chunk = new Uint8Array(this.buffer, 0, this.offset);
+        this.offset = 0;
+        return chunk;
+    }
+    else {
+        const chunk = new Uint8Array(this.offset);
+        chunk.set(new Uint8Array(this.buffer, 0, this.offset));
+        this.offset = 0;
+        return chunk;
+    }
+};
+Encoder.defaultChunkSize = 4096;
+/**
+ * Encode a single CBOR value.
+ * options.chunkRecycling has no effect here.
+ */
+export function encode(value, options = {}) {
+    const encoder = new Encoder({ ...options, chunkRecycling: false });
+    let byteLength = 0;
+    const chunks = [];
+    for (const chunk of encoder.encodeValue(value)) {
+        chunks.push(chunk);
+        byteLength += chunk.byteLength;
+    }
+    for (const chunk of encoder.flush()) {
+        chunks.push(chunk);
+        byteLength += chunk.byteLength;
+    }
+    const data = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        data.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return data;
+}

package/lib/decodeAsyncIterable.d.ts

@@ -0,0 +1,37 @@
+import type { CBORValue } from "./types.js";
+export declare class Decoder implements AsyncIterableIterator<CBORValue> {
+    private offset;
+    private byteLength;
+    private readonly chunks;
+    private readonly constantBuffer;
+    private readonly constantView;
+    private readonly iter;
+    private readonly onFree?;
+    constructor(source: AsyncIterable<Uint8Array>, options?: {
+        onFree?: (chunk: Uint8Array) => void;
+    });
+    [Symbol.asyncIterator]: () => this;
+    private allocate;
+    private fill;
+    private constant;
+    private float16;
+    private float32;
+    private float64;
+    private uint8;
+    private uint16;
+    private uint32;
+    private uint64;
+    private decodeBytes;
+    private decodeString;
+    private getArgument;
+    next(): Promise<{
+        done: true;
+        value: undefined;
+    } | {
+        done: false;
+        value: CBORValue;
+    }>;
+    private decodeValue;
+}
+/** Decode an async iterable of Uint8Array chunks into an async iterable of CBOR values */
+export declare function decodeAsyncIterable(source: AsyncIterable<Uint8Array>): AsyncIterableIterator<CBORValue>;

package/lib/{decodeStream.js → decodeAsyncIterable.js}

@@ -1,8 +1,8 @@
 var _a;
 import { getFloat16 } from "fp16";
 import { UnsafeIntegerError, maxSafeInteger, minSafeInteger } from "./utils.js";
-class DecoderStream {
-    constructor(source) {
+export class Decoder {
+    constructor(source, options = {}) {
         this.offset = 0;
         this.byteLength = 0;
         this.chunks = [];
@@ -25,6 +25,7 @@ class DecoderStream {
         this.uint32 = this.constant(4, (view) => view.getUint32(0));
         this.uint64 = this.constant(8, (view) => view.getBigUint64(0));
         this.iter = source[Symbol.asyncIterator]();
+        this.onFree = options.onFree;
     }
     async allocate(size) {
         while (this.byteLength < size) {
@@ -64,6 +65,11 @@ class DecoderStream {
                 this.byteLength -= capacity;
             }
         }
+        if (this.onFree !== undefined) {
+            for (let i = 0; i < deleteCount; i++) {
+                this.onFree(this.chunks[i]);
+            }
+        }
         this.chunks.splice(0, deleteCount);
     }
     async decodeBytes(length) {
@@ -200,6 +206,7 @@ class DecoderStream {
     }
 }
 _a = Symbol.asyncIterator;
-export async function* decodeStream(source) {
-    yield* new DecoderStream(source);
+/** Decode an async iterable of Uint8Array chunks into an async iterable of CBOR values */
+export async function* decodeAsyncIterable(source) {
+    yield* new Decoder(source);
 }

package/lib/decodeIterable.d.ts

@@ -0,0 +1,3 @@
+import type { CBORValue } from "./types.js";
+/** Decode an iterable of Uint8Array chunks into an iterable of CBOR values */
+export declare function decodeIterable(source: Iterable<Uint8Array>): IterableIterator<CBORValue>;

package/lib/decodeIterable.js

@@ -0,0 +1,206 @@
+var _a;
+import { getFloat16 } from "fp16";
+import { UnsafeIntegerError, maxSafeInteger, minSafeInteger } from "./utils.js";
+class Decoder {
+    constructor(source) {
+        this.offset = 0;
+        this.byteLength = 0;
+        this.chunks = [];
+        this.constantBuffer = new ArrayBuffer(8);
+        this.constantView = new DataView(this.constantBuffer);
+        this[_a] = () => this;
+        this.constant = (size, f) => {
+            return () => {
+                this.allocate(size);
+                const array = new Uint8Array(this.constantBuffer, 0, size);
+                this.fill(array);
+                return f(this.constantView);
+            };
+        };
+        this.float16 = this.constant(2, (view) => getFloat16(view, 0));
+        this.float32 = this.constant(4, (view) => view.getFloat32(0));
+        this.float64 = this.constant(8, (view) => view.getFloat64(0));
+        this.uint8 = this.constant(1, (view) => view.getUint8(0));
+        this.uint16 = this.constant(2, (view) => view.getUint16(0));
+        this.uint32 = this.constant(4, (view) => view.getUint32(0));
+        this.uint64 = this.constant(8, (view) => view.getBigUint64(0));
+        this.iter = source[Symbol.iterator]();
+    }
+    allocate(size) {
+        while (this.byteLength < size) {
+            const { done, value } = this.iter.next();
+            if (done) {
+                throw new Error("stream ended prematurely");
+            }
+            else {
+                this.chunks.push(value);
+                this.byteLength += value.byteLength;
+            }
+        }
+    }
+    fill(target) {
+        if (this.byteLength < target.byteLength) {
+            throw new Error("internal error - please file a bug report!");
+        }
+        let byteLength = 0;
+        let deleteCount = 0;
+        for (let i = 0; byteLength < target.byteLength; i++) {
+            const chunk = this.chunks[i];
+            const capacity = target.byteLength - byteLength;
+            const length = chunk.byteLength - this.offset;
+            if (length <= capacity) {
+                // copy the entire remainder of the chunk
+                target.set(chunk.subarray(this.offset), byteLength);
+                byteLength += length;
+                deleteCount += 1;
+                this.offset = 0;
+                this.byteLength -= length;
+            }
+            else {
+                // fill the remainder of the target
+                target.set(chunk.subarray(this.offset, this.offset + capacity), byteLength);
+                byteLength += capacity; // equivalent to break
+                this.offset += capacity;
+                this.byteLength -= capacity;
+            }
+        }
+        this.chunks.splice(0, deleteCount);
+    }
+    decodeBytes(length) {
+        this.allocate(length);
+        const array = new Uint8Array(length);
+        this.fill(array);
+        return array;
+    }
+    decodeString(length) {
+        this.allocate(length);
+        const data = new Uint8Array(length);
+        this.fill(data);
+        return new TextDecoder().decode(data);
+    }
+    getArgument(additionalInformation) {
+        if (additionalInformation < 24) {
+            return { value: additionalInformation };
+        }
+        else if (additionalInformation === 24) {
+            return { value: this.uint8() };
+        }
+        else if (additionalInformation === 25) {
+            return { value: this.uint16() };
+        }
+        else if (additionalInformation === 26) {
+            return { value: this.uint32() };
+        }
+        else if (additionalInformation === 27) {
+            const uint64 = this.uint64();
+            const value = maxSafeInteger < uint64 ? Infinity : Number(uint64);
+            return { value, uint64 };
+        }
+        else if (additionalInformation === 31) {
+            throw new Error("microcbor does not support decoding indefinite-length items");
+        }
+        else {
+            throw new Error("invalid argument encoding");
+        }
+    }
+    next() {
+        while (this.byteLength === 0) {
+            const { done, value } = this.iter.next();
+            if (done) {
+                return { done: true, value: undefined };
+            }
+            else if (value.byteLength > 0) {
+                this.chunks.push(value);
+                this.byteLength += value.byteLength;
+            }
+        }
+        const value = this.decodeValue();
+        return { done: false, value };
+    }
+    decodeValue() {
+        const initialByte = this.uint8();
+        const majorType = initialByte >> 5;
+        const additionalInformation = initialByte & 0x1f;
+        if (majorType === 0) {
+            const { value, uint64 } = this.getArgument(additionalInformation);
+            if (uint64 !== undefined && maxSafeInteger < uint64) {
+                throw new UnsafeIntegerError("cannot decode integers greater than 2^53-1", uint64);
+            }
+            else {
+                return value;
+            }
+        }
+        else if (majorType === 1) {
+            const { value, uint64 } = this.getArgument(additionalInformation);
+            if (uint64 !== undefined && -1n - uint64 < minSafeInteger) {
+                throw new UnsafeIntegerError("cannot decode integers less than -2^53+1", -1n - uint64);
+            }
+            else {
+                return -1 - value;
+            }
+        }
+        else if (majorType === 2) {
+            const { value: length } = this.getArgument(additionalInformation);
+            return this.decodeBytes(length);
+        }
+        else if (majorType === 3) {
+            const { value: length } = this.getArgument(additionalInformation);
+            return this.decodeString(length);
+        }
+        else if (majorType === 4) {
+            const { value: length } = this.getArgument(additionalInformation);
+            const value = new Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = this.decodeValue();
+            }
+            return value;
+        }
+        else if (majorType === 5) {
+            const { value: length } = this.getArgument(additionalInformation);
+            const value = {};
+            for (let i = 0; i < length; i++) {
+                const key = this.decodeValue();
+                if (typeof key !== "string") {
+                    throw new Error("microcbor only supports string keys in objects");
+                }
+                value[key] = this.decodeValue();
+            }
+            return value;
+        }
+        else if (majorType === 6) {
+            throw new Error("microcbor does not support tagged data items");
+        }
+        else if (majorType === 7) {
+            switch (additionalInformation) {
+                case 20:
+                    return false;
+                case 21:
+                    return true;
+                case 22:
+                    return null;
+                case 23:
+                    return undefined;
+                case 24:
+                    throw new Error("microcbor does not support decoding unassigned simple values");
+                case 25:
+                    return this.float16();
+                case 26:
+                    return this.float32();
+                case 27:
+                    return this.float64();
+                case 31:
+                    throw new Error("microcbor does not support decoding indefinite-length items");
+                default:
+                    throw new Error("invalid simple value");
+            }
+        }
+        else {
+            throw new Error("invalid major type");
+        }
+    }
+}
+_a = Symbol.iterator;
+/** Decode an iterable of Uint8Array chunks into an iterable of CBOR values */
+export function* decodeIterable(source) {
+    yield* new Decoder(source);
+}

package/lib/encodeAsyncIterable.d.ts

@@ -0,0 +1,4 @@
+import type { CBORValue } from "./types.js";
+import { EncodeOptions } from "./Encoder.js";
+/** Encode an async iterable of CBOR values into an async iterable of Uint8Array chunks */
+export declare function encodeAsyncIterable(source: AsyncIterable<CBORValue>, options?: EncodeOptions): AsyncIterableIterator<Uint8Array>;

package/lib/encodeAsyncIterable.js

@@ -0,0 +1,9 @@
+import { Encoder } from "./Encoder.js";
+/** Encode an async iterable of CBOR values into an async iterable of Uint8Array chunks */
+export async function* encodeAsyncIterable(source, options = {}) {
+    const encoder = new Encoder(options);
+    for await (const value of source) {
+        yield* encoder.encodeValue(value);
+    }
+    yield* encoder.flush();
+}

package/lib/encodeIterable.d.ts

@@ -0,0 +1,4 @@
+import type { CBORValue } from "./types.js";
+import { EncodeOptions } from "./Encoder.js";
+/** Encode an iterable of CBOR values into an iterable of Uint8Array chunks */
+export declare function encodeIterable(source: Iterable<CBORValue>, options?: EncodeOptions): IterableIterator<Uint8Array>;

package/lib/encodeIterable.js

@@ -0,0 +1,9 @@
+import { Encoder } from "./Encoder.js";
+/** Encode an iterable of CBOR values into an iterable of Uint8Array chunks */
+export function* encodeIterable(source, options = {}) {
+    const encoder = new Encoder(options);
+    for (const value of source) {
+        yield* encoder.encodeValue(value);
+    }
+    yield* encoder.flush();
+}

package/lib/encodingLength.d.ts

@@ -1,2 +1,6 @@
-import type { CBORValue } from "./types.js";
+import { CBORValue } from "./types.js";
+/**
+ * Calculate the byte length that a value will encode into
+ * without actually allocating anything.
+ */
 export declare function encodingLength(value: CBORValue): number;