@fireproof/vendor 1.1.0 → 1.2.0

package/src/cborg/json/encode.js

@@ -0,0 +1,302 @@
+// never reference the file directly to ensure the
+// indepency of the json module
+import { encodeCustom } from "@fireproof/vendor/cborg"
+import { Type, asU8A, fromString } from "@fireproof/vendor/cborg/utils"
+
+/**
+ * @typedef {import('../interface').EncodeOptions} EncodeOptions
+ * @typedef {import('../interface').TokenTypeEncoder} TokenTypeEncoder
+ * @typedef {import('cborg/utils').Token} Token
+ * @typedef {import('cborg/utils').Bl} Bl
+ */
+
+/**
+ * @param {(buf: Bl, token: Token, opt: EncodeOptions) => void} action
+ * @returns {TokenTypeEncoder}
+ */
+function wrapCompareTokens (action) {
+  const wrapped = (/** @type {Bl} */ buf, /** @type {Token} */token, /** @type {EncodeOptions} */opt) => action(buf, token, opt)
+  /**
+   * @param {Token} tok1
+   * @param {Token} tok2
+   * @returns {number}
+   */
+  wrapped.compareTokens = function compareTokens (tok1, tok2) {
+    return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0
+  }
+  return wrapped
+}
+
+/**
+ * @returns {TokenTypeEncoder[]}
+ */
+function makeJSONEncoders () {
+  /** @type {TokenTypeEncoder[]} */
+  const encoders = []
+  /** @type {{type:Type,elements:number}[]} */
+  const inRecursive = []
+
+  /**
+   * @param {Bl} buf
+   */
+  function prefix (buf) {
+    const recurs = inRecursive[inRecursive.length - 1]
+    if (recurs) {
+      if (recurs.type.equals(Type.array)) {
+        recurs.elements++
+        if (recurs.elements !== 1) { // >first
+          buf.push([44]) // ','
+        }
+      }
+      if (recurs.type.equals(Type.map)) {
+        recurs.elements++
+        if (recurs.elements !== 1) { // >first
+          if (recurs.elements % 2 === 1) { // key
+            buf.push([44]) // ','
+          } else {
+            buf.push([58]) // ':'
+          }
+        }
+      }
+    }
+  }
+
+  encoders[Type.uint.major] = wrapCompareTokens((buf, token) => {
+    prefix(buf)
+    const is = String(token.value)
+    const isa = []
+    for (let i = 0; i < is.length; i++) {
+      isa[i] = is.charCodeAt(i)
+    }
+    buf.push(isa)
+  })
+
+  encoders[Type.negint.major] = wrapCompareTokens((buf, token, opt) => {
+    encoders[Type.uint.major](buf, token, opt)
+  })
+
+  encoders[Type.bytes.major] = wrapCompareTokens((_buf, _token, { encodeErrPrefix }) => {
+    throw new Error(`${encodeErrPrefix} unsupported type: Uint8Array`)
+  })
+
+  encoders[Type.string.major] = wrapCompareTokens((buf, token) => {
+    prefix(buf)
+    const byts = fromString(JSON.stringify(token.value))
+    buf.push(byts.length > 32 ? asU8A(byts) : byts)
+  })
+
+  encoders[Type.array.major] = wrapCompareTokens((buf, _token) => {
+    prefix(buf)
+    inRecursive.push({ type: Type.array, elements: 0 })
+    buf.push([91]) // '['
+  })
+
+  encoders[Type.map.major] = wrapCompareTokens((buf, _token) => {
+    prefix(buf)
+    inRecursive.push({ type: Type.map, elements: 0 })
+    buf.push([123]) // '{'
+  })
+
+  encoders[Type.tag.major] = wrapCompareTokens((_buf, _token) => {
+  })
+
+  encoders[Type.float.major] = wrapCompareTokens((buf, token, { encodeErrPrefix }) => {
+    if (token.type.equals(Type.break)) {
+      const recurs = inRecursive.pop()
+      if (recurs) {
+        if (recurs.type.equals(Type.array)) {
+          buf.push([93]) // ']'
+        } else if (recurs.type.equals(Type.map)) {
+          buf.push([125]) // '}'
+        /* c8 ignore next 3 */
+        } else {
+          throw new Error('Unexpected recursive type; this should not happen!')
+        }
+        return
+      }
+      /* c8 ignore next 2 */
+      throw new Error('Unexpected break; this should not happen!')
+    }
+    if (token.value === undefined) {
+      throw new Error(`${encodeErrPrefix} unsupported type: undefined`)
+    }
+
+    prefix(buf)
+    if (token.type.equals(Type.true)) {
+      buf.push([116, 114, 117, 101]) // 'true'
+      return
+    } else if (token.type.equals(Type.false)) {
+      buf.push([102, 97, 108, 115, 101]) // 'false'
+      return
+    } else if (token.type.equals(Type.null)) {
+      buf.push([110, 117, 108, 108]) // 'null'
+      return
+    }
+
+    // number
+    const is = String(token.value)
+    const isa = []
+    let dp = false
+    for (let i = 0; i < is.length; i++) {
+      isa[i] = is.charCodeAt(i)
+      if (!dp && (isa[i] === 46 || isa[i] === 101 || isa[i] === 69)) { // '[.eE]'
+        dp = true
+      }
+    }
+    if (!dp) { // need a decimal point for floats
+      isa.push(46) // '.'
+      isa.push(48) // '0'
+    }
+    buf.push(isa)
+  })
+  return encoders
+}
+
+// The below code is mostly taken and modified from https://github.com/feross/buffer
+// Licensed MIT. Copyright (c) Feross Aboukhadijeh
+// function encodeUtf8 (string, byts) {
+//   let codePoint
+//   const length = string.length
+//   let leadSurrogate = null
+
+//   for (let i = 0; i < length; ++i) {
+//     codePoint = string.charCodeAt(i)
+
+//     // is surrogate component
+//     if (codePoint > 0xd7ff && codePoint < 0xe000) {
+//       // last char was a lead
+//       if (!leadSurrogate) {
+//         // no lead yet
+//         /* c8 ignore next 9 */
+//         if (codePoint > 0xdbff) {
+//           // unexpected trail
+//           byts.push(0xef, 0xbf, 0xbd)
+//           continue
+//         } else if (i + 1 === length) {
+//           // unpaired lead
+//           byts.push(0xef, 0xbf, 0xbd)
+//           continue
+//         }
+
+//         // valid lead
+//         leadSurrogate = codePoint
+
+//         continue
+//       }
+
+//       // 2 leads in a row
+//       /* c8 ignore next 5 */
+//       if (codePoint < 0xdc00) {
+//         byts.push(0xef, 0xbf, 0xbd)
+//         leadSurrogate = codePoint
+//         continue
+//       }
+
+//       // valid surrogate pair
+//       codePoint = (leadSurrogate - 0xd800 << 10 | codePoint - 0xdc00) + 0x10000
+//     /* c8 ignore next 4 */
+//     } else if (leadSurrogate) {
+//       // valid bmp char, but last char was a lead
+//       byts.push(0xef, 0xbf, 0xbd)
+//     }
+
+//     leadSurrogate = null
+
+//     // encode utf8
+//     if (codePoint < 0x80) {
+//       // special JSON escapes
+//       switch (codePoint) {
+//         case 8: // '\b'
+//           byts.push(92, 98) // '\\b'
+//           continue
+//         case 9: // '\t'
+//           byts.push(92, 116) // '\\t'
+//           continue
+//         case 10: // '\n'
+//           byts.push(92, 110) // '\\n'
+//           continue
+//         case 12: // '\f'
+//           byts.push(92, 102) // '\\f'
+//           continue
+//         case 13: // '\r'
+//           byts.push(92, 114) // '\\r'
+//           continue
+//         case 34: // '"'
+//           byts.push(92, 34) // '\\"'
+//           continue
+//         case 92: // '\\'
+//           byts.push(92, 92) // '\\\\'
+//           continue
+//       }
+
+//       byts.push(codePoint)
+//     } else if (codePoint < 0x800) {
+//       /* c8 ignore next 1 */
+//       byts.push(
+//         codePoint >> 0x6 | 0xc0,
+//         codePoint & 0x3f | 0x80
+//       )
+//     } else if (codePoint < 0x10000) {
+//       /* c8 ignore next 1 */
+//       byts.push(
+//         codePoint >> 0xc | 0xe0,
+//         codePoint >> 0x6 & 0x3f | 0x80,
+//         codePoint & 0x3f | 0x80
+//       )
+//     /* c8 ignore next 9 */
+//     } else if (codePoint < 0x110000) {
+//       byts.push(
+//         codePoint >> 0x12 | 0xf0,
+//         codePoint >> 0xc & 0x3f | 0x80,
+//         codePoint >> 0x6 & 0x3f | 0x80,
+//         codePoint & 0x3f | 0x80
+//       )
+//     } else {
+//       /* c8 ignore next 2 */
+//       throw new Error('Invalid code point')
+//     }
+//   }
+// }
+
+const encodeErrPrefix = 'JSON encode error:'
+/**
+ * @param {(Token|Token[])[]} e1
+ * @param {(Token|Token[])[]} e2
+ * @returns {number}
+ */
+function mapSorter (e1, e2) {
+  if (Array.isArray(e1[0]) || Array.isArray(e2[0])) {
+    throw new Error(`${encodeErrPrefix} complex map keys are not supported`)
+  }
+  const keyToken1 = e1[0]
+  const keyToken2 = e2[0]
+  if (!keyToken1.type.equals(Type.string) || !keyToken2.type.equals(Type.string)) {
+    throw new Error(`${encodeErrPrefix} non-string map keys are not supported`)
+  }
+  if (keyToken1 < keyToken2) {
+    return -1
+  }
+  if (keyToken1 > keyToken2) {
+    return 1
+  }
+  /* c8 ignore next 1 */
+  throw new Error(`${encodeErrPrefix} unexpected duplicate map keys, this is not supported`)
+}
+
+const defaultEncodeOptions = {
+  addBreakTokens: true,
+  encodeErrPrefix,
+  mapSorter
+}
+
+/**
+ * @param {any} data
+ * @param {EncodeOptions} [options]
+ * @returns {Uint8Array}
+ */
+function encode (data, options) {
+  options = Object.assign({}, defaultEncodeOptions, options)
+  return encodeCustom(data, makeJSONEncoders(), options)
+}
+
+export { encode }

