@fireproof/vendor 0.0.0-smoke

package/patched/cborg/types/lib/decode.d.ts

@@ -0,0 +1,41 @@
+export type Token = import("./token.js").Token;
+export type DecodeOptions = import("../interface").DecodeOptions;
+export type DecodeTokenizer = import("../interface").DecodeTokenizer;
+/**
+ * @implements {DecodeTokenizer}
+ */
+export class Tokeniser implements DecodeTokenizer {
+    /**
+     * @param {Uint8Array} data
+     * @param {DecodeOptions} options
+     */
+    constructor(data: Uint8Array, options?: DecodeOptions);
+    _pos: number;
+    data: Uint8Array<ArrayBufferLike>;
+    options: import("../interface").DecodeOptions;
+    pos(): number;
+    done(): boolean;
+    next(): import("./token.js").Token;
+}
+/**
+ * @param {DecodeTokenizer} tokeniser
+ * @param {DecodeOptions} options
+ * @returns {any|BREAK|DONE}
+ */
+export function tokensToObject(tokeniser: DecodeTokenizer, options: DecodeOptions): any | typeof BREAK | typeof DONE;
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {any}
+ */
+export function decode(data: Uint8Array, options?: DecodeOptions): any;
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {[any, Uint8Array]}
+ */
+export function decodeFirst(data: Uint8Array, options?: DecodeOptions): [any, Uint8Array];
+declare const BREAK: unique symbol;
+declare const DONE: unique symbol;
+export {};
+//# sourceMappingURL=decode.d.ts.map

package/patched/cborg/types/lib/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../lib/decode.js"],"names":[],"mappings":"oBAKa,OAAO,YAAY,EAAE,KAAK;4BAC1B,OAAO,cAAc,EAAE,aAAa;8BACpC,OAAO,cAAc,EAAE,eAAe;AAUnD;;GAEG;AACH,kCAFgB,eAAe;IAG7B;;;OAGG;IACH,kBAHW,UAAU,YACV,aAAa,EAMvB;IAHC,aAAa;IACb,kCAAgB;IAChB,8CAAsB;IAGxB,cAEC;IAED,gBAEC;IAED,mCAgBC;CACF;AA6ED;;;;GAIG;AACH,0CAJW,eAAe,WACf,aAAa,GACX,GAAG,6BAAW,CAoC1B;AAuBD;;;;GAIG;AACH,6BAJW,UAAU,YACV,aAAa,GACX,GAAG,CAQf;AAhCD;;;;GAIG;AACH,kCAJW,UAAU,YACV,aAAa,GACX,CAAC,GAAG,EAAE,UAAU,CAAC,CAgB7B;AAtID,mCAAiC;AADjC,kCAA+B"}

package/patched/cborg/types/lib/diagnostic.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {Uint8Array} inp
+ * @param {number} [width]
+ */
+export function tokensToDiagnostic(inp: Uint8Array, width?: number): Generator<string, void, unknown>;
+/**
+ * Convert an input string formatted as CBOR diagnostic output into binary CBOR form.
+ * @param {string} input
+ * @returns {Uint8Array}
+ */
+export function fromDiag(input: string): Uint8Array;
+//# sourceMappingURL=diagnostic.d.ts.map

package/patched/cborg/types/lib/diagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic.d.ts","sourceRoot":"","sources":["../../lib/diagnostic.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wCAHW,UAAU,UACV,MAAM,oCA6HhB;AAED;;;;GAIG;AACH,gCAHW,MAAM,GACJ,UAAU,CAatB"}

package/patched/cborg/types/lib/diagnostic_test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=diagnostic_test.d.ts.map

package/patched/cborg/types/lib/diagnostic_test.d.ts.map

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

package/patched/cborg/types/lib/encode.d.ts

