zkjson 0.6.0 → 1.0.2

package/benchmark/lib/cbor.js

@@ -0,0 +1,387 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014-2016 Patrick Gansterer <paroga@paroga.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+;(function (global, undefined) {
+  "use strict"
+  var POW_2_24 = 5.960464477539063e-8,
+    POW_2_32 = 4294967296,
+    POW_2_53 = 9007199254740992
+
+  function encode(value) {
+    var data = new ArrayBuffer(256)
+    var dataView = new DataView(data)
+    var lastLength
+    var offset = 0
+
+    function prepareWrite(length) {
+      var newByteLength = data.byteLength
+      var requiredLength = offset + length
+      while (newByteLength < requiredLength) newByteLength <<= 1
+      if (newByteLength !== data.byteLength) {
+        var oldDataView = dataView
+        data = new ArrayBuffer(newByteLength)
+        dataView = new DataView(data)
+        var uint32count = (offset + 3) >> 2
+        for (var i = 0; i < uint32count; ++i)
+          dataView.setUint32(i << 2, oldDataView.getUint32(i << 2))
+      }
+
+      lastLength = length
+      return dataView
+    }
+    function commitWrite() {
+      offset += lastLength
+    }
+    function writeFloat64(value) {
+      commitWrite(prepareWrite(8).setFloat64(offset, value))
+    }
+    function writeUint8(value) {
+      commitWrite(prepareWrite(1).setUint8(offset, value))
+    }
+    function writeUint8Array(value) {
+      var dataView = prepareWrite(value.length)
+      for (var i = 0; i < value.length; ++i)
+        dataView.setUint8(offset + i, value[i])
+      commitWrite()
+    }
+    function writeUint16(value) {
+      commitWrite(prepareWrite(2).setUint16(offset, value))
+    }
+    function writeUint32(value) {
+      commitWrite(prepareWrite(4).setUint32(offset, value))
+    }
+    function writeUint64(value) {
+      var low = value % POW_2_32
+      var high = (value - low) / POW_2_32
+      var dataView = prepareWrite(8)
+      dataView.setUint32(offset, high)
+      dataView.setUint32(offset + 4, low)
+      commitWrite()
+    }
+    function writeTypeAndLength(type, length) {
+      if (length < 24) {
+        writeUint8((type << 5) | length)
+      } else if (length < 0x100) {
+        writeUint8((type << 5) | 24)
+        writeUint8(length)
+      } else if (length < 0x10000) {
+        writeUint8((type << 5) | 25)
+        writeUint16(length)
+      } else if (length < 0x100000000) {
+        writeUint8((type << 5) | 26)
+        writeUint32(length)
+      } else {
+        writeUint8((type << 5) | 27)
+        writeUint64(length)
+      }
+    }
+
+    function encodeItem(value) {
+      var i
+
+      if (value === false) return writeUint8(0xf4)
+      if (value === true) return writeUint8(0xf5)
+      if (value === null) return writeUint8(0xf6)
+      if (value === undefined) return writeUint8(0xf7)
+
+      switch (typeof value) {
+        case "number":
+          if (Math.floor(value) === value) {
+            if (0 <= value && value <= POW_2_53)
+              return writeTypeAndLength(0, value)
+            if (-POW_2_53 <= value && value < 0)
+              return writeTypeAndLength(1, -(value + 1))
+          }
+          writeUint8(0xfb)
+          return writeFloat64(value)
+
+        case "string":
+          var utf8data = []
+          for (i = 0; i < value.length; ++i) {
+            var charCode = value.charCodeAt(i)
+            if (charCode < 0x80) {
+              utf8data.push(charCode)
+            } else if (charCode < 0x800) {
+              utf8data.push(0xc0 | (charCode >> 6))
+              utf8data.push(0x80 | (charCode & 0x3f))
+            } else if (charCode < 0xd800) {
+              utf8data.push(0xe0 | (charCode >> 12))
+              utf8data.push(0x80 | ((charCode >> 6) & 0x3f))
+              utf8data.push(0x80 | (charCode & 0x3f))
+            } else {
+              charCode = (charCode & 0x3ff) << 10
+              charCode |= value.charCodeAt(++i) & 0x3ff
+              charCode += 0x10000
+
+              utf8data.push(0xf0 | (charCode >> 18))
+              utf8data.push(0x80 | ((charCode >> 12) & 0x3f))
+              utf8data.push(0x80 | ((charCode >> 6) & 0x3f))
+              utf8data.push(0x80 | (charCode & 0x3f))
+            }
+          }
+
+          writeTypeAndLength(3, utf8data.length)
+          return writeUint8Array(utf8data)
+
+        default:
+          var length
+          if (Array.isArray(value)) {
+            length = value.length
+            writeTypeAndLength(4, length)
+            for (i = 0; i < length; ++i) encodeItem(value[i])
+          } else if (value instanceof Uint8Array) {
+            writeTypeAndLength(2, value.length)
+            writeUint8Array(value)
+          } else {
+            var keys = Object.keys(value)
+            length = keys.length
+            writeTypeAndLength(5, length)
+            for (i = 0; i < length; ++i) {
+              var key = keys[i]
+              encodeItem(key)
+              encodeItem(value[key])
+            }
+          }
+      }
+    }
+
+    encodeItem(value)
+
+    if ("slice" in data) return data.slice(0, offset)
+
+    var ret = new ArrayBuffer(offset)
+    var retView = new DataView(ret)
+    for (var i = 0; i < offset; ++i) retView.setUint8(i, dataView.getUint8(i))
+    return ret
+  }
+
+  function decode(data, tagger, simpleValue) {
+    var dataView = new DataView(data)
+    var offset = 0
+
+    if (typeof tagger !== "function")
+      tagger = function (value) {
+        return value
+      }
+    if (typeof simpleValue !== "function")
+      simpleValue = function () {
+        return undefined
+      }
+
+    function commitRead(length, value) {
+      offset += length
+      return value
+    }
+    function readArrayBuffer(length) {
+      return commitRead(length, new Uint8Array(data, offset, length))
+    }
+    function readFloat16() {
+      var tempArrayBuffer = new ArrayBuffer(4)
+      var tempDataView = new DataView(tempArrayBuffer)
+      var value = readUint16()
+
+      var sign = value & 0x8000
+      var exponent = value & 0x7c00
+      var fraction = value & 0x03ff
+
+      if (exponent === 0x7c00) exponent = 0xff << 10
+      else if (exponent !== 0) exponent += (127 - 15) << 10
+      else if (fraction !== 0) return (sign ? -1 : 1) * fraction * POW_2_24
+
+      tempDataView.setUint32(
+        0,
+        (sign << 16) | (exponent << 13) | (fraction << 13),
+      )
+      return tempDataView.getFloat32(0)
+    }
+    function readFloat32() {
+      return commitRead(4, dataView.getFloat32(offset))
+    }
+    function readFloat64() {
+      return commitRead(8, dataView.getFloat64(offset))
+    }
+    function readUint8() {
+      return commitRead(1, dataView.getUint8(offset))
+    }
+    function readUint16() {
+      return commitRead(2, dataView.getUint16(offset))
+    }
+    function readUint32() {
+      return commitRead(4, dataView.getUint32(offset))
+    }
+    function readUint64() {
+      return readUint32() * POW_2_32 + readUint32()
+    }
+    function readBreak() {
+      if (dataView.getUint8(offset) !== 0xff) return false
+      offset += 1
+      return true
+    }
+    function readLength(additionalInformation) {
+      if (additionalInformation < 24) return additionalInformation
+      if (additionalInformation === 24) return readUint8()
+      if (additionalInformation === 25) return readUint16()
+      if (additionalInformation === 26) return readUint32()
+      if (additionalInformation === 27) return readUint64()
+      if (additionalInformation === 31) return -1
+      throw "Invalid length encoding"
+    }
+    function readIndefiniteStringLength(majorType) {
+      var initialByte = readUint8()
+      if (initialByte === 0xff) return -1
+      var length = readLength(initialByte & 0x1f)
+      if (length < 0 || initialByte >> 5 !== majorType)
+        throw "Invalid indefinite length element"
+      return length
+    }
+
+    function appendUtf16Data(utf16data, length) {
+      for (var i = 0; i < length; ++i) {
+        var value = readUint8()
+        if (value & 0x80) {
+          if (value < 0xe0) {
+            value = ((value & 0x1f) << 6) | (readUint8() & 0x3f)
+            length -= 1
+          } else if (value < 0xf0) {
+            value =
+              ((value & 0x0f) << 12) |
+              ((readUint8() & 0x3f) << 6) |
+              (readUint8() & 0x3f)
+            length -= 2
+          } else {
+            value =
+              ((value & 0x0f) << 18) |
+              ((readUint8() & 0x3f) << 12) |
+              ((readUint8() & 0x3f) << 6) |
+              (readUint8() & 0x3f)
+            length -= 3
+          }
+        }
+
+        if (value < 0x10000) {
+          utf16data.push(value)
+        } else {
+          value -= 0x10000
+          utf16data.push(0xd800 | (value >> 10))
+          utf16data.push(0xdc00 | (value & 0x3ff))
+        }
+      }
+    }
+
+    function decodeItem() {
+      var initialByte = readUint8()
+      var majorType = initialByte >> 5
+      var additionalInformation = initialByte & 0x1f
+      var i
+      var length
+
+      if (majorType === 7) {
+        switch (additionalInformation) {
+          case 25:
+            return readFloat16()
+          case 26:
+            return readFloat32()
+          case 27:
+            return readFloat64()
+        }
+      }
+
+      length = readLength(additionalInformation)
+      if (length < 0 && (majorType < 2 || 6 < majorType)) throw "Invalid length"
+
+      switch (majorType) {
+        case 0:
+          return length
+        case 1:
+          return -1 - length
+        case 2:
+          if (length < 0) {
+            var elements = []
+            var fullArrayLength = 0
+            while ((length = readIndefiniteStringLength(majorType)) >= 0) {
+              fullArrayLength += length
+              elements.push(readArrayBuffer(length))
+            }
+            var fullArray = new Uint8Array(fullArrayLength)
+            var fullArrayOffset = 0
+            for (i = 0; i < elements.length; ++i) {
+              fullArray.set(elements[i], fullArrayOffset)
+              fullArrayOffset += elements[i].length
+            }
+            return fullArray
+          }
+          return readArrayBuffer(length)
+        case 3:
+          var utf16data = []
+          if (length < 0) {
+            while ((length = readIndefiniteStringLength(majorType)) >= 0)
+              appendUtf16Data(utf16data, length)
+          } else appendUtf16Data(utf16data, length)
+          return String.fromCharCode.apply(null, utf16data)
+        case 4:
+          var retArray
+          if (length < 0) {
+            retArray = []
+            while (!readBreak()) retArray.push(decodeItem())
+          } else {
+            retArray = new Array(length)
+            for (i = 0; i < length; ++i) retArray[i] = decodeItem()
+          }
+          return retArray
+        case 5:
+          var retObject = {}
+          for (i = 0; i < length || (length < 0 && !readBreak()); ++i) {
+            var key = decodeItem()
+            retObject[key] = decodeItem()
+          }
+          return retObject
+        case 6:
+          return tagger(decodeItem(), length)
+        case 7:
+          switch (length) {
+            case 20:
+              return false
+            case 21:
+              return true
+            case 22:
+              return null
+            case 23:
+              return undefined
+            default:
+              return simpleValue(length)
+          }
+      }
+    }
+
+    var ret = decodeItem()
+    if (offset !== data.byteLength) throw "Remaining bytes"
+    return ret
+  }
+
+  var obj = { encode: encode, decode: decode }
+
+  if (typeof define === "function" && define.amd) define("cbor/cbor", obj)
+  else if (typeof module !== "undefined" && module.exports) module.exports = obj
+  else if (!global.CBOR) global.CBOR = obj
+})(this)