package/src/cborg/json/json.js

@@ -0,0 +1,4 @@
+import { encode } from './encode.js'
+import { decode, decodeFirst, Tokenizer } from './decode.js'
+
+export { encode, decode, decodeFirst, Tokenizer }

package/src/cborg/taglib.js

@@ -0,0 +1,75 @@
+// never reference the file directly to ensure the
+// indepency of the json module
+import { Token, Type } from "@fireproof/vendor/cborg/utils"
+
+/*
+A collection of some standard CBOR tags.
+
+There are no tags included by default in the cborg encoder or decoder, you have
+to include them by passing options. `typeEncoders` for encode() and `tags` for
+decode().
+
+The encoders here can be included with these options (see the tests for how this
+can be done), or as examples for writing additional tags. Additional standard
+(and reasonable) tags may be added here by pull request.
+*/
+
+/* TAG(2) Bignums https://tools.ietf.org/html/rfc8949#section-3.4.3 */
+const neg1b = BigInt(-1)
+const pos1b = BigInt(1)
+const zerob = BigInt(0)
+// const twob = BigInt(2)
+const eightb = BigInt(8)
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+export function bigIntDecoder (bytes) {
+  // TODO: assert that `bytes` is a `Uint8Array`
+  let bi = zerob
+  for (let ii = 0; ii < bytes.length; ii++) {
+    bi = (bi << eightb) + BigInt(bytes[ii])
+  }
+  return bi
+}
+
+/**
+ * @param {bigint} bi
+ * @returns {Uint8Array}
+ */
+function fromBigInt (bi) {
+  const buf = []
+  while (bi > 0) {
+    buf.unshift(Number(bi) & 0xff)
+    bi >>= eightb
+  }
+  return Uint8Array.from(buf)
+}
+
+// assuming that we're receiving a BigInt here, it should be registered for
+// type 'bigint' for this to work.
+const maxSafeBigInt = BigInt('18446744073709551615') // (twob ** BigInt(64)) - pos1b
+const minSafeBigInt = BigInt('-18446744073709551616') // neg1b * (twob ** BigInt(64))
+/**
+ * @param {bigint} obj
+ * @returns {Token[]|null}
+ */
+export function bigIntEncoder (obj) {
+  if (obj >= minSafeBigInt && obj <= maxSafeBigInt) {
+    return null // null = do it the standard way
+  }
+  return [
+    new Token(Type.tag, obj >= zerob ? 2 : 3),
+    new Token(Type.bytes, fromBigInt(obj >= zerob ? obj : obj * neg1b - pos1b))
+  ]
+}
+
+/**
+ * TAG(3) Negative Bignums https://tools.ietf.org/html/rfc8949#section-3.4.3
+ * @param {Uint8Array} bytes
+ * @returns {bigint}
+ */
+export function bigNegIntDecoder (bytes) {
+  return neg1b - bigIntDecoder(bytes)
+}