@fireproof/vendor 1.0.4 → 1.1.0-dev

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

@@ -1 +0,0 @@
-{"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

@@ -1,62 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,60 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,26 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,53 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,8 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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

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

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

@@ -1,16 +0,0 @@
-/**
- * @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

@@ -1 +0,0 @@
-{"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

@@ -1,59 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,229 +0,0 @@
-/* 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

@@ -1,111 +0,0 @@
-/* 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
-}