cborg 1.6.1 → 1.8.0

package/lib/bin.js

@@ -2,7 +2,7 @@
 
 import process from 'process'
 import { decode, encode } from '../cborg.js'
-import { tokensToDiagnostic } from './diagnostic.js'
+import { tokensToDiagnostic, fromDiag } from './diagnostic.js'
 import { fromHex as _fromHex, toHex } from './byte-utils.js'
 
 /**
@@ -11,15 +11,18 @@ import { fromHex as _fromHex, toHex } from './byte-utils.js'
 function usage (code) {
   console.error('Usage: cborg <command> <args>')
   console.error('Valid commands:')
-  console.error('\thex2diag [hex input]')
-  console.error('\thex2bin [hex input]')
-  console.error('\thex2json [--pretty] [hex input]')
-  console.error('\tbin2hex [binary input]')
   console.error('\tbin2diag [binary input]')
+  console.error('\tbin2hex [binary input]')
   console.error('\tbin2json [--pretty] [binary input]')
-  console.error('\tjson2hex \'[json input]\'')
-  console.error('\tjson2diag \'[json input]\'')
+  console.error('\tdiag2bin [diagnostic input]')
+  console.error('\tdiag2hex [diagnostic input]')
+  console.error('\tdiag2json [--pretty] [diagnostic input]')
+  console.error('\thex2bin [hex input]')
+  console.error('\thex2diag [hex input]')
+  console.error('\thex2json [--pretty] [hex input]')
   console.error('\tjson2bin \'[json input]\'')
+  console.error('\tjson2diag \'[json input]\'')
+  console.error('\tjson2hex \'[json input]\'')
   console.error('Input may either be supplied as an argument or piped via stdin')
   process.exit(code || 0)
 }
@@ -59,26 +62,15 @@ async function run () {
       return usage(0)
     }
 
-    case 'hex2json': {
-      const { argv, pretty } = argvPretty()
-      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
-      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
-    }
-
-    case 'hex2diag': {
-      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+    case 'bin2diag': {
+      /* c8 ignore next 1 */
+      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
       for (const line of tokensToDiagnostic(bin)) {
         console.log(line)
       }
       return
     }
 
