@fireproof/vendor 0.0.0-smoke

package/src/cborg/cborg/lib/diagnostic.js

@@ -0,0 +1,156 @@
+import { Tokeniser } from './decode.js'
+import { Type } from './token.js'
+import { toHex, fromHex } from './byte-utils.js'
+import { uintBoundaries } from './0uint.js'
+
+const utf8Encoder = new TextEncoder()
+const utf8Decoder = new TextDecoder()
+
+/**
+ * @param {Uint8Array} inp
+ * @param {number} [width]
+ */
+function * tokensToDiagnostic (inp, width = 100) {
+  const tokeniser = new Tokeniser(inp, { retainStringBytes: true, allowBigInt: true })
+  let pos = 0
+  const indent = []
+
+  /**
+   * @param {number} start
+   * @param {number} length
+   * @returns {string}
+   */
+  const slc = (start, length) => {
+    return toHex(inp.slice(pos + start, pos + start + length))
+  }
+
+  while (!tokeniser.done()) {
+    const token = tokeniser.next()
+    let margin = ''.padStart(indent.length * 2, ' ')
+    // @ts-ignore should be safe for decode
+    let vLength = token.encodedLength - 1
+    /** @type {string|number} */
+    let v = String(token.value)
+    let outp = `${margin}${slc(0, 1)}`
+    const str = token.type.equals(Type.bytes) || token.type.equals(Type.string)
+    if (token.type.equals(Type.string)) {
+      v = v.length
+      vLength -= v
+    } else if (token.type.equals(Type.bytes)) {
+      v = token.value.length
+      // @ts-ignore
+      vLength -= v
+    }
+
+    let multilen
+    switch (token.type.name) {
+      case Type.string.name:
+      case Type.bytes.name:
+      case Type.map.name:
+      case Type.array.name:
+        // for bytes and string, we want to print out the length part of the value prefix if it
+        // exists - it exists for short lengths (<24) but does for longer lengths
+        multilen = token.type.equals(Type.string) ? utf8Encoder.encode(token.value).length : token.value.length
+        if (multilen >= uintBoundaries[0]) {
+          if (multilen < uintBoundaries[1]) {
+            outp += ` ${slc(1, 1)}`
+          } else if (multilen < uintBoundaries[2]) {
+            outp += ` ${slc(1, 2)}`
+            /* c8 ignore next 5 */
+          } else if (multilen < uintBoundaries[3]) { // sus
+            outp += ` ${slc(1, 4)}`
+          } else if (multilen < uintBoundaries[4]) { // orly?
+            outp += ` ${slc(1, 8)}`
+          }
+        }
+        break
+      default:
+        // print the value if it's not compacted into the first byte
+        outp += ` ${slc(1, vLength)}`
+        break
+    }
+
+    outp = outp.padEnd(width / 2, ' ')
+    outp += `# ${margin}${token.type.name}`
+    // there should be a method to get a Type from a String
+    if (token.type.name !== v) {
+      outp += `(${v})`
+    }
+    yield outp
+
+    if (str) {
+      let asString = token.type.equals(Type.string)
+      margin += '  '
+      let repr = asString ? utf8Encoder.encode(token.value) : token.value
+      if (asString && token.byteValue !== undefined) {
+        if (repr.length !== token.byteValue.length) {
+          // bail on printing this as a string, it's probably not utf8, so treat it as bytes
+          // (you can probably blame a Go programmer for this)
+          repr = token.byteValue
+          asString = false
+        }
+      }
+      const wh = ((width / 2) - margin.length - 1) / 2
+      let snip = 0
+      while (repr.length - snip > 0) {
+        const piece = repr.slice(snip, snip + wh)
+        snip += piece.length
+        const st = asString
+          ? utf8Decoder.decode(piece)
+          : piece.reduce((/** @type {string} */ p, /** @type {number} */ c) => {
+            if (c < 0x20 || (c >= 0x7f && c < 0xa1) || c === 0xad) {
+              return `${p}\\x${c.toString(16).padStart(2, '0')}`
+            }
+            return `${p}${String.fromCharCode(c)}`
+          }, '')
+        yield `${margin}${toHex(piece)}`.padEnd(width / 2, ' ') + `# ${margin}"${st}"`
+      }
+    }
+
+    if (indent.length) {
+      indent[indent.length - 1]--
+    }
+    if (!token.type.terminal) {
+      switch (token.type.name) {
+        case Type.map.name:
+          indent.push(token.value * 2)
+          break
+        case Type.array.name:
+          indent.push(token.value)
+          break
+        // TODO: test tags .. somehow
+        /* c8 ignore next 5 */
+        case Type.tag.name:
+          indent.push(1)
+          break
+        default:
+          throw new Error(`Unknown token type '${token.type.name}'`)
+      }
+    }
+    while (indent.length && indent[indent.length - 1] <= 0) {
+      indent.pop()
+    }
+    // @ts-ignore it should be set on a decode operation
+    pos += token.encodedLength
+  }
+}
+
+/**
+ * Convert an input string formatted as CBOR diagnostic output into binary CBOR form.
+ * @param {string} input
+ * @returns {Uint8Array}
+ */
+function fromDiag (input) {
+  /* c8 ignore next 3 */
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected string input')
+  }
+  input = input.replace(/#.*?$/mg, '').replace(/[\s\r\n]+/mg, '')
+  /* c8 ignore next 3 */
+  if (/[^a-f0-9]/i.test(input)) {
+    throw new TypeError('Input string was not CBOR diagnostic format')
+  }
+  return fromHex(input)
+}
+
+export { tokensToDiagnostic, fromDiag }

