@fireproof/vendor 0.0.0-smoke → 1.0.1

package/patched/cborg/lib/json/decode.js

@@ -1,462 +0,0 @@
-// never reference the file directly to ensure the
-// indepency of the json module
-import { decode as _decode, decodeFirst as _decodeFirst } from 'cborg'
-import { Token, Type } from 'cborg'
-import { decodeCodePointsArray } from 'cborg'
-import { decodeErrPrefix } from 'cborg'
-
-/**
- * @typedef {import('../../interface').DecodeOptions} DecodeOptions
- * @typedef {import('../../interface').DecodeTokenizer} DecodeTokenizer
- */
-
-/**
- * @implements {DecodeTokenizer}
- */
-class Tokenizer {
-  /**
-   * @param {Uint8Array} data
-   * @param {DecodeOptions} options
-   */
-  constructor (data, options = {}) {
-    this._pos = 0
-    this.data = data
-    this.options = options
-    /** @type {string[]} */
-    this.modeStack = ['value']
-    this.lastToken = ''
-  }
-
-  pos () {
-    return this._pos
-  }
-
-  /**
-   * @returns {boolean}
-   */
-  done () {
-    return this._pos >= this.data.length
-  }
-
-  /**
-   * @returns {number}
-   */
-  ch () {
-    return this.data[this._pos]
-  }
-
-  /**
-   * @returns {string}
-   */
-  currentMode () {
-    return this.modeStack[this.modeStack.length - 1]
-  }
-
-  skipWhitespace () {
-    let c = this.ch()
-    // @ts-ignore
-    while (c === 32 /* ' ' */ || c === 9 /* '\t' */ || c === 13 /* '\r' */ || c === 10 /* '\n' */) {
-      c = this.data[++this._pos]
-    }
-  }
-
-  /**
-   * @param {number[]} str
-   */
-  expect (str) {
-    if (this.data.length - this._pos < str.length) {
-      throw new Error(`${decodeErrPrefix} unexpected end of input at position ${this._pos}`)
-    }
-    for (let i = 0; i < str.length; i++) {
-      if (this.data[this._pos++] !== str[i]) {
-        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}, expected to find '${String.fromCharCode(...str)}'`)
-      }
-    }
-  }
-
-  parseNumber () {
-    const startPos = this._pos
-    let negative = false
-    let float = false
-
-    /**
-     * @param {number[]} chars
-     */
-    const swallow = (chars) => {
-      while (!this.done()) {
-        const ch = this.ch()
-        if (chars.includes(ch)) {
-          this._pos++
-        } else {
-          break
-        }
-      }
-    }
-
-    // lead
-    if (this.ch() === 45) { // '-'
-      negative = true
-      this._pos++
-    }
-    if (this.ch() === 48) { // '0'
-      this._pos++
-      if (this.ch() === 46) { // '.'
-        this._pos++
-        float = true
-      } else {
-        return new Token(Type.uint, 0, this._pos - startPos)
-      }
-    }
-    swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]) // DIGIT
-    if (negative && this._pos === startPos + 1) {
-      throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}`)
-    }
-    if (!this.done() && this.ch() === 46) { // '.'
-      if (float) {
-        throw new Error(`${decodeErrPrefix} unexpected token at position ${this._pos}`)
-      }
-      float = true
-      this._pos++
-      swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]) // DIGIT
-    }
-    if (!this.done() && (this.ch() === 101 || this.ch() === 69)) { // '[eE]'
-      float = true
-      this._pos++
-      if (!this.done() && (this.ch() === 43 || this.ch() === 45)) { // '+', '-'
-        this._pos++
-      }
-      swallow([48, 49, 50, 51, 52, 53, 54, 55, 56, 57]) // DIGIT
-    }
-    // @ts-ignore
-    const numStr = String.fromCharCode.apply(null, this.data.subarray(startPos, this._pos))
-    const num = parseFloat(numStr)
-    if (float) {
-      return new Token(Type.float, num, this._pos - startPos)
-    }
-    if (this.options.allowBigInt !== true || Number.isSafeInteger(num)) {
-      return new Token(num >= 0 ? Type.uint : Type.negint, num, this._pos - startPos)
-    }
-    return new Token(num >= 0 ? Type.uint : Type.negint, BigInt(numStr), this._pos - startPos)
-  }
-
-  /**
-   * @returns {Token}
-   */
-  parseString () {
-    /* c8 ignore next 4 */
-    if (this.ch() !== 34) { // '"'
-      // this would be a programming error
-      throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}; this shouldn't happen`)
-    }
-    this._pos++
-
-    // check for simple fast-path, all printable ascii, no escapes
-    // >0x10000 elements may fail fn.apply() (http://stackoverflow.com/a/22747272/680742)
-    for (let i = this._pos, l = 0; i < this.data.length && l < 0x10000; i++, l++) {
-      const ch = this.data[i]
-      if (ch === 92 || ch < 32 || ch >= 128) { // '\', ' ', control-chars or non-trivial
-        break
-      }
-      if (ch === 34) { // '"'
-        // @ts-ignore
-        const str = String.fromCharCode.apply(null, this.data.subarray(this._pos, i))
-        this._pos = i + 1
-        return new Token(Type.string, str, l)
-      }
-    }
-
-    const startPos = this._pos
-    const chars = []
-
-    const readu4 = () => {
-      if (this._pos + 4 >= this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected end of unicode escape sequence at position ${this._pos}`)
-      }
-      let u4 = 0
-      for (let i = 0; i < 4; i++) {
-        let ch = this.ch()
-        if (ch >= 48 && ch <= 57) { // '0' && '9'
-          ch -= 48
-        } else if (ch >= 97 && ch <= 102) { // 'a' && 'f'
-          ch = ch - 97 + 10
-        } else if (ch >= 65 && ch <= 70) { // 'A' && 'F'
-          ch = ch - 65 + 10
-        } else {
-          throw new Error(`${decodeErrPrefix} unexpected unicode escape character at position ${this._pos}`)
-        }
-        u4 = u4 * 16 + ch
-        this._pos++
-      }
-      return u4
-    }
-
-    // mostly taken from feross/buffer and adjusted to fit
-    const readUtf8Char = () => {
-      const firstByte = this.ch()
-      let codePoint = null
-      /* c8 ignore next 1 */
-      let bytesPerSequence = (firstByte > 0xef) ? 4 : (firstByte > 0xdf) ? 3 : (firstByte > 0xbf) ? 2 : 1
-
-      if (this._pos + bytesPerSequence > this.data.length) {
-        throw new Error(`${decodeErrPrefix} unexpected unicode sequence at position ${this._pos}`)
-      }
-
-      let secondByte, thirdByte, fourthByte, tempCodePoint
-
-      switch (bytesPerSequence) {
-        /* c8 ignore next 6 */
-        // this case is dealt with by the caller function
-        case 1:
-          if (firstByte < 0x80) {
-            codePoint = firstByte
-          }
-          break
-        case 2:
-          secondByte = this.data[this._pos + 1]
-          if ((secondByte & 0xc0) === 0x80) {
-            tempCodePoint = (firstByte & 0x1f) << 0x6 | (secondByte & 0x3f)
-            if (tempCodePoint > 0x7f) {
-              codePoint = tempCodePoint
-            }
-          }
-          break
-        case 3:
-          secondByte = this.data[this._pos + 1]
-          thirdByte = this.data[this._pos + 2]
-          if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80) {
-            tempCodePoint = (firstByte & 0xf) << 0xc | (secondByte & 0x3f) << 0x6 | (thirdByte & 0x3f)
-            /* c8 ignore next 3 */
-            if (tempCodePoint > 0x7ff && (tempCodePoint < 0xd800 || tempCodePoint > 0xdfff)) {
-              codePoint = tempCodePoint
-            }
-          }
-          break
-        case 4:
-          secondByte = this.data[this._pos + 1]
-          thirdByte = this.data[this._pos + 2]
-          fourthByte = this.data[this._pos + 3]
-          if ((secondByte & 0xc0) === 0x80 && (thirdByte & 0xc0) === 0x80 && (fourthByte & 0xc0) === 0x80) {
-            tempCodePoint = (firstByte & 0xf) << 0x12 | (secondByte & 0x3f) << 0xc | (thirdByte & 0x3f) << 0x6 | (fourthByte & 0x3f)
-            if (tempCodePoint > 0xffff && tempCodePoint < 0x110000) {
-              codePoint = tempCodePoint
-            }
-          }
-      }
-
-      /* c8 ignore next 5 */
-      if (codePoint === null) {
-        // we did not generate a valid codePoint so insert a
-        // replacement char (U+FFFD) and advance only 1 byte
-        codePoint = 0xfffd
-        bytesPerSequence = 1
-      } else if (codePoint > 0xffff) {
-        // encode to utf16 (surrogate pair dance)
-        codePoint -= 0x10000
-        chars.push(codePoint >>> 10 & 0x3ff | 0xd800)
-        codePoint = 0xdc00 | codePoint & 0x3ff
-      }
-
-      chars.push(codePoint)
-      this._pos += bytesPerSequence
-    }
-
-    // TODO: could take the approach of a quick first scan for special chars like encoding/json/decode.go#unquoteBytes
-    // and converting all of the ascii chars from the base array in bulk
-    while (!this.done()) {
-      const ch = this.ch()
-      let ch1
-      switch (ch) {
-        case 92: // '\'
-          this._pos++
-          if (this.done()) {
-            throw new Error(`${decodeErrPrefix} unexpected string termination at position ${this._pos}`)
-          }
-          ch1 = this.ch()
-          this._pos++
-          switch (ch1) {
-            case 34: // '"'
-            case 39: // '\''
-            case 92: // '\'
-            case 47: // '/'
-              chars.push(ch1)
-              break
-            case 98: // 'b'
-              chars.push(8)
-              break
-            case 116: // 't'
-              chars.push(9)
-              break
-            case 110: // 'n'
-              chars.push(10)
-              break
-            case 102: // 'f'
-              chars.push(12)
-              break
-            case 114: // 'r'
-              chars.push(13)
-              break
-            case 117: // 'u'
-              chars.push(readu4())
-              break
-            default:
-              throw new Error(`${decodeErrPrefix} unexpected string escape character at position ${this._pos}`)
-          }
-          break
-        case 34: // '"'
-          this._pos++
-          return new Token(Type.string, decodeCodePointsArray(chars), this._pos - startPos)
-        default:
-          if (ch < 32) { // ' '
-            throw new Error(`${decodeErrPrefix} invalid control character at position ${this._pos}`)
-          } else if (ch < 0x80) {
-            chars.push(ch)
-            this._pos++
-          } else {
-            readUtf8Char()
-          }
-      }
-    }
-
-    throw new Error(`${decodeErrPrefix} unexpected end of string at position ${this._pos}`)
-  }
-
-  /**
-   * @returns {Token}
-   */
-  parseValue () {
-    switch (this.ch()) {
-      case 123: // '{'
-        this.modeStack.push('obj-start')
-        this._pos++
-        return new Token(Type.map, Infinity, 1)
-      case 91: // '['
-        this.modeStack.push('array-start')
-        this._pos++
-        return new Token(Type.array, Infinity, 1)
-      case 34: { // '"'
-        return this.parseString()
-      }
-      case 110: // 'n' / null
-        this.expect([110, 117, 108, 108]) // 'null'
-        return new Token(Type.null, null, 4)
-      case 102: // 'f' / // false
-        this.expect([102, 97, 108, 115, 101]) // 'false'
-        return new Token(Type.false, false, 5)
-      case 116: // 't' / // true
-        this.expect([116, 114, 117, 101]) // 'true'
-        return new Token(Type.true, true, 4)
-      case 45: // '-'
-      case 48: // '0'
-      case 49: // '1'
-      case 50: // '2'
-      case 51: // '3'
-      case 52: // '4'
-      case 53: // '5'
-      case 54: // '6'
-      case 55: // '7'
-      case 56: // '8'
-      case 57: // '9'
-        return this.parseNumber()
-      default:
-        throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}`)
-    }
-  }
-
-  /**
-   * @returns {Token}
-   */
-  next () {
-    this.skipWhitespace()
-    switch (this.currentMode()) {
-      case 'value':
-        this.modeStack.pop()
-        return this.parseValue()
-      case 'array-value': {
-        this.modeStack.pop()
-        if (this.ch() === 93) { // ']'
-          this._pos++
-          this.skipWhitespace()
-          return new Token(Type.break, undefined, 1)
-        }
-        if (this.ch() !== 44) { // ','
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting array delimiter but found '${String.fromCharCode(this.ch())}'`)
-        }
-        this._pos++
-        this.modeStack.push('array-value')
-        this.skipWhitespace()
-        return this.parseValue()
-      }
-      case 'array-start': {
-        this.modeStack.pop()
-        if (this.ch() === 93) { // ']'
-          this._pos++
-          this.skipWhitespace()
-          return new Token(Type.break, undefined, 1)
-        }
-        this.modeStack.push('array-value')
-        this.skipWhitespace()
-        return this.parseValue()
-      }
-      // @ts-ignore
-      case 'obj-key':
-        if (this.ch() === 125) { // '}'
-          this.modeStack.pop()
-          this._pos++
-          this.skipWhitespace()
-          return new Token(Type.break, undefined, 1)
-        }
-        if (this.ch() !== 44) { // ','
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting object delimiter but found '${String.fromCharCode(this.ch())}'`)
-        }
-        this._pos++
-        this.skipWhitespace()
-      case 'obj-start': { // eslint-disable-line no-fallthrough
-        this.modeStack.pop()
-        if (this.ch() === 125) { // '}'
-          this._pos++
-          this.skipWhitespace()
-          return new Token(Type.break, undefined, 1)
-        }
-        const token = this.parseString()
-        this.skipWhitespace()
-        if (this.ch() !== 58) { // ':'
-          throw new Error(`${decodeErrPrefix} unexpected character at position ${this._pos}, was expecting key/value delimiter ':' but found '${String.fromCharCode(this.ch())}'`)
-        }
-        this._pos++
-        this.modeStack.push('obj-value')
-        return token
-      }
-      case 'obj-value': {
-        this.modeStack.pop()
-        this.modeStack.push('obj-key')
-        this.skipWhitespace()
-        return this.parseValue()
-      }
-      /* c8 ignore next 2 */
-      default:
-        throw new Error(`${decodeErrPrefix} unexpected parse state at position ${this._pos}; this shouldn't happen`)
-    }
-  }
-}
-
-/**
- * @param {Uint8Array} data
- * @param {DecodeOptions} [options]
- * @returns {any}
- */
-function decode (data, options) {
-  options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options)
-  return _decode(data, options)
-}
-
-/**
- * @param {Uint8Array} data
- * @param {DecodeOptions} [options]
- * @returns {[any, Uint8Array]}
- */
-function decodeFirst (data, options) {
-  options = Object.assign({ tokenizer: new Tokenizer(data, options) }, options)
-  return _decodeFirst(data, options)
-}
-
-export { decode, decodeFirst, Tokenizer }