@@ -0,0 +1,50 @@
+/** @returns {TokenTypeEncoder[]} */
+export function makeCborEncoders(): TokenTypeEncoder[];
+export type EncodeOptions = import("../interface").EncodeOptions;
+export type OptionalTypeEncoder = import("../interface").OptionalTypeEncoder;
+export type Reference = import("../interface").Reference;
+export type StrictTypeEncoder = import("../interface").StrictTypeEncoder;
+export type TokenTypeEncoder = import("../interface").TokenTypeEncoder;
+export type TokenOrNestedTokens = import("../interface").TokenOrNestedTokens;
+/**
+ * @param {any} obj
+ * @param {EncodeOptions} [options]
+ * @param {Reference} [refStack]
+ * @returns {TokenOrNestedTokens}
+ */
+export function objectToTokens(obj: any, options?: EncodeOptions, refStack?: Reference): TokenOrNestedTokens;
+/**
+ * @param {any} data
+ * @param {EncodeOptions} [options]
+ * @returns {Uint8Array}
+ */
+export function encode(data: any, options?: EncodeOptions): Uint8Array;
+/**
+ * @param {any} data
+ * @param {TokenTypeEncoder[]} encoders
+ * @param {EncodeOptions} options
+ * @returns {Uint8Array}
+ */
+export function encodeCustom(data: any, encoders: TokenTypeEncoder[], options: EncodeOptions): Uint8Array;
+/** @implements {Reference} */
+export class Ref implements Reference {
+    /**
+     * @param {Reference|undefined} stack
+     * @param {object|any[]} obj
+     * @returns {Reference}
+     */
+    static createCheck(stack: Reference | undefined, obj: object | any[]): Reference;
+    /**
+     * @param {object|any[]} obj
+     * @param {Reference|undefined} parent
+     */
+    constructor(obj: object | any[], parent: Reference | undefined);
+    obj: object | any[];
+    parent: import("../interface").Reference | undefined;
+    /**
+     * @param {object|any[]} obj
+     * @returns {boolean}
+     */
+    includes(obj: object | any[]): boolean;
+}
+//# sourceMappingURL=encode.d.ts.map

package/patched/cborg/types/lib/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../lib/encode.js"],"names":[],"mappings":"AAgCA,oCAAoC;AACpC,oCADc,gBAAgB,EAAE,CAY/B;4BA3BY,OAAO,cAAc,EAAE,aAAa;kCACpC,OAAO,cAAc,EAAE,mBAAmB;wBAC1C,OAAO,cAAc,EAAE,SAAS;gCAChC,OAAO,cAAc,EAAE,iBAAiB;+BACxC,OAAO,cAAc,EAAE,gBAAgB;kCACvC,OAAO,cAAc,EAAE,mBAAmB;AAgQvD;;;;;GAKG;AACH,oCALW,GAAG,YACH,aAAa,aACb,SAAS,GACP,mBAAmB,CAgB/B;AA2JD;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAKtB;AAvCD;;;;;GAKG;AACH,mCALW,GAAG,YACH,gBAAgB,EAAE,WAClB,aAAa,GACX,UAAU,CAyBtB;AAjZD,8BAA8B;AAC9B,4BADiB,SAAS;IA0BxB;;;;OAIG;IACH,0BAJW,SAAS,GAAC,SAAS,OACnB,MAAM,GAAC,GAAG,EAAE,GACV,SAAS,CAOrB;IAlCD;;;OAGG;IACH,iBAHW,MAAM,GAAC,GAAG,EAAE,UACZ,SAAS,GAAC,SAAS,EAK7B;IAFC,oBAAc;IACd,qDAAoB;IAGtB;;;OAGG;IACH,cAHW,MAAM,GAAC,GAAG,EAAE,GACV,OAAO,CAWnB;CAaF"}

package/patched/cborg/types/lib/is.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {any} value
+ * @returns {string}
+ */
+export function is(value: any): string;
+//# sourceMappingURL=is.d.ts.map

package/patched/cborg/types/lib/is.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../lib/is.js"],"names":[],"mappings":"AAiDA;;;GAGG;AACH,0BAHW,GAAG,GACD,MAAM,CAiClB"}

package/patched/cborg/types/lib/json/decode.d.ts

@@ -0,0 +1,67 @@
+export type DecodeOptions = import("../../interface").DecodeOptions;
+export type DecodeTokenizer = import("../../interface").DecodeTokenizer;
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {any}
+ */
+export function decode(data: Uint8Array, options?: DecodeOptions): any;
+/**
+ * @param {Uint8Array} data
+ * @param {DecodeOptions} [options]
+ * @returns {[any, Uint8Array]}
+ */
+export function decodeFirst(data: Uint8Array, options?: DecodeOptions): [any, Uint8Array];
+/**
+ * @typedef {import('../../interface').DecodeOptions} DecodeOptions
+ * @typedef {import('../../interface').DecodeTokenizer} DecodeTokenizer
+ */
+/**
+ * @implements {DecodeTokenizer}
+ */
+export class Tokenizer implements DecodeTokenizer {
+    /**
+     * @param {Uint8Array} data
+     * @param {DecodeOptions} options
+     */
+    constructor(data: Uint8Array, options?: DecodeOptions);
+    _pos: number;
+    data: Uint8Array<ArrayBufferLike>;
+    options: import("../../interface").DecodeOptions;
+    /** @type {string[]} */
+    modeStack: string[];
+    lastToken: string;
+    pos(): number;
+    /**
+     * @returns {boolean}
+     */
+    done(): boolean;
+    /**
+     * @returns {number}
+     */
+    ch(): number;
+    /**
+     * @returns {string}
+     */
+    currentMode(): string;
+    skipWhitespace(): void;
+    /**
+     * @param {number[]} str
+     */
+    expect(str: number[]): void;
+    parseNumber(): Token;
+    /**
+     * @returns {Token}
+     */
+    parseString(): Token;
+    /**
+     * @returns {Token}
+     */
+    parseValue(): Token;
+    /**
+     * @returns {Token}
+     */
+    next(): Token;
+}
+import { Token } from 'cborg';
+//# sourceMappingURL=decode.d.ts.map

