@fireproof/vendor 1.1.0 → 1.2.0

package/src/cborg/types/utils/5map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"5map.d.ts","sourceRoot":"","sources":["../../utils/5map.js"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,uCANW,UAAU,OACV,MAAM,SACN,MAAM,YACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,iCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,kCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,kCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAGD;;;;;;GAMG;AACH,kCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAQjB;AAED;;;;;;GAMG;AACH,0CANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAED;;;;GAIG;AACH,+BAJW,EAAE,SACF,KAAK,uBACL,OAAO,iBAAiB,EAAE,aAAa,QAIjD;;;IAMD;;;OAGG;IACH,4BAHW,KAAK,GACH,MAAM,CAIlB;;iBA5GY,OAAO,SAAS,EAAE,EAAE;4BACpB,OAAO,iBAAiB,EAAE,aAAa;sBALxB,YAAY"}

package/src/cborg/types/utils/6tag.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @typedef {import('./bl.js').Bl} Bl
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+ */
+/**
+ * @param {Uint8Array} _data
+ * @param {number} _pos
+ * @param {number} minor
+ * @param {DecodeOptions} _options
+ * @returns {Token}
+ */
+export function decodeTagCompact(_data: Uint8Array, _pos: number, minor: number, _options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeTag8(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeTag16(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeTag32(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeTag64(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Bl} buf
+ * @param {Token} token
+ * @param {import('../interface.js').EncodeOptions} options
+ */
+export function encodeTag(buf: Bl, token: Token, { encodeErrPrefix }: import("../interface.js").EncodeOptions): void;
+export namespace encodeTag {
+    let compareTokens: (tok1: Token, tok2: Token) => number;
+    /**
+     * @param {Token} token
+     * @returns {number}
+     */
+    function encodedSize(token: Token): number;
+}
+export type Bl = import("./bl.js").Bl;
+export type DecodeOptions = import("../interface.js").DecodeOptions;
+import { Token } from './token.js';
+//# sourceMappingURL=6tag.d.ts.map

package/src/cborg/types/utils/6tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"6tag.d.ts","sourceRoot":"","sources":["../../utils/6tag.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;GAMG;AACH,wCANW,UAAU,QACV,MAAM,SACN,MAAM,YACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,iCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,kCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,kCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,kCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;GAIG;AACH,+BAJW,EAAE,SACF,KAAK,uBACL,OAAO,iBAAiB,EAAE,aAAa,QAIjD;;;IAID;;;OAGG;IACH,4BAHW,KAAK,GACH,MAAM,CAIlB;;iBA5EY,OAAO,SAAS,EAAE,EAAE;4BACpB,OAAO,iBAAiB,EAAE,aAAa;sBALxB,YAAY"}

package/src/cborg/types/utils/7float.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @param {Uint8Array} _data
+ * @param {number} _pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUndefined(_data: Uint8Array, _pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} _data
+ * @param {number} _pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeBreak(_data: Uint8Array, _pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeFloat16(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeFloat32(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeFloat64(data: Uint8Array, pos: number, _minor: number, options: DecodeOptions): Token;
+/**
+ * @param {Bl} buf
+ * @param {Token} token
+ * @param {EncodeOptions} options
+ */
+export function encodeFloat(buf: Bl, token: Token, options: EncodeOptions): void;
+export namespace encodeFloat {
+    /**
+     * @param {Token} token
+     * @param {EncodeOptions} options
+     * @returns {number}
+     */
+    function encodedSize(token: Token, options: EncodeOptions): number;
+    let compareTokens: (tok1: Token, tok2: Token) => number;
+}
+export type Bl = import("./bl.js").Bl;
+export type DecodeOptions = import("../interface.js").DecodeOptions;
+export type EncodeOptions = import("../interface.js").EncodeOptions;
+import { Token } from './token.js';
+//# sourceMappingURL=7float.d.ts.map

package/src/cborg/types/utils/7float.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"7float.d.ts","sourceRoot":"","sources":["../../utils/7float.js"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,uCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CASjB;AAED;;;;;;GAMG;AACH,mCANW,UAAU,QACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAOjB;AAoBD;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;;;GAMG;AACH,oCANW,UAAU,OACV,MAAM,UACN,MAAM,WACN,aAAa,GACX,KAAK,CAIjB;AAED;;;;GAIG;AACH,iCAJW,EAAE,SACF,KAAK,WACL,aAAa,QAwCvB;;IAED;;;;OAIG;IACH,4BAJW,KAAK,WACL,aAAa,GACX,MAAM,CAsBlB;;;iBAjKY,OAAO,SAAS,EAAE,EAAE;4BACpB,OAAO,iBAAiB,EAAE,aAAa;4BACvC,OAAO,iBAAiB,EAAE,aAAa;sBANxB,YAAY"}

package/src/cborg/types/utils/bl.d.ts

@@ -0,0 +1,26 @@
+export class Bl {
+    /**
+     * @param {number} [chunkSize]
+     */
+    constructor(chunkSize?: number);
+    chunkSize: number;
+    /** @type {number} */
+    cursor: number;
+    /** @type {number} */
+    maxCursor: number;
+    /** @type {(Uint8Array|number[])[]} */
+    chunks: (Uint8Array | number[])[];
+    /** @type {Uint8Array|number[]|null} */
+    _initReuseChunk: Uint8Array | number[] | null;
+    reset(): void;
+    /**
+     * @param {Uint8Array|number[]} bytes
+     */
+    push(bytes: Uint8Array | number[]): void;
+    /**
+     * @param {boolean} [reset]
+     * @returns {Uint8Array}
+     */
+    toBytes(reset?: boolean): Uint8Array;
+}
+//# sourceMappingURL=bl.d.ts.map

package/src/cborg/types/utils/bl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bl.d.ts","sourceRoot":"","sources":["../../utils/bl.js"],"names":[],"mappings":"AA0BA;IACE;;OAEG;IACH,wBAFW,MAAM,EAahB;IAVC,kBAA0B;IAC1B,qBAAqB;IACrB,QADW,MAAM,CACF;IACf,qBAAqB;IACrB,WADW,MAAM,CACE;IACnB,sCAAsC;IACtC,QADW,CAAC,UAAU,GAAC,MAAM,EAAE,CAAC,EAAE,CAClB;IAEhB,uCAAuC;IACvC,iBADW,UAAU,GAAC,MAAM,EAAE,GAAC,IAAI,CACR;IAG7B,cAUC;IAED;;OAEG;IACH,YAFW,UAAU,GAAC,MAAM,EAAE,QAsC7B;IAED;;;OAGG;IACH,gBAHW,OAAO,GACL,UAAU,CAwBtB;CACF"}

package/src/cborg/types/utils/byte-utils.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @param {Uint8Array|number[]} buf
+ * @returns {Uint8Array}
+ */
+export function asU8A(buf: Uint8Array | number[]): Uint8Array;
+/**
+ * @param {Uint8Array} b1
+ * @param {Uint8Array} b2
+ * @returns {number}
+ */
+export function compare(b1: Uint8Array, b2: Uint8Array): number;
+/**
+ * @param {number[]} codePoints
+ * @returns {string}
+ */
+export function decodeCodePointsArray(codePoints: number[]): string;
+export const useBuffer: boolean;
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} start
+ * @param {number} end
+ */
+export function toString(bytes: Uint8Array, start: number, end: number): string;
+export const fromString: ((string: string) => number[] | Buffer<ArrayBuffer>) | ((string: string) => Uint8Array<ArrayBufferLike> | number[]);
+export function fromArray(arr: number[]): Uint8Array;
+/**
+ * @param {Uint8Array} bytes
+ * @param {number} start
+ * @param {number} end
+ */
+export function slice(bytes: Uint8Array, start: number, end: number): Uint8Array<ArrayBuffer>;
+/**
+ * @param {Uint8Array[]} chunks
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+export function concat(chunks: Uint8Array[], length: number): Uint8Array;
+/**
+ * @param {number} size
+ * @returns {Uint8Array}
+ */
+export function alloc(size: number): Uint8Array;
+/**
+ * @param {Uint8Array} d
+ * @returns {string}
+ */
+export function toHex(d: Uint8Array): string;
+/**
+ * @param {string|Uint8Array} hex
+ * @returns {Uint8Array}
+ */
+export function fromHex(hex: string | Uint8Array): Uint8Array;
+//# sourceMappingURL=byte-utils.d.ts.map

package/src/cborg/types/utils/byte-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-utils.d.ts","sourceRoot":"","sources":["../../utils/byte-utils.js"],"names":[],"mappings":"AAwBA;;;GAGG;AACH,2BAHW,UAAU,GAAC,MAAM,EAAE,GACjB,UAAU,CAQtB;AA8ND;;;;GAIG;AACH,4BAJW,UAAU,MACV,UAAU,GACR,MAAM,CAgBlB;AAyHD;;;GAGG;AACH,kDAHW,MAAM,EAAE,GACN,MAAM,CAkBlB;AA5ZD,gCAMkD;AA4B9C;;;;GAIG;AACH,gCAJW,UAAU,SACV,MAAM,OACN,MAAM,UAQhB;AAcL,mCAGe,MAAM,iDAYN,MAAM,6CAIhB;AAOE,+BAHI,MAAM,EAAE,GACN,UAAU,CAItB;AAIG;;;;GAIG;AACH,6BAJW,UAAU,SACV,MAAM,OACN,MAAM,2BAOhB;AAcD;;;;GAIG;AACH,+BAJW,UAAU,EAAE,UACZ,MAAM,GACJ,UAAU,CActB;AAwBD;;;GAGG;AACH,4BAHW,MAAM,GACJ,UAAU,CAMtB;AAaD;;;GAGG;AACH,yBAHW,UAAU,GACR,MAAM,CAQlB;AAiBH;;;GAGG;AACD,6BAHS,MAAM,GAAC,UAAU,GACf,UAAU,CAQpB"}

package/src/cborg/types/utils/common.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} need
+ * @param {string} decodeErrPrefix
+ */
+export function assertEnoughData(data: Uint8Array, pos: number, need: number, decodeErrPrefix: string): void;
+//# sourceMappingURL=common.d.ts.map

package/src/cborg/types/utils/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../utils/common.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,uCALW,UAAU,OACV,MAAM,QACN,MAAM,mBACN,MAAM,QAMhB"}

package/src/cborg/types/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./byte-utils.js";
+export * from "./jump.js";
+export { encodeNegint } from "./1negint.js";
+export { encodeBytes } from "./2bytes.js";
+export { encodeString } from "./3string.js";
+export { encodeArray } from "./4array.js";
+export { encodeMap } from "./5map.js";
+export { encodeTag } from "./6tag.js";
+export { encodeFloat } from "./7float.js";
+export { Bl } from "./bl.js";
+export { encodeUint, uintBoundaries } from "./0uint.js";
+export { Token, Type } from "./token.js";
+//# sourceMappingURL=index.d.ts.map

package/src/cborg/types/utils/index.d.ts.map

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

package/src/cborg/types/utils/jump.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {string} decodeErrPrefix
+ * @return {DecodeFunction[]}
+ */
+export function jump(decodeErrPrefix: string): DecodeFunction[];
+/**
+ * @param {Token} token
+ * @returns {Uint8Array|undefined}
+ */
+export function quickEncodeToken(token: Token): Uint8Array | undefined;
+/** @type {Token[]} */
+export const quick: Token[];
+export type DecodeOptions = import("../interface.js").DecodeOptions;
+export type DecodeFunction = import("../interface.js").DecodeFunction;
+import { Token } from './token.js';
+//# sourceMappingURL=jump.d.ts.map

package/src/cborg/types/utils/jump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jump.d.ts","sourceRoot":"","sources":["../../utils/jump.js"],"names":[],"mappings":"AAwCA;;;GAGG;AACH,sCAHW,MAAM,GACL,cAAc,EAAE,CA0G3B;AA2BD;;;GAGG;AACH,wCAHW,KAAK,GACH,UAAU,GAAC,SAAS,CA4ChC;AAvED,sBAAsB;AACtB,oBADW,KAAK,EAAE,CACK;4BA3IV,OAAO,iBAAiB,EAAE,aAAa;6BACvC,OAAO,iBAAiB,EAAE,cAAc;sBAbzB,YAAY"}

package/src/cborg/types/utils/token.d.ts

@@ -0,0 +1,59 @@
+export class Type {
+    /**
+     * @param {number} major
+     * @param {string} name
+     * @param {boolean} terminal
+     */
+    constructor(major: number, name: string, terminal: boolean);
+    major: number;
+    majorEncoded: number;
+    name: string;
+    terminal: boolean;
+    toString(): string;
+    /**
+     * @param {Type} typ
+     * @returns {boolean}
+     */
+    equals(typ: Type): boolean;
+    /**
+     * @param {Type} typ
+     * @returns {number}
+     */
+    compare(typ: Type): number;
+}
+export namespace Type {
+    export let uint: Type;
+    export let negint: Type;
+    export let bytes: Type;
+    export let string: Type;
+    export let array: Type;
+    export let map: Type;
+    export let tag: Type;
+    export let float: Type;
+    let _false: Type;
+    export { _false as false };
+    let _true: Type;
+    export { _true as true };
+    let _null: Type;
+    export { _null as null };
+    export let undefined: Type;
+    let _break: Type;
+    export { _break as break };
+}
+export class Token {
+    /**
+     * @param {Type} type
+     * @param {any} [value]
+     * @param {number} [encodedLength]
+     */
+    constructor(type: Type, value?: any, encodedLength?: number);
+    type: Type;
+    value: any;
+    encodedLength: number | undefined;
+    /** @type {Uint8Array|undefined} */
+    encodedBytes: Uint8Array | undefined;
+    /** @type {Uint8Array|undefined} */
+    byteValue: Uint8Array | undefined;
+    toString(): string;
+}
+//# sourceMappingURL=token.d.ts.map

package/src/cborg/types/utils/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../utils/token.js"],"names":[],"mappings":"AAAA;IACE;;;;OAIG;IACH,mBAJW,MAAM,QACN,MAAM,YACN,OAAO,EAOjB;IAJC,cAAkB;IAClB,qBAA8B;IAC9B,aAAgB;IAChB,kBAAwB;IAI1B,mBAEC;IAED;;;OAGG;IACH,YAHW,IAAI,GACF,OAAO,CAInB;IAED;;;OAGG;IACH,aAHW,IAAI,GACF,MAAM,CAKlB;CACF;;;;;;;;;;;;;;;;;;;;AAmBD;IACE;;;;OAIG;IACH,kBAJW,IAAI,UACJ,GAAG,kBACH,MAAM,EAUhB;IAPC,WAAgB;IAChB,WAAkB;IAClB,kCAAkC;IAClC,mCAAmC;IACnC,cADW,UAAU,GAAC,SAAS,CACF;IAC7B,mCAAmC;IACnC,WADW,UAAU,GAAC,SAAS,CACL;IAI5B,mBAEC;CACF"}

package/src/cborg/utils/0uint.js

@@ -0,0 +1,229 @@
+/* globals BigInt */
+
+import { Token, Type } from './token.js'
+import { assertEnoughData } from './common.js'
+
+export const uintBoundaries = [24, 256, 65536, 4294967296, BigInt('18446744073709551616')]
+
+/**
+ * @typedef {import('./bl.js').Bl} Bl
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+ */
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number}
+ */
+export function readUint8 (data, offset, options) {
+  assertEnoughData(data, offset, 1, options.decodeErrPrefix)
+  const value = data[offset]
+  if (options.strict === true && value < uintBoundaries[0]) {
+    throw new Error(`${options.decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  return value
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number}
+ */
+export function readUint16 (data, offset, options) {
+  assertEnoughData(data, offset, 2, options.decodeErrPrefix)
+  const value = (data[offset] << 8) | data[offset + 1]
+  if (options.strict === true && value < uintBoundaries[1]) {
+    throw new Error(`${options.decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  return value
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number}
+ */
+export function readUint32 (data, offset, options) {
+  assertEnoughData(data, offset, 4, options.decodeErrPrefix)
+  const value = ((data[offset] * 16777216) /* 2 ** 24 */) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3]
+  if (options.strict === true && value < uintBoundaries[2]) {
+    throw new Error(`${options.decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  return value
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} offset
+ * @param {DecodeOptions} options
+ * @returns {number|bigint}
+ */
+export function readUint64 (data, offset, options) {
+  // assume BigInt, convert back to Number if within safe range
+  assertEnoughData(data, offset, 8, options.decodeErrPrefix)
+  const hi = ((data[offset] * 16777216) /* 2 ** 24 */) + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3]
+  const lo = ((data[offset + 4] * 16777216) /* 2 ** 24 */) + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7]
+  const value = (BigInt(hi) << BigInt(32)) + BigInt(lo)
+  if (options.strict === true && value < uintBoundaries[3]) {
+    throw new Error(`${options.decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`)
+  }
+  if (value <= Number.MAX_SAFE_INTEGER) {
+    return Number(value)
+  }
+  if (options.allowBigInt === true) {
+    return value
+  }
+  throw new Error(`${options.decodeErrPrefix} integers outside of the safe integer range are not supported`)
+}
+
+/* not required thanks to quick[] list
+const oneByteTokens = new Array(24).fill(0).map((v, i) => new Token(Type.uint, i, 1))
+export function decodeUintCompact (data, pos, minor, options) {
+  return oneByteTokens[minor]
+}
+*/
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint8 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint8(data, pos + 1, options), 2)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint16 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint16(data, pos + 1, options), 3)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint32 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint32(data, pos + 1, options), 5)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeUint64 (data, pos, _minor, options) {
+  return new Token(Type.uint, readUint64(data, pos + 1, options), 9)
+}
+
+/**
+ * @param {Bl} buf
+ * @param {Token} token
+ * @param {import('../interface.js').EncodeOptions} options
+ */
+export function encodeUint (buf, token, { encodeErrPrefix }) {
+  return encodeUintValue(buf, 0, token.value, encodeErrPrefix)
+}
+
+/**
+ * @param {Bl} buf
+ * @param {number} major
+ * @param {number|bigint} uint
+ * @param {string} decodeErrPrefix
+ */
+export function encodeUintValue (buf, major, uint, decodeErrPrefix) {
+  if (uint < uintBoundaries[0]) {
+    const nuint = Number(uint)
+    // pack into one byte, minor=0, additional=value
+    buf.push([major | nuint])
+  } else if (uint < uintBoundaries[1]) {
+    const nuint = Number(uint)
+    // pack into two byte, minor=0, additional=24
+    buf.push([major | 24, nuint])
+  } else if (uint < uintBoundaries[2]) {
+    const nuint = Number(uint)
+    // pack into three byte, minor=0, additional=25
+    buf.push([major | 25, nuint >>> 8, nuint & 0xff])
+  } else if (uint < uintBoundaries[3]) {
+    const nuint = Number(uint)
+    // pack into five byte, minor=0, additional=26
+    buf.push([major | 26, (nuint >>> 24) & 0xff, (nuint >>> 16) & 0xff, (nuint >>> 8) & 0xff, nuint & 0xff])
+  } else {
+    const buint = BigInt(uint)
+    if (buint < uintBoundaries[4]) {
+      // pack into nine byte, minor=0, additional=27
+      const set = [major | 27, 0, 0, 0, 0, 0, 0, 0]
+      // simulate bitwise above 32 bits
+      let lo = Number(buint & BigInt(0xffffffff))
+      let hi = Number(buint >> BigInt(32) & BigInt(0xffffffff))
+      set[8] = lo & 0xff
+      lo = lo >> 8
+      set[7] = lo & 0xff
+      lo = lo >> 8
+      set[6] = lo & 0xff
+      lo = lo >> 8
+      set[5] = lo & 0xff
+      set[4] = hi & 0xff
+      hi = hi >> 8
+      set[3] = hi & 0xff
+      hi = hi >> 8
+      set[2] = hi & 0xff
+      hi = hi >> 8
+      set[1] = hi & 0xff
+      buf.push(set)
+    } else {
+      throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`)
+    }
+  }
+}
+
+/**
+ * @param {Token} token
+ * @returns {number}
+ */
+encodeUint.encodedSize = function encodedSize (token) {
+  return encodeUintValue.encodedSize(token.value)
+}
+
+/**
+ * @param {number} uint
+ * @returns {number}
+ */
+encodeUintValue.encodedSize = function encodedSize (uint) {
+  if (uint < uintBoundaries[0]) {
+    return 1
+  }
+  if (uint < uintBoundaries[1]) {
+    return 2
+  }
+  if (uint < uintBoundaries[2]) {
+    return 3
+  }
+  if (uint < uintBoundaries[3]) {
+    return 5
+  }
+  return 9
+}
+
+/**
+ * @param {Token} tok1
+ * @param {Token} tok2
+ * @returns {number}
+ */
+encodeUint.compareTokens = function compareTokens (tok1, tok2) {
+  return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : /* c8 ignore next */ 0
+}

package/src/cborg/utils/1negint.js

@@ -0,0 +1,111 @@
+/* eslint-env es2020 */
+
+import { Token, Type } from './token.js'
+import * as uint from './0uint.js'
+
+/**
+ * @typedef {import('./bl.js').Bl} Bl
+ * @typedef {import('../interface.js').DecodeOptions} DecodeOptions
+ */
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeNegint8 (data, pos, _minor, options) {
+  return new Token(Type.negint, -1 - uint.readUint8(data, pos + 1, options), 2)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeNegint16 (data, pos, _minor, options) {
+  return new Token(Type.negint, -1 - uint.readUint16(data, pos + 1, options), 3)
+}
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeNegint32 (data, pos, _minor, options) {
+  return new Token(Type.negint, -1 - uint.readUint32(data, pos + 1, options), 5)
+}
+
+const neg1b = BigInt(-1)
+const pos1b = BigInt(1)
+
+/**
+ * @param {Uint8Array} data
+ * @param {number} pos
+ * @param {number} _minor
+ * @param {DecodeOptions} options
+ * @returns {Token}
+ */
+export function decodeNegint64 (data, pos, _minor, options) {
+  const int = uint.readUint64(data, pos + 1, options)
+  if (typeof int !== 'bigint') {
+    const value = -1 - int
+    if (value >= Number.MIN_SAFE_INTEGER) {
+      return new Token(Type.negint, value, 9)
+    }
+  }
+  if (options.allowBigInt !== true) {
+    throw new Error(`${options.decodeErrPrefix} integers outside of the safe integer range are not supported`)
+  }
+  return new Token(Type.negint, neg1b - BigInt(int), 9)
+}
+
+/**
+ * @param {Bl} buf
+ * @param {Token} token
+ * @param {import('../interface.js').EncodeOptions} options
+ */
+export function encodeNegint (buf, token, { encodeErrPrefix }) {
+  const negint = token.value
+  const unsigned = (typeof negint === 'bigint' ? (negint * neg1b - pos1b) : (negint * -1 - 1))
+  uint.encodeUintValue(buf, token.type.majorEncoded, unsigned, encodeErrPrefix)
+}
+
+/**
+ * @param {Token} token
+ * @returns {number}
+ */
+encodeNegint.encodedSize = function encodedSize (token) {
+  const negint = token.value
+  const unsigned = (typeof negint === 'bigint' ? (negint * neg1b - pos1b) : (negint * -1 - 1))
+  /* c8 ignore next 4 */
+  // handled by quickEncode, we shouldn't get here but it's included for completeness
+  if (unsigned < uint.uintBoundaries[0]) {
+    return 1
+  }
+  if (unsigned < uint.uintBoundaries[1]) {
+    return 2
+  }
+  if (unsigned < uint.uintBoundaries[2]) {
+    return 3
+  }
+  if (unsigned < uint.uintBoundaries[3]) {
+    return 5
+  }
+  return 9
+}
+
+/**
+ * @param {Token} tok1
+ * @param {Token} tok2
+ * @returns {number}
+ */
+encodeNegint.compareTokens = function compareTokens (tok1, tok2) {
+  // opposite of the uint comparison since we store the uint version in bytes
+  return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : /* c8 ignore next */ 0
+}