package/src/cborg/cborg/lib/diagnostic_test.js

@@ -0,0 +1,117 @@
+import { tokensToDiagnostic } from './diagnostic.js'
+import { fromHex } from './byte-utils.js'
+
+const inp = `
+a7
+62
+6964
+78 40
+6469643a6578616d706c653a31324433
+4b6f6f574d4864727a6377706a626472
+5a733547477145524176636771583362
+3564707550745061396f743639796577
+65
+70726f6f66
+a4
+64
+74797065
+74
+656432353531395369676e617475726532303138
+67
+63726561746564
+74
+323032302d30352d30315430333a30303a30325a
+67
+63726561746f72
+78 8c
+6469643a6578616d706c653a31324433
+4b6f6f574d4864727a6377706a626472
+5a733547477145524176636771583362
+3564707550745061396f743639796577
+3b206578616d706c653a6b65793d6964
+3d626166797265696375627478357771
+6f336e6f73633463617a726b63746668
+776436726577657a6770776f65347377
+69726c733465626468733269
+6e
+7369676e617475726556616c7565
+78 58
+6f3972364c78676f474e38466f616565
+554136456444637631324776447a4645
+6d43676a577a76707572325953517941
+3857327230535357554b2b6e4835744d
+717a61464c756e3677775a31456f7433
+37616d4744673d3d
+67
+63726561746564
+74
+323031382d31322d30315430333a30303a30305a
+67
+75706461746564
+74
+323032302d30352d30315430333a30303a30305a
+68
+40636f6e74657874
+78 1c
+68747470733a2f2f7777772e77332e6f
+72672f6e732f6469642f7631
+69
+7075626c69634b6579
+81
+a5
+62
+6964
+78 85
+6261667972656963756274783577716f
+336e6f73633463617a726b6374666877
+6436726577657a6770776f6534737769
+726c7334656264687332693b6578616d
+706c653a6b65793d6964626166797265
+6963756274783577716f336e6f736334
+63617a726b6374666877643672657765
+7a6770776f6534737769726c73346562
+6468733269
+64
+74797065
+6e
+45644473615075626c69634b6579
+65
+6375727665
+67
+65643235353139
+67
+65787069726573
+74
+323031392d31322d30315430333a30303a30305a
+6f
+7075626c69634b6579426173653634
+78 2c
+716d7a3774704c4e4b4b4b646c376344
+375062656a4469425670374f4e706d5a
+62666d633763454b396d673d
+6e
+61757468656e7469636174696f6e
+81
+78 83
+6469643a6578616d706c653a31324433
+4b6f6f574d4864727a6377706a626472
+5a733547477145524176636771583362
+3564707550745061396f743639796577
+3b6b65792d69643d6261667972656963
+756274783577716f336e6f7363346361
+7a726b63746668776436726577657a67
+70776f6534737769726c733465626468
+733269
+`.replace(/[\n ]/g, '')
+
+// tokensToDiagnostic(fromHex('861864fb4376345785d8a0002063796570428411fb3ff199999999999a'))
+for (const line of tokensToDiagnostic(fromHex('851864fb4376345785d8a00020a661624284116166f46168f7616ef6617379012c7965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965707965706174f5fb3ff199999999999a'))) {
+  console.log(line)
+}
+for (const line of tokensToDiagnostic(fromHex(inp))) {
+  console.log(line)
+}
+
+for (const line of tokensToDiagnostic(fromHex('82410181a161318182410041ff'))) {
+  console.log(line)
+}