microcbor 0.1.0 → 0.2.1

package/lib/decodeStream.js

@@ -0,0 +1,205 @@
+var _a;
+import { getFloat16 } from "fp16";
+import { UnsafeIntegerError, maxSafeInteger, minSafeInteger } from "./utils.js";
+class DecoderStream {
+    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 async () => {
+                await 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.asyncIterator]();
+    }
+    async allocate(size) {
+        while (this.byteLength < size) {
+            const { done, value } = await 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);
+    }
+    async decodeBytes(length) {
+        await this.allocate(length);
+        const array = new Uint8Array(length);
+        this.fill(array);
+        return array;
+    }
+    async decodeString(length) {
+        await this.allocate(length);
+        const data = new Uint8Array(length);
+        this.fill(data);
+        return new TextDecoder().decode(data);
+    }
+    async getArgument(additionalInformation) {
+        if (additionalInformation < 24) {
+            return { value: additionalInformation };
+        }
+        else if (additionalInformation === 24) {
+            return { value: await this.uint8() };
+        }
+        else if (additionalInformation === 25) {
+            return { value: await this.uint16() };
+        }
+        else if (additionalInformation === 26) {
+            return { value: await this.uint32() };
+        }
+        else if (additionalInformation === 27) {
+            const uint64 = await 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");
+        }
+    }
+    async next() {
+        while (this.byteLength === 0) {
+            const { done, value } = await 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 = await this.decodeValue();
+        return { done: false, value };
+    }
+    async decodeValue() {
+        const initialByte = await this.uint8();
+        const majorType = initialByte >> 5;
+        const additionalInformation = initialByte & 0x1f;
+        if (majorType === 0) {
+            const { value, uint64 } = await 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 } = await 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 } = await this.getArgument(additionalInformation);
+            return await this.decodeBytes(length);
+        }
+        else if (majorType === 3) {
+            const { value: length } = await this.getArgument(additionalInformation);
+            return await this.decodeString(length);
+        }
+        else if (majorType === 4) {
+            const { value: length } = await this.getArgument(additionalInformation);
+            const value = new Array(length);
+            for (let i = 0; i < length; i++) {
+                value[i] = await this.decodeValue();
+            }
+            return value;
+        }
+        else if (majorType === 5) {
+            const { value: length } = await this.getArgument(additionalInformation);
+            const value = {};
+            for (let i = 0; i < length; i++) {
+                const key = await this.decodeValue();
+                if (typeof key !== "string") {
+                    throw new Error("microcbor only supports string keys in objects");
+                }
+                value[key] = await 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 await this.float16();
+                case 26:
+                    return await this.float32();
+                case 27:
+                    return await 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.asyncIterator;
+export async function* decodeStream(source) {
+    yield* new DecoderStream(source);
+}

package/lib/encode.d.ts

@@ -1,5 +1,35 @@
-export interface EncodeOptions {
-    strictJSON?: boolean;
-    chunkSize?: number;
+import type { CBORValue } from "./types.js";
+export declare class Encoder {
+    static defaultChunkSize: number;
+    closed: boolean;
+    private buffer;
+    private view;
+    private offset;
+    private readonly encoder;
+    private readonly chunkSize;
+    constructor(options?: {
+        chunkSize?: number;
+        noCopy?: boolean;
+    });
+    private allocate;
+    private float16;
+    private float32;
+    private float64;
+    private uint8;
+    private uint16;
+    private uint32;
+    private uint64;
+    private encodeTypeAndArgument;
+    private encodeNumber;
+    private encodeInteger;
+    private encodeFloat;
+    private encodeString;
+    private encodeBytes;
+    encodeValue(value: CBORValue): Iterable<Uint8Array>;
+    flush(): Iterable<Uint8Array>;
+    private static compareKeys;
+    private static getAdditionalInformation;
 }
-export declare function encode(value: any, options?: EncodeOptions): Uint8Array;
+export declare function encode(value: CBORValue, options?: {
+    chunkSize?: number;
+}): Uint8Array;

package/lib/encode.js

@@ -1,193 +1,222 @@
-import { getFloat16Precision, getFloat32Precision, setFloat16 } from "fp16";
-const defaultChunkSize = 512;
-function* allocate(state, size) {
-    if (state.buffer.byteLength < state.offset + size) {
-        yield new Uint8Array(state.buffer, 0, state.offset);
-        const byteLength = Math.max(size, state.options.chunkSize || defaultChunkSize);
-        state.buffer = new ArrayBuffer(byteLength);
-        state.view = new DataView(state.buffer);
-        state.offset = 0;
-    }
-}
-const c = (size, f) => function* (state, value) {
-    yield* allocate(state, size);
-    f(state, value);
-    state.offset += size;
-};
-const constants = {
-    float16: c(2, (state, value) => setFloat16(state.view, state.offset, value)),
-    float32: c(4, (state, value) => state.view.setFloat32(state.offset, value)),
-    float64: c(8, (state, value) => state.view.setFloat64(state.offset, value)),
-    uint8: c(1, (state, value) => state.view.setUint8(state.offset, value)),
-    uint16: c(2, (state, value) => state.view.setUint16(state.offset, value)),
-    uint32: c(4, (state, value) => state.view.setUint32(state.offset, value)),
-    uint64: c(8, (state, value) => state.view.setBigUint64(state.offset, BigInt(value))),
-};
-function* encodeTypeAndArgument(state, type, argument) {
-    const additionalInformation = getAdditionalInformation(argument);
-    yield* constants.uint8(state, (type << 5) | additionalInformation);
-    switch (additionalInformation) {
-        case 24:
-            return yield* constants.uint8(state, argument);
-        case 25:
-            return yield* constants.uint16(state, argument);
-        case 26:
-            return yield* constants.uint32(state, argument);
-        case 27:
-            return yield* constants.uint64(state, argument);
-    }
-}
-function* encodeNumber(state, value) {
-    if (Object.is(value, 0)) {
-        yield* encodeInteger(state, value);
-    }
-    else if (Object.is(value, -0)) {
-        yield* encodeFloat(state, value);
-    }
-    else if (Math.floor(value) === value &&
-        Number.MIN_SAFE_INTEGER <= value &&
-        value <= Number.MAX_SAFE_INTEGER) {
-        yield* encodeInteger(state, value);
-    }
-    else {
-        if (state.options.strictJSON === true) {
-            if (isNaN(value)) {
-                throw new Error("cannot encode NaN when strict mode is enabled");
-            }
-            else if (value === Infinity || value === -Infinity) {
-                throw new Error("cannot encode +/- Infinity when strict mode is enabled");
-            }
+import { getFloat16Precision, getFloat32Precision, setFloat16, Precision, } from "fp16";
+export class Encoder {
+    constructor(options = {}) {
+        this.encoder = new TextEncoder();
+        this.chunkSize = options.chunkSize || Encoder.defaultChunkSize;
+        this.buffer = new ArrayBuffer(this.chunkSize);
+        this.view = new DataView(this.buffer);
+        this.offset = 0;
+        this.closed = false;
+    }
+    *allocate(size) {
+        if (this.buffer.byteLength < this.offset + size) {
+            yield new Uint8Array(this.buffer, 0, this.offset);
+            const byteLength = Math.max(size, this.chunkSize);
+            this.buffer = new ArrayBuffer(byteLength);
+            this.view = new DataView(this.buffer);
+            this.offset = 0;
         }
-        yield* encodeFloat(state, value);
     }
-}
-function* encodeInteger(state, value) {
-    if (value < 0) {
-        yield* encodeTypeAndArgument(state, 1, -value - 1);
-    }
-    else {
-        yield* encodeTypeAndArgument(state, 0, value);
-    }
-}
-function* encodeFloat(state, value) {
-    if (getFloat16Precision(value) === "exact") {
-        yield* constants.uint8(state, 0xe0 | 25);
-        return yield* constants.float16(state, value);
-    }
-    else if (getFloat32Precision(value) === "exact") {
-        yield* constants.uint8(state, 0xe0 | 26);
-        return yield* constants.float32(state, value);
+    *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);
+        }
     }
-    else {
-        yield* constants.uint8(state, 0xe0 | 27);
-        return yield* constants.float64(state, value);
+    *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);
+        }
     }
-}
-function* encodeString(state, value) {
-    const data = new TextEncoder().encode(value);
-    yield* encodeTypeAndArgument(state, 3, data.byteLength);
-    yield* allocate(state, data.byteLength);
-    new Uint8Array(state.buffer, state.offset).set(data);
-    state.offset += data.byteLength;
-}
-function getAdditionalInformation(argument) {
-    if (argument < 24) {
-        return argument;
+    *encodeInteger(value) {
+        if (value < 0) {
+            yield* this.encodeTypeAndArgument(1, -value - 1);
+        }
+        else {
+            yield* this.encodeTypeAndArgument(0, value);
+        }
     }
-    else if (argument < 0x100) {
-        return 24;
+    *encodeFloat(value) {
+        if (getFloat16Precision(value) === Precision.Exact) {
+            yield* this.uint8(0xe0 | 25);
+            yield* this.float16(value);
+        }
+        else if (getFloat32Precision(value) === Precision.Exact) {
+            yield* this.uint8(0xe0 | 26);
+            yield* this.float32(value);
+        }
+        else {
+            yield* this.uint8(0xe0 | 27);
+            yield* this.float64(value);
+        }
     }
-    else if (argument < 0x10000) {
-        return 25;
+    *encodeString(value) {
+        const data = this.encoder.encode(value);
+        yield* this.encodeTypeAndArgument(3, data.byteLength);
+        yield* this.allocate(data.byteLength);
+        new Uint8Array(this.buffer, this.offset).set(data);
+        this.offset += data.byteLength;
+    }
+    *encodeBytes(value) {
+        yield* this.encodeTypeAndArgument(2, value.byteLength);
+        yield* this.allocate(value.byteLength);
+        new Uint8Array(this.buffer, this.offset, value.byteLength).set(value);
+        this.offset += value.byteLength;
+    }
+    *encodeValue(value) {
+        if (this.closed) {
+            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 keys = Object.keys(value).sort(Encoder.compareKeys);
+            yield* this.encodeTypeAndArgument(5, keys.length);
+            for (const key of keys) {
+                yield* this.encodeString(key);
+                yield* this.encodeValue(value[key]);
+            }
+        }
     }
-    else if (argument < 0x100000000) {
-        return 26;
+    *flush() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        if (this.offset > 0) {
+            yield new Uint8Array(this.buffer, 0, this.offset);
+        }
     }
-    else {
-        return 27;
+    // 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!
+    // However, microcbor only supports string keys, which means we
+    // can get away with sorting them without actually encoding them
+    // first. 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 compareKeys(a, b) {
+        if (a.length < b.length) {
+            return -1;
+        }
+        else if (b.length < a.length) {
+            return 1;
+        }
+        else {
+            return a < b ? -1 : 1;
+        }
     }
-}
-function* encodeValue(state, value) {
-    if (value === false) {
-        return yield* constants.uint8(state, 0xf4);
-    }
-    else if (value === true) {
-        return yield* constants.uint8(state, 0xf5);
-    }
-    else if (value === null) {
-        return yield* constants.uint8(state, 0xf6);
-    }
-    else if (value === undefined) {
-        throw new Error("microcbor does not support encoding the undefined value");
-    }
-    else if (typeof value === "number") {
-        return yield* encodeNumber(state, value);
-    }
-    else if (typeof value === "string") {
-        return yield* encodeString(state, value);
-    }
-    else if (Array.isArray(value)) {
-        yield* encodeTypeAndArgument(state, 4, value.length);
-        for (const element of value) {
-            yield* encodeValue(state, element);
-        }
-        return;
-    }
-    else if (typeof value !== "object") {
-        throw new Error("invalid value");
-    }
-    else {
-        // Note: this can't be a normal sort, because 'b' needs to sort before
-        // 'aa'
-        // 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!
-        // However, microcbor only supports string keys, which means we
-        // can get away with sorting them without actually encoding them
-        // first. 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 lengt
-        // prefix (either in the additionalInformation bits, if < 24, or
-        // in the next serveral bytes, but in all cases the order holds).
-        const keys = Object.keys(value).sort((a, b) => {
-            if (a.length < b.length) {
-                return -1;
-            }
-            else if (b.length < a.length) {
-                return 1;
-            }
-            else {
-                return a < b ? -1 : 1;
-            }
-        });
-        yield* encodeTypeAndArgument(state, 5, keys.length);
-        for (const key of keys) {
-            if (typeof key === "string") {
-                yield* encodeString(state, key);
-                yield* encodeValue(state, value[key]);
-            }
-            else {
-                throw new Error("object keys must be strings");
-            }
+    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;
         }
-        return;
     }
 }
+Encoder.defaultChunkSize = 512;
 export function encode(value, options = {}) {
-    const buffer = new ArrayBuffer(options.chunkSize || defaultChunkSize);
-    const state = {
-        options: options,
-        buffer: buffer,
-        view: new DataView(buffer),
-        offset: 0,
-    };
-    const chunks = Array.from(encodeValue(state, value));
-    if (state.offset > 0) {
-        chunks.push(new Uint8Array(state.buffer, 0, state.offset));
-    }
+    const encoder = new Encoder(options);
     let byteLength = 0;
-    for (const chunk of chunks) {
-        byteLength += chunk.length;
+    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;

package/lib/encodeStream.d.ts

@@ -0,0 +1,4 @@
+import type { CBORValue } from "./types.js";
+export declare function encodeStream(source: AsyncIterable<CBORValue>, options?: {
+    chunkSize?: number;
+}): AsyncIterable<Uint8Array>;

package/lib/encodeStream.js

@@ -0,0 +1,8 @@
+import { Encoder } from "./encode.js";
+export async function* encodeStream(source, options = {}) {
+    const encoder = new Encoder(options);
+    for await (const value of source) {
+        yield* encoder.encodeValue(value);
+    }
+    yield* encoder.flush();
+}

package/lib/encodingLength.d.ts

@@ -0,0 +1,2 @@
+import type { CBORValue } from "./types.js";
+export declare function encodingLength(value: CBORValue): number;