You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
406 lines
12 KiB
406 lines
12 KiB
/*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2014-2016 Patrick Gansterer <[email protected]>
|
|
*
|
|
* 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);
|