-    case 'hex2bin': {
-      // this is really nothing to do with cbor.. just handy
-      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
-      return process.stdout.write(bin)
-    }
-
     case 'bin2hex': {
       // this is really nothing to do with cbor.. just handy
       /* c8 ignore next 1 */
@@ -93,19 +85,52 @@ async function run () {
       return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
     }
 
-    case 'bin2diag': {
+    case 'diag2bin': {
+      // no coverage on windows for non-stdin input
       /* c8 ignore next 1 */
-      const bin = process.argv.length < 4 ? (await fromStdin()) : new TextEncoder().encode(process.argv[3])
+      const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return process.stdout.write(bin)
+    }
+
+    case 'diag2hex': {
+      // no coverage on windows for non-stdin input
+      /* c8 ignore next 1 */
+      const bin = fromDiag(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return console.log(toHex(bin))
+    }
+
+    case 'diag2json': {
+      const { argv, pretty } = argvPretty()
+      // no coverage on windows for non-stdin input
+      /* c8 ignore next 1 */
+      const bin = fromDiag(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
+    }
+
+    case 'hex2bin': {
+      // this is really nothing to do with cbor.. just handy
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
+      return process.stdout.write(bin)
+    }
+
+    case 'hex2diag': {
+      const bin = fromHex(process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3])
       for (const line of tokensToDiagnostic(bin)) {
         console.log(line)
       }
       return
     }
 
-    case 'json2hex': {
+    case 'hex2json': {
+      const { argv, pretty } = argvPretty()
+      const bin = fromHex(argv.length < 4 ? (await fromStdin()).toString() : argv[3])
+      return console.log(JSON.stringify(decode(bin), undefined, pretty ? 2 : undefined))
+    }
+
+    case 'json2bin': {
       const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
       const obj = JSON.parse(inp)
-      return console.log(toHex(encode(obj)))
+      return process.stdout.write(encode(obj))
     }
 
     case 'json2diag': {
@@ -117,10 +142,10 @@ async function run () {
       return
     }
 
-    case 'json2bin': {
+    case 'json2hex': {
       const inp = process.argv.length < 4 ? (await fromStdin()).toString() : process.argv[3]
       const obj = JSON.parse(inp)
-      return process.stdout.write(encode(obj))
+      return console.log(toHex(encode(obj)))
     }
 
     default: { // no, or unknown cmd

package/lib/diagnostic.js

@@ -1,12 +1,16 @@
 import { Tokeniser } from './decode.js'
-import { toHex } from './byte-utils.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)
+  const tokeniser = new Tokeniser(inp, { retainStringBytes: true })
   let pos = 0
   const indent = []
 
@@ -26,6 +30,7 @@ function * tokensToDiagnostic (inp, width = 100) {
     let vLength = token.encodedLength - 1
     /** @type {string|number} */
     let v = String(token.value)
+    let outp = `${margin}${slc(0, 1)}`
     const str = token.type.name === 'bytes' || token.type.name === 'string'
     if (token.type.name === 'string') {
       v = v.length
@@ -36,7 +41,33 @@ function * tokensToDiagnostic (inp, width = 100) {
       vLength -= v
     }
 
-    let outp = `${margin}${slc(0, 1)} ${slc(1, vLength)}`
+    let multilen
+    switch (token.type.name) {
+      case 'string':
+      case 'bytes':
+      case 'map':
+      case 'array':
+        // 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.name === '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}`
@@ -46,19 +77,26 @@ function * tokensToDiagnostic (inp, width = 100) {
     yield outp
 
     if (str) {
+      let asString = token.type.name === 'string'
       margin += '  '
-      const repr = token.type.name === 'bytes' ? token.value : new TextEncoder().encode(token.value)
+      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
-        // the assumption that we can utf8 a byte-sliced version is a stretch,
-        // we could be slicing in the middle of a multi-byte character
-        const st = token.type.name === 'string'
-          ? new TextDecoder().decode(piece)
+        const st = asString
+          ? utf8Decoder.decode(piece)
           : piece.reduce((/** @type {string} */ p, /** @type {number} */ c) => {
-            if (c < 0x20 || c === 0x7f) {
+            if (c < 0x20 || (c >= 0x7f && c < 0xa1) || c === 0xad) {
               return `${p}\\x${c.toString(16).padStart(2, '0')}`
             }
             return `${p}${String.fromCharCode(c)}`
@@ -67,17 +105,16 @@ function * tokensToDiagnostic (inp, width = 100) {
       }
     }
 
+    if (indent.length) {
+      indent[indent.length - 1]--
+    }
     if (!token.type.terminal) {
       switch (token.type.name) {
         case 'map':
-          if (token.value) {
-            indent.push(token.value * 2)
-          }
+          indent.push(token.value * 2)
           break
         case 'array':
-          if (token.value) {
-            indent.push(token.value)
-          }
+          indent.push(token.value)
           break
         // TODO: test tags .. somehow
         /* c8 ignore next 5 */
@@ -87,17 +124,31 @@ function * tokensToDiagnostic (inp, width = 100) {
         default:
           throw new Error(`Unknown token type '${token.type.name}'`)
       }
-    } else {
-      if (indent.length) {
-        indent[indent.length - 1]--
-        if (indent[indent.length - 1] === 0) {
-          indent.pop()
-        }
-      }
+    }
+    while (indent.length && indent[indent.length - 1] <= 0) {
+      indent.pop()
     }
     // @ts-ignore it should be set on a decode operation
     pos += token.encodedLength
   }
 }
 
-export { tokensToDiagnostic }
+/**
+ * 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/lib/token.js

@@ -54,6 +54,8 @@ class Token {
     this.encodedLength = encodedLength
     /** @type {Uint8Array|undefined} */
     this.encodedBytes = undefined
+    /** @type {Uint8Array|undefined} */
+    this.byteValue = undefined
   }
 
   /* c8 ignore next 3 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cborg",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "description": "Fast CBOR with a focus on strictness",
   "main": "./cjs/cborg.js",
   "bin": {