@fireproof/vendor 0.0.0-smoke → 1.0.0

package/src/cborg/cborg/bench/json.js

@@ -1,124 +0,0 @@
-// can be run in a browser with `polendina --runner=bare-sync --timeout 6000 --cleanup bench.js`
-// with additional dependencies for cborg installed here
-
-import assert from 'assert'
-import { garbage } from 'ipld-garbage'
-import { decode, encode } from '../lib/json/json.js'
-
-let writebuf = ''
-const write = process.stdout
-  ? process.stdout.write.bind(process.stdout)
-  : (str) => {
-      writebuf += str
-      if (str.endsWith('\n')) {
-        console.log(writebuf.replace(/\n$/, ''))
-        writebuf = ''
-      }
-    }
-
-const textEncoder = new TextEncoder()
-const textDecoder = new TextDecoder()
-
-function jencode (obj) {
-  return textEncoder.encode(JSON.stringify(obj))
-}
-
-function jdecode (buf) {
-  return JSON.parse(textDecoder.decode(buf))
-}
-
-function runWith (description, count, targetTime, size, options) {
-  const fixtures = []
-
-  console.log(`${description} @ ${count.toLocaleString()}`)
-  for (let i = 0; i < count; i++) {
-    const obj = garbage(size, options)
-    const cbyts = encode(obj)
-    /*
-    const jbyts = jencode(obj)
-    if (Buffer.compare(Buffer.from(cbyts), jbyts) !== 0) {
-      console.log(`mismatch for obj: ${JSON.stringify(obj)}`)
-      console.log('\tc> ', Buffer.from(cbyts).toString('utf8'))
-      console.log('\tj> ', Buffer.from(jbyts).toString('utf8'))
-    }
-    */
-    if (cbyts.length <= size * 2) {
-      fixtures.push([obj, cbyts])
-    }
-  }
-  const avgSize = Math.round(fixtures.reduce((p, c) => p + c[1].length, 0) / fixtures.length)
-
-  const enc = (encoder) => {
-    for (const [obj, byts] of fixtures) {
-      const ebyts = encoder(obj)
-      if (byts.length !== ebyts.length) {
-        throw new Error('bork')
-      }
-    }
-    return fixtures.length
-  }
-
-  const bench = (bfn) => {
-    const start = Date.now()
-    let opcount = 0
-    do {
-      opcount += bfn()
-    } while (Date.now() - start < targetTime)
-    const ops = Math.round(opcount / ((Date.now() - start) / 1000))
-    return ops
-  }
-
-  const dec = (decoder) => {
-    for (const [obj, byts] of fixtures) {
-      let cobj
-      try {
-        cobj = decoder(byts)
-      } catch (e) {
-        console.log('Failed to decode:', Buffer.from(byts).toString('utf8'))
-        throw e
-      }
-      if (obj != null && typeof obj === 'object') {
-        assert.deepStrictEqual(Object.keys(cobj).length, Object.keys(obj).length)
-      } else {
-        assert.deepStrictEqual(obj, cobj)
-      }
-    }
-    return fixtures.length
-  }
-
-  const cmp = (desc, cbfn, bofn) => {
-    write(`\t${desc} (avg ${avgSize.toLocaleString()} b):`)
-    const cborgOps = bench(cbfn)
-    write(` cborg @ ${cborgOps.toLocaleString()} op/s`)
-    const jOps = bench(bofn)
-    write(` / JSON @ ${jOps.toLocaleString()} op/s`)
-    const percent = Math.round((cborgOps / jOps) * 1000) / 10
-    write(` = ${(percent).toLocaleString()} %\n`)
-    return percent
-  }
-
-  return [
-    cmp('encode', () => enc(encode), () => enc(jencode)),
-    cmp('decode', () => dec(decode), () => dec(jdecode))
-  ]
-}
-
-const targetTime = 1000
-const accum = []
-accum.push(runWith('rnd-100', 1000, targetTime, 100, { weights: { CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-nomap-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, map: 0 } }))
-accum.push(runWith('rnd-nolist-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, list: 0 } }))
-accum.push(runWith('rnd-nofloat-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, float: 0 } }))
-accum.push(runWith('rnd-nomaj7-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, float: 0, null: 0, boolean: 0 } }))
-accum.push(runWith('rnd-nostr-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, string: 0 } }))
-accum.push(runWith('rnd-nostrbyts-300', 1000, targetTime, 300, { weights: { CID: 0, bytes: 0, string: 0 } }))
-accum.push(runWith('rnd-1000', 1000, targetTime, 1000, { weights: { CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-2000', 1000, targetTime, 2000, { weights: { CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-fil-100', 1000, targetTime, 100, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-fil-300', 1000, targetTime, 300, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-fil-500', 1000, targetTime, 500, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-fil-1000', 1000, targetTime, 1000, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
-accum.push(runWith('rnd-fil-2000', 1000, targetTime, 2000, { weights: { float: 0, map: 0, CID: 0, bytes: 0 } }))
-console.log(`Avg encode: ${Math.round(accum.reduce((p, c) => p + c[0], 0) / accum.length).toLocaleString()} %`)
-console.log(`Avg decode: ${Math.round(accum.reduce((p, c) => p + c[1], 0) / accum.length).toLocaleString()} %`)

package/src/cborg/cborg/bench/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "cborg-bench",
-  "type": "module",
-  "dependencies": {
-    "borc": "^2.1.2",
-    "ipld-garbage": "^3.0.3"
-  }
-}

package/src/cborg/cborg/cborg.js

@@ -1,31 +0,0 @@
-import { encode } from './lib/encode.js'
-import { decode, decodeFirst, Tokeniser, tokensToObject } from './lib/decode.js'
-import { Token, Type } from './lib/token.js'
-
-// is this needed for the json module and other independ encoders
-export { encodeCustom } from './lib/encode.js'
-export { encodeErrPrefix, decodeErrPrefix } from './lib/common.js'
-export { asU8A, fromString, decodeCodePointsArray } from './lib/byte-utils.js'
-
-/**
- * Export the types that were present in the original manual cborg.d.ts
- * @typedef {import('./interface').TagDecoder} TagDecoder
- * There was originally just `TypeEncoder` so don't break types by renaming or not exporting
- * @typedef {import('./interface').OptionalTypeEncoder} TypeEncoder
- * @typedef {import('./interface').DecodeOptions} DecodeOptions
- * @typedef {import('./interface').EncodeOptions} EncodeOptions
- */
-
-export {
-  // this is needed to prevent the bundleing trouble which happens
-  // due to the fact that token.js is used in lib/json and so in
-  // cborg/json which ends up on bundling to have two copies of token.js
-  // which will fail stmts like token.type === Type.array
-  decode,
-  decodeFirst,
-  Tokeniser as Tokenizer,
-  tokensToObject,
-  encode,
-  Token,
-  Type
-}

package/src/cborg/cborg/example-bytestrings.js

@@ -1,180 +0,0 @@
-/*
-RFC 8746 defines a set of tags to use for typed arrays. Out of the box, cborg doesn't care about
-tags and just squashes all concerns around byte arrays to Uint8Array with major type 2. This is
-fine for most use cases, but it is lossy, you can't round-trip and retain your original type.
-
-This example shows how to use cborg to round-trip a typed array with tags.
-
-https://www.rfc-editor.org/rfc/rfc8746.html
-*/
-
-import { encode, decode, Token, Tokenizer, Type } from 'cborg.js'
-
-const tagUint8Array = 64
-const tagUint64Array = 71
-// etc... see https://www.rfc-editor.org/rfc/rfc8746.html#name-iana-considerations
-
-/* ENCODERS */
-
-/**
- * @param {any} obj
- * @returns {[Token]}
- */
-function uint8ArrayEncoder (obj) {
-  if (!(obj instanceof Uint8Array)) {
-    throw new Error('expected Uint8Array')
-  }
-  return [
-    new Token(Type.tag, tagUint8Array),
-    new Token(Type.bytes, obj)
-  ]
-}
-
-/**
- * @param {any} obj
- * @returns {[Token]}
- */
-function uint64ArrayEncoder (obj) {
-  if (!(obj instanceof BigUint64Array)) {
-    throw new Error('expected BigUint64Array')
-  }
-  return [
-    new Token(Type.tag, tagUint64Array),
-    // BigUint64Array to a Uint8Array, but we have to pay attention to the possibility of it being
-    // a view of a larger ArrayBuffer.
-    new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength))
-  ]
-}
-
-// etc...
-
-const typeEncoders = {
-  Uint8Array: uint8ArrayEncoder,
-  BigUint64Array: uint64ArrayEncoder
-}
-
-/* DECODERS */
-
-/**
- * @param {ArrayBuffer} bytes
- * @returns {any}
- */
-function uint8ArrayDecoder (bytes) {
-  if (!(bytes instanceof ArrayBuffer)) {
-    throw new Error('expected ArrayBuffer')
-  }
-  return new Uint8Array(bytes)
-}
-
-/**
- * @param {ArrayBuffer} bytes
- * @returns {any}
- */
-function uint64ArrayDecoder (bytes) {
-  if (!(bytes instanceof ArrayBuffer)) {
-    throw new Error('expected ArrayBuffer')
-  }
-  return new BigUint64Array(bytes)
-}
-
-// etc...
-
-const tags = []
-tags[tagUint8Array] = uint8ArrayDecoder
-tags[tagUint64Array] = uint64ArrayDecoder
-
-/* TOKENIZER */
-
-// We have to deal with the fact that cborg talks in Uint8Arrays but we now want it to treat major 2
-// as ArrayBuffers, so we have to transform the token stream to replace the Uint8Array with an
-// ArrayBuffer.
-
-class ArrayBufferTransformingTokeniser extends Tokenizer {
-  next () {
-    const nextToken = super.next()
-    if (nextToken.type.equals(Type.bytes)) {
-      // Transform the (assumed) Uint8Array value to an ArrayBuffer of the same bytes, note though
-      // that all tags we care about are going to be <tag><bytes>, so we're also transforming those
-      // into ArrayBuffers, so our tag decoders need to also assume they are getting ArrayBuffers
-      // now. An alternative would be to watch the token stream for <tag> and not transform the next
-      // token if it's <bytes>, but that's a bit more complicated for demo purposes.
-      nextToken.value = nextToken.value.buffer
-    }
-    return nextToken
-  }
-}
-
-// Optional: a new decode() wrapper, mainly so we don't have to deal with the complications of\
-// instantiating a Tokenizer which needs both data and the options.
-function byteStringDecoder (data, options) {
-  options = Object.assign({}, options, {
-    tags,
-    tokenizer: new ArrayBufferTransformingTokeniser(data, options)
-  })
-  return decode(data, options)
-}
-
-/* ROUND-TRIP */
-
-const original = {
-  u8: new Uint8Array([1, 2, 3, 4, 5]),
-  u64: new BigUint64Array([10000000000000000n, 20000000000000000n, 30000000000000000n, 40000000000000000n, 50000000000000000n]),
-  ab: new Uint8Array([6, 7, 8, 9, 10]).buffer
-}
-
-const encoded = encode(original, { typeEncoders })
-
-const decoded = byteStringDecoder(encoded)
-
-console.log('Original:', original)
-console.log('Encoded:', Buffer.from(encoded).toString('hex')) // excuse the Buffer, sorry browser peeps
-console.log('Decoded:', decoded)
-
-/* Output:
-
-Original: {
-  u8: Uint8Array(5) [ 1, 2, 3, 4, 5 ],
-  u64: BigUint64Array(5) [
-    10000000000000000n,
-    20000000000000000n,
-    30000000000000000n,
-    40000000000000000n,
-    50000000000000000n
-  ],
-  ab: ArrayBuffer { [Uint8Contents]: <06 07 08 09 0a>, byteLength: 5 }
-}
-Encoded: a362616245060708090a627538d84045010203040563753634d84758280000c16ff2862300000082dfe40d47000000434fd7946a00000004bfc91b8e000000c52ebca2b100
-Decoded: {
-  ab: ArrayBuffer { [Uint8Contents]: <06 07 08 09 0a>, byteLength: 5 },
-  u8: Uint8Array(5) [ 1, 2, 3, 4, 5 ],
-  u64: BigUint64Array(5) [
-    10000000000000000n,
-    20000000000000000n,
-    30000000000000000n,
-    40000000000000000n,
-    50000000000000000n
-  ]
-}
-
-*/
-
-/* Diagnostic:
-
-$ cborg hex2diag a362616245060708090a627538d84045010203040563753634d84758280000c16ff2862300000082dfe40d47000000434fd7946a00000004bfc91b8e000000c52ebca2b100
-a3                                                # map(3)
-  62                                              #   string(2)
-    6162                                          #     "ab"
-  45                                              #   bytes(5)
-    060708090a                                    #     "\x06\x07\x08\x09\x0a"
-  62                                              #   string(2)
-    7538                                          #     "u8"
-  d8 40                                           #   tag(64)
-    45                                            #     bytes(5)
-      0102030405                                  #       "\x01\x02\x03\x04\x05"
-  63                                              #   string(3)
-    753634                                        #     "u64"
-  d8 47                                           #   tag(71)
-    58 28                                         #     bytes(40)
-      0000c16ff2862300000082dfe40d47000000434fd7  #       "\x00\x00Áoò\x86#\x00\x00\x00\x82ßä\x0dG\x00\x00\x00CO×"
-      946a00000004bfc91b8e000000c52ebca2b100      #       "\x94j\x00\x00\x00\x04¿É\x1b\x8e\x00\x00\x00Å.¼¢±\x00
-*/

package/src/cborg/cborg/interface.ts

@@ -1,56 +0,0 @@
-import { Token } from './lib/token'
-import { Bl } from './lib/bl'
-
-export type TokenOrNestedTokens = Token | Token[] | TokenOrNestedTokens[]
-
-export interface Reference {
-  parent: Reference | undefined
-  obj: object | any[]
-  includes(obj: object | any[]): boolean
-}
-
-export type OptionalTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens | null
-
-export type StrictTypeEncoder = (data: any, typ: string, options: EncodeOptions, refStack?: Reference) => TokenOrNestedTokens
-
-export type TokenTypeEncoder = {
-  (buf: Bl, token: Token, options?: EncodeOptions): void;
-  compareTokens(t1: Token, t2: Token): number;
-  // TODO: make this non-optional as a breaking change and remove the throw in length.js
-  encodedSize?(token: Token, options?: EncodeOptions): number;
-}
-
-export type MapSorter = (e1: (Token | Token[])[], e2: (Token | Token[])[]) => number
-
-export type QuickEncodeToken = (token: Token) => Uint8Array | undefined
-
-export interface DecodeTokenizer {
-  done(): boolean,
-  next(): Token,
-  pos(): number,
-}
-
-export type TagDecoder = (inner: any) => any
-
-export interface DecodeOptions {
-  allowIndefinite?: boolean
-  allowUndefined?: boolean
-  coerceUndefinedToNull?: boolean
-  allowInfinity?: boolean
-  allowNaN?: boolean
-  allowBigInt?: boolean
-  strict?: boolean
-  useMaps?: boolean
-  rejectDuplicateMapKeys?: boolean
-  retainStringBytes?: boolean
-  tags?: TagDecoder[],
-  tokenizer?: DecodeTokenizer
-}
-
-export interface EncodeOptions {
-  float64?: boolean,
-  addBreakTokens?: boolean,
-  mapSorter?: MapSorter,
-  quickEncodeToken?: QuickEncodeToken,
-  typeEncoders?: { [typeName: string]: OptionalTypeEncoder }
-}

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

@@ -1,111 +0,0 @@
-/* eslint-env es2020 */
-
-import { Token, Type } from './token.js'
-import * as uint from './0uint.js'
-import { decodeErrPrefix } from './common.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').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(`${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
- */
-export function encodeNegint (buf, token) {
-  const negint = token.value
-  const unsigned = (typeof negint === 'bigint' ? (negint * neg1b - pos1b) : (negint * -1 - 1))
-  uint.encodeUintValue(buf, token.type.majorEncoded, unsigned)
-}
-
-/**
- * @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
-}

package/src/cborg/cborg/lib/2bytes.js

@@ -1,133 +0,0 @@
-import { Token, Type } from './token.js'
-import { assertEnoughData, decodeErrPrefix } from './common.js'
-import * as uint from './0uint.js'
-import { compare, fromString, slice } from './byte-utils.js'
-
-/**
- * @typedef {import('./bl.js').Bl} Bl
- * @typedef {import('../interface').DecodeOptions} DecodeOptions
- */
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} prefix
- * @param {number} length
- * @returns {Token}
- */
-function toToken (data, pos, prefix, length) {
-  assertEnoughData(data, pos, prefix + length)
-  const buf = slice(data, pos + prefix, pos + prefix + length)
-  return new Token(Type.bytes, buf, prefix + length)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} minor
- * @param {DecodeOptions} _options
- * @returns {Token}
- */
-export function decodeBytesCompact (data, pos, minor, _options) {
-  return toToken(data, pos, 1, minor)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes8 (data, pos, _minor, options) {
-  return toToken(data, pos, 2, uint.readUint8(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes16 (data, pos, _minor, options) {
-  return toToken(data, pos, 3, uint.readUint16(data, pos + 1, options))
-}
-
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes32 (data, pos, _minor, options) {
-  return toToken(data, pos, 5, uint.readUint32(data, pos + 1, options))
-}
-
-// TODO: maybe we shouldn't support this ..
-/**
- * @param {Uint8Array} data
- * @param {number} pos
- * @param {number} _minor
- * @param {DecodeOptions} options
- * @returns {Token}
- */
-export function decodeBytes64 (data, pos, _minor, options) {
-  const l = uint.readUint64(data, pos + 1, options)
-  if (typeof l === 'bigint') {
-    throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`)
-  }
-  return toToken(data, pos, 9, l)
-}
-
-/**
- * `encodedBytes` allows for caching when we do a byte version of a string
- * for key sorting purposes
- * @param {Token} token
- * @returns {Uint8Array}
- */
-function tokenBytes (token) {
-  if (token.encodedBytes === undefined) {
-    token.encodedBytes = token.type.equals(Type.string) ? fromString(token.value) : token.value
-  }
-  // @ts-ignore c'mon
-  return token.encodedBytes
-}
-
-/**
- * @param {Bl} buf
- * @param {Token} token
- */
-export function encodeBytes (buf, token) {
-  const bytes = tokenBytes(token)
-  uint.encodeUintValue(buf, token.type.majorEncoded, bytes.length)
-  buf.push(bytes)
-}
-
-/**
- * @param {Token} token
- * @returns {number}
- */
-encodeBytes.encodedSize = function encodedSize (token) {
-  const bytes = tokenBytes(token)
-  return uint.encodeUintValue.encodedSize(bytes.length) + bytes.length
-}
-
-/**
- * @param {Token} tok1
- * @param {Token} tok2
- * @returns {number}
- */
-encodeBytes.compareTokens = function compareTokens (tok1, tok2) {
-  return compareBytes(tokenBytes(tok1), tokenBytes(tok2))
-}
-
-/**
- * @param {Uint8Array} b1
- * @param {Uint8Array} b2
- * @returns {number}
- */
-export function compareBytes (b1, b2) {
-  return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2)
-}