package/patched/cborg/types/lib/json/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../lib/json/decode.js"],"names":[],"mappings":"4BAQa,OAAO,iBAAiB,EAAE,aAAa;8BACvC,OAAO,iBAAiB,EAAE,eAAe;AAgbtD;;;;GAIG;AACH,6BAJW,UAAU,YACV,aAAa,GACX,GAAG,CAKf;AAED;;;;GAIG;AACH,kCAJW,UAAU,YACV,aAAa,GACX,CAAC,GAAG,EAAE,UAAU,CAAC,CAK7B;AApcD;;;GAGG;AAEH;;GAEG;AACH,kCAFgB,eAAe;IAG7B;;;OAGG;IACH,kBAHW,UAAU,YACV,aAAa,EASvB;IANC,aAAa;IACb,kCAAgB;IAChB,iDAAsB;IACtB,uBAAuB;IACvB,WADW,MAAM,EAAE,CACO;IAC1B,kBAAmB;IAGrB,cAEC;IAED;;OAEG;IACH,QAFa,OAAO,CAInB;IAED;;OAEG;IACH,MAFa,MAAM,CAIlB;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED,uBAMC;IAED;;OAEG;IACH,YAFW,MAAM,EAAE,QAWlB;IAED,qBA+DC;IAED;;OAEG;IACH,eAFa,KAAK,CAkLjB;IAED;;OAEG;IACH,cAFa,KAAK,CAuCjB;IAED;;OAEG;IACH,QAFa,KAAK,CAyEjB;CACF;sBApb2B,OAAO"}

package/patched/cborg/types/lib/json/encode.d.ts

@@ -0,0 +1,11 @@
+export type EncodeOptions = import("../../interface").EncodeOptions;
+export type TokenTypeEncoder = import("../../interface").TokenTypeEncoder;
+export type Token = import("../token").Token;
+export type Bl = import("../bl").Bl;
+/**
+ * @param {any} data
+ * @param {EncodeOptions} [options]
+ * @returns {Uint8Array}
+ */
+export function encode(data: any, options?: EncodeOptions): Uint8Array;
+//# sourceMappingURL=encode.d.ts.map

package/patched/cborg/types/lib/json/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../../lib/json/encode.js"],"names":[],"mappings":"4BAQa,OAAO,iBAAiB,EAAE,aAAa;+BACvC,OAAO,iBAAiB,EAAE,gBAAgB;oBAC1C,OAAO,UAAU,EAAE,KAAK;iBACxB,OAAO,OAAO,EAAE,EAAE;AAqR/B;;;;GAIG;AACH,6BAJW,GAAG,YACH,aAAa,GACX,UAAU,CAKtB"}

package/patched/cborg/types/lib/json/forward-cborg.d.ts

@@ -0,0 +1,6 @@
+export const encode: typeof json.encode;
+export const decode: typeof json.decode;
+export const decodeFirst: typeof json.decodeFirst;
+export const Tokenizer: typeof json.Tokenizer;
+import { json } from 'cborg';
+//# sourceMappingURL=forward-cborg.d.ts.map

package/patched/cborg/types/lib/json/forward-cborg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward-cborg.d.ts","sourceRoot":"","sources":["../../../lib/json/forward-cborg.js"],"names":[],"mappings":";;;;qBAAqB,OAAO"}

package/patched/cborg/types/lib/json/json.d.ts

@@ -0,0 +1,6 @@
+import { encode } from './encode.js';
+import { decode } from './decode.js';
+import { decodeFirst } from './decode.js';
+import { Tokenizer } from './decode.js';
+export { encode, decode, decodeFirst, Tokenizer };
+//# sourceMappingURL=json.d.ts.map

package/patched/cborg/types/lib/json/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../lib/json/json.js"],"names":[],"mappings":"uBAAuB,aAAa;uBACW,aAAa;4BAAb,aAAa;0BAAb,aAAa"}

package/patched/cborg/types/lib/jump.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {Token} token
+ * @returns {Uint8Array|undefined}
+ */
+export function quickEncodeToken(token: Token): Uint8Array | undefined;
+/** @type {((data:Uint8Array, pos:number, minor:number, options?:DecodeOptions) => any)[]} */
+export const jump: ((data: Uint8Array, pos: number, minor: number, options?: DecodeOptions) => any)[];
+/** @type {Token[]} */
+export const quick: Token[];
+export type DecodeOptions = import("../interface").DecodeOptions;
+import { Token } from './token.js';
+//# sourceMappingURL=jump.d.ts.map

package/patched/cborg/types/lib/jump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jump.d.ts","sourceRoot":"","sources":["../../lib/jump.js"],"names":[],"mappings":"AAkKA;;;GAGG;AACH,wCAHW,KAAK,GACH,UAAU,GAAC,SAAS,CA4ChC;AA/KD,6FAA6F;AAC7F,mBADW,CAAC,CAAC,IAAI,EAAC,UAAU,EAAE,GAAG,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,EAAE,OAAO,CAAC,EAAC,aAAa,KAAK,GAAG,CAAC,EAAE,CACnE;AAuGtB,sBAAsB;AACtB,oBADW,KAAK,EAAE,CACK;4BA7HV,OAAO,cAAc,EAAE,aAAa;sBAbrB,YAAY"}

package/patched/cborg/types/lib/length.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Calculate the byte length of the given data when encoded as CBOR with the
+ * options provided.
+ * This calculation will be accurate if the same options are used as when
+ * performing a normal encode. Some encode options can change the encoding
+ * output length.
+ *
+ * @param {any} data
+ * @param {EncodeOptions} [options]
+ * @returns {number}
+ */
+export function encodedLength(data: any, options?: EncodeOptions): number;
+/**
+ * Calculate the byte length of the data as represented by the given tokens when
+ * encoded as CBOR with the options provided.
+ * This function is for advanced users and would not normally be called
+ * directly. See `encodedLength()` for appropriate use.
+ *
+ * @param {TokenOrNestedTokens} tokens
+ * @param {TokenTypeEncoder[]} [encoders]
+ * @param {EncodeOptions} [options]
+ */
+export function tokensToLength(tokens: TokenOrNestedTokens, encoders?: TokenTypeEncoder[], options?: EncodeOptions): number;
+export type EncodeOptions = import("../interface").EncodeOptions;
+export type TokenTypeEncoder = import("../interface").TokenTypeEncoder;
+export type TokenOrNestedTokens = import("../interface").TokenOrNestedTokens;
+//# sourceMappingURL=length.d.ts.map

package/patched/cborg/types/lib/length.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"length.d.ts","sourceRoot":"","sources":["../../lib/length.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;GAUG;AACH,oCAJW,GAAG,YACH,aAAa,GACX,MAAM,CAOlB;AAED;;;;;;;;;GASG;AACH,uCAJW,mBAAmB,aACnB,gBAAgB,EAAE,YAClB,aAAa,UAiBvB;4BAxDY,OAAO,cAAc,EAAE,aAAa;+BACpC,OAAO,cAAc,EAAE,gBAAgB;kCACvC,OAAO,cAAc,EAAE,mBAAmB"}

package/patched/cborg/types/lib/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/patched/cborg/types/lib/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../lib/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/patched/cborg/types/taglib.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+export function bigIntDecoder(bytes: Uint8Array): bigint;
+/**
+ * @param {bigint} obj
+ * @returns {Token[]|null}
+ */
+export function bigIntEncoder(obj: bigint): Token[] | null;
+/**
+ * TAG(3) Negative Bignums https://tools.ietf.org/html/rfc8949#section-3.4.3
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+export function bigNegIntDecoder(bytes: Uint8Array): bigint;
+import { Token } from './cborg.js';
+//# sourceMappingURL=taglib.d.ts.map

package/patched/cborg/types/taglib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taglib.d.ts","sourceRoot":"","sources":["../taglib.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,qCAHW,UAAU,GACR,MAAM,CASlB;AAmBD;;;GAGG;AACH,mCAHW,MAAM,GACJ,KAAK,EAAE,GAAC,IAAI,CAUxB;AAED;;;;GAIG;AACH,wCAHW,UAAU,GACR,MAAM,CAIlB;sBAxE2B,YAAY"}

package/patched/cborg/types/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../cborg.js","../example.js","../taglib.js","../lib/0uint.js","../lib/1negint.js","../lib/2bytes.js","../lib/3string.js","../lib/4array.js","../lib/5map.js","../lib/6tag.js","../lib/7float.js","../lib/bin.js","../lib/bl.js","../lib/byte-utils.js","../lib/common.js","../lib/decode.js","../lib/diagnostic.js","../lib/diagnostic_test.js","../lib/encode.js","../lib/is.js","../lib/jump.js","../lib/length.js","../lib/token.js","../lib/json/decode.js","../lib/json/encode.js","../lib/json/json.js"],"version":"5.7.2"}

package/src/@ipld/car/car/LICENSE

@@ -0,0 +1,4 @@
+This project is dual licensed under MIT and Apache-2.0.
+
+MIT: https://www.opensource.org/licenses/mit
+Apache-2.0: https://www.apache.org/licenses/license-2.0