Use lz-string-unsafe.min.js
This commit is contained in:
Rob Garrison
parent
4eafb32f27
commit
7bfb483c65
2
vendor/lz-string-unsafe/README.md
vendored
2
vendor/lz-string-unsafe/README.md
vendored
|
|
@ -2,4 +2,4 @@
|
|||
|
||||
lz-string-unsafe installed via npm - source repo:
|
||||
|
||||
https://github.com/openstyles/lz-string-unsafe/blob/v1.4.4-beta/lz-string-unsafe.js
|
||||
https://github.com/openstyles/lz-string-unsafe/blob/v1.4.4-beta/lz-string-unsafe.min.js
|
||||
|
|
|
|||
449
vendor/lz-string-unsafe/lz-string-unsafe.js
vendored
449
vendor/lz-string-unsafe/lz-string-unsafe.js
vendored
|
|
@ -1,449 +0,0 @@
|
|||
|
||||
var LZStringUnsafe = (
|
||||
function () {
|
||||
|
||||
// private property
|
||||
var f = String.fromCharCode,
|
||||
Base64CharArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split(''),
|
||||
UriSafeCharArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$".split(''),
|
||||
Base64ReverseDic = {},
|
||||
UriSafeReverseDic = {},
|
||||
i = 65;
|
||||
while (i--) {
|
||||
Base64ReverseDic[Base64CharArray[i].charCodeAt(0)] = i;
|
||||
UriSafeReverseDic[UriSafeCharArray[i].charCodeAt(0)] = i;
|
||||
}
|
||||
var getChar16Bits = function (a) { return f(a); },
|
||||
getCharFromBase64 = function (a) { return Base64CharArray[a]; },
|
||||
getCharFromURISafe = function (a) { return UriSafeCharArray[a]; },
|
||||
getCharFromUTF16 = function (a) { return f(a + 32); };
|
||||
|
||||
var LZString = {
|
||||
compressToBase64: function (input) {
|
||||
if (input == null) return "";
|
||||
var res = LZString._compressToArray(input, 6, getCharFromBase64);
|
||||
// To produce valid Base64
|
||||
var i = res.length % 4;
|
||||
while (i--) {
|
||||
res.push("=");
|
||||
}
|
||||
|
||||
return res.join('');
|
||||
},
|
||||
|
||||
decompressFromBase64: function (input) {
|
||||
if (input == null) return "";
|
||||
if (input == "") return null;
|
||||
return LZString._decompress(input.length, 6, function (index) { return Base64ReverseDic[input.charCodeAt(index)]; });
|
||||
},
|
||||
|
||||
compressToUTF16: function (input) {
|
||||
if (input == null) return "";
|
||||
var compressed = LZString._compressToArray(input, 15, getCharFromUTF16);
|
||||
compressed.push(" ");
|
||||
return compressed.join('');
|
||||
},
|
||||
|
||||
decompressFromUTF16: function (compressed) {
|
||||
if (compressed == null) return "";
|
||||
if (compressed == "") return null;
|
||||
return LZString._decompress(compressed.length, 15, function (index) { return compressed.charCodeAt(index) - 32; });
|
||||
},
|
||||
|
||||
//compress into uint8array (UCS-2 big endian format)
|
||||
compressToUint8Array: function (uncompressed) {
|
||||
var compressed = LZString.compressToArray(uncompressed);
|
||||
var buf = new Uint8Array(compressed.length * 2); // 2 bytes per character
|
||||
|
||||
for (var i = 0, TotalLen = compressed.length; i < TotalLen; i++) {
|
||||
var current_value = compressed[i].charCodeAt(0);
|
||||
buf[i * 2] = current_value >>> 8;
|
||||
buf[i * 2 + 1] = current_value & 0xFF;
|
||||
}
|
||||
return buf;
|
||||
},
|
||||
|
||||
//decompress from uint8array (UCS-2 big endian format)
|
||||
decompressFromUint8Array: function (compressed) {
|
||||
if (compressed === null || compressed === undefined) {
|
||||
return LZString.decompressFromArray(compressed);
|
||||
} else if (compressed.length == 0) {
|
||||
return null;
|
||||
}
|
||||
return LZString._decompress(compressed.length, 8, function (index) { return compressed[index]; });
|
||||
},
|
||||
|
||||
|
||||
//compress into a string that is already URI encoded
|
||||
compressToEncodedURIComponent: function (input) {
|
||||
if (input == null) return "";
|
||||
return LZString._compressToArray(input, 6, getCharFromURISafe).join('');
|
||||
},
|
||||
|
||||
//decompress from an output of compressToEncodedURIComponent
|
||||
decompressFromEncodedURIComponent: function (input) {
|
||||
if (input == null) return "";
|
||||
if (input == "") return null;
|
||||
input = input.replace(/ /g, "+");
|
||||
return LZString._decompress(input.length, 6, function (index) { return UriSafeReverseDic[input.charCodeAt(index)]; });
|
||||
},
|
||||
|
||||
compress: function (uncompressed) {
|
||||
return LZString.compressToArray(uncompressed).join('');
|
||||
},
|
||||
compressToArray: function (uncompressed) {
|
||||
return LZString._compressToArray(uncompressed, 16, getChar16Bits);
|
||||
},
|
||||
_compressToArray: function (uncompressed, bitsPerChar, getCharFromInt) {
|
||||
if (uncompressed == null) return [];
|
||||
var i = 0, j = 0, k = 0, value = 0,
|
||||
node = [3], // first node will always be initialised like this.
|
||||
// we should never output the root anyway,
|
||||
// so we initiate with terminating token
|
||||
// Also, dictionary[1] will be overwritten
|
||||
// by the firs charCode
|
||||
dictionary = [2, 2, node],
|
||||
freshNode = true,
|
||||
c = 0,
|
||||
nextNode,
|
||||
enlargeIn = 1,
|
||||
dictSize = 4,
|
||||
numBits = 2,
|
||||
data = [],
|
||||
data_val = 0,
|
||||
data_position = 0;
|
||||
|
||||
if (uncompressed.length) {
|
||||
// If there is a string, the first charCode is guaranteed to
|
||||
// be new, so we write it to output stream, and add it to the
|
||||
// dictionary. For the same reason we can initialize freshNode
|
||||
// as true, and new_node, node and dictSize as if
|
||||
// it was already added to the dictionary (see above).
|
||||
|
||||
c = uncompressed.charCodeAt(0);
|
||||
|
||||
// == Write first charCode token to output ==
|
||||
|
||||
// 8 or 16 bit?
|
||||
value = c < 256 ? 0 : 1
|
||||
|
||||
// insert "new 8/16 bit charCode" token
|
||||
// into bitstream (value 1)
|
||||
for (i = 0; i < numBits; i++) {
|
||||
// Value is 0 (8 bit) or 1 (16 bit).
|
||||
// We shift it into the bitstream in reverse
|
||||
// (shifting has precedence over bitmasking)
|
||||
data_val = value >> i | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
// insert charCode bits into bitstream
|
||||
// Nasty but effective hack:
|
||||
// loop 8 or 16 times based on token value
|
||||
value = 8 + 8 * value;
|
||||
for (i = 0; i < value; i++) {
|
||||
// shifting has precedence over bitmasking
|
||||
data_val = c >> i & 1 | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Add charCode to the dictionary.
|
||||
dictionary[1] = c;
|
||||
|
||||
nextchar:
|
||||
for (j = 1; j < uncompressed.length; j++) {
|
||||
c = uncompressed.charCodeAt(j);
|
||||
// does the new charCode match an existing prefix?
|
||||
for (k = 1; k < node.length; k += 2) {
|
||||
if (node[k] == c) {
|
||||
node = node[k + 1];
|
||||
continue nextchar;
|
||||
}
|
||||
}
|
||||
// we only end up here if there is no matching char
|
||||
|
||||
// Prefix+charCode does not exist in trie yet.
|
||||
// We write the prefix to the bitstream, and add
|
||||
// the new charCode to the dictionary if it's new
|
||||
// Then we set `node` to the root node matching
|
||||
// the charCode.
|
||||
|
||||
if (freshNode) {
|
||||
// Prefix is a freshly added character token,
|
||||
// which was already written to the bitstream
|
||||
freshNode = false;
|
||||
} else {
|
||||
// write out the current prefix token
|
||||
value = node[0];
|
||||
for (i = 0; i < numBits; i++) {
|
||||
// shifting has precedence over bitmasking
|
||||
data_val = value >> i & 1 | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Is the new charCode a new character
|
||||
// that needs to be stored at the root?
|
||||
k = 1;
|
||||
while (dictionary[k] != c && k < dictionary.length) {
|
||||
k += 2;
|
||||
}
|
||||
if (k == dictionary.length) {
|
||||
// increase token bitlength if necessary
|
||||
if (--enlargeIn == 0) {
|
||||
enlargeIn = 1 << numBits++;
|
||||
}
|
||||
|
||||
// insert "new 8/16 bit charCode" token,
|
||||
// see comments above for explanation
|
||||
value = c < 256 ? 0 : 1
|
||||
for (i = 0; i < numBits; i++) {
|
||||
data_val = value >> i | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
value = 8 + 8 * value;
|
||||
for (i = 0; i < value; i++) {
|
||||
data_val = c >> i & 1 | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
dictionary.push(c);
|
||||
dictionary.push([dictSize++]);
|
||||
// Note of that we already wrote
|
||||
// the charCode token to the bitstream
|
||||
freshNode = true;
|
||||
}
|
||||
// add node representing prefix + new charCode to trie
|
||||
node.push(c);
|
||||
node.push([dictSize++]);
|
||||
// increase token bitlength if necessary
|
||||
if (--enlargeIn == 0) {
|
||||
enlargeIn = 1 << numBits++;
|
||||
}
|
||||
// set node to first charCode of new prefix
|
||||
// k is guaranteed to be at the current charCode,
|
||||
// since we either broke out of the while loop
|
||||
// when it matched, or just added the new charCode
|
||||
node = dictionary[k + 1];
|
||||
|
||||
}
|
||||
|
||||
// === Write last prefix to output ===
|
||||
if (freshNode) {
|
||||
// character token already written to output
|
||||
freshNode = false;
|
||||
} else {
|
||||
// write out the prefix token
|
||||
value = node[0];
|
||||
for (i = 0; i < numBits; i++) {
|
||||
// shifting has precedence over bitmasking
|
||||
data_val = value >> i & 1 | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Is c a new character?
|
||||
k = 1;
|
||||
while (dictionary[k] != c && k < dictionary.length) {
|
||||
k += 2;
|
||||
}
|
||||
if (k == dictionary.length) {
|
||||
// increase token bitlength if necessary
|
||||
if (--enlargeIn == 0) {
|
||||
enlargeIn = 1 << numBits++;
|
||||
}
|
||||
// insert "new 8/16 bit charCode" token,
|
||||
// see comments above for explanation
|
||||
value = c < 256 ? 0 : 1
|
||||
for (i = 0; i < numBits; i++) {
|
||||
data_val = value >> i | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
value = 8 + 8 * value;
|
||||
for (i = 0; i < value; i++) {
|
||||
data_val = c >> i & 1 | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
// increase token bitlength if necessary
|
||||
if (--enlargeIn == 0) {
|
||||
enlargeIn = 1 << numBits++;
|
||||
}
|
||||
}
|
||||
|
||||
// Mark the end of the stream
|
||||
for (i = 0; i < numBits; i++) {
|
||||
// shifting has precedence over bitmasking
|
||||
data_val = 2 >> i & 1 | data_val << 1;
|
||||
if (++data_position == bitsPerChar) {
|
||||
data_position = 0;
|
||||
data.push(getCharFromInt(data_val));
|
||||
data_val = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// Flush the last char
|
||||
data_val <<= bitsPerChar - data_position;
|
||||
data.push(getCharFromInt(data_val));
|
||||
return data;
|
||||
},
|
||||
|
||||
decompress: function (compressed) {
|
||||
if (compressed == null) return "";
|
||||
if (compressed == "") return null;
|
||||
return LZString._decompress(compressed.length, 16, function (index) { return compressed.charCodeAt(index); });
|
||||
},
|
||||
|
||||
decompressFromArray: function (compressed) {
|
||||
if (compressed == null) return "";
|
||||
if (compressed.length == 0) return null;
|
||||
return LZString._decompress(compressed.length, 16, function (index) { return compressed[index].charCodeAt(0); });
|
||||
},
|
||||
|
||||
_decompress: function (length, resetBits, getNextValue) {
|
||||
var dictionary = [0, 1, 2],
|
||||
enlargeIn = 4,
|
||||
dictSize = 4,
|
||||
numBits = 3,
|
||||
entry = "",
|
||||
result = [],
|
||||
w = "",
|
||||
bits = 0,
|
||||
maxpower = 2,
|
||||
power = 0,
|
||||
c = "",
|
||||
data_val = getNextValue(0),
|
||||
data_position = resetBits,
|
||||
data_index = 1;
|
||||
|
||||
// Get first token, guaranteed to be either
|
||||
// a new character token (8 or 16 bits)
|
||||
// or end of stream token.
|
||||
while (power != maxpower) {
|
||||
// shifting has precedence over bitmasking
|
||||
bits += (data_val >> --data_position & 1) << power++;
|
||||
if (data_position == 0) {
|
||||
data_position = resetBits;
|
||||
data_val = getNextValue(data_index++);
|
||||
}
|
||||
}
|
||||
|
||||
// if end of stream token, return empty string
|
||||
if (bits == 2) {
|
||||
return "";
|
||||
}
|
||||
|
||||
// else, get character
|
||||
maxpower = bits * 8 + 8;
|
||||
bits = power = 0;
|
||||
while (power != maxpower) {
|
||||
// shifting has precedence over bitmasking
|
||||
bits += (data_val >> --data_position & 1) << power++;
|
||||
if (data_position == 0) {
|
||||
data_position = resetBits;
|
||||
data_val = getNextValue(data_index++);
|
||||
}
|
||||
}
|
||||
c = f(bits);
|
||||
dictionary[3] = c;
|
||||
w = c;
|
||||
result.push(c);
|
||||
|
||||
// read rest of string
|
||||
while (data_index <= length) {
|
||||
// read out next token
|
||||
maxpower = numBits;
|
||||
bits = power = 0;
|
||||
while (power != maxpower) {
|
||||
// shifting has precedence over bitmasking
|
||||
bits += (data_val >> --data_position & 1) << power++;
|
||||
if (data_position == 0) {
|
||||
data_position = resetBits;
|
||||
data_val = getNextValue(data_index++);
|
||||
}
|
||||
}
|
||||
|
||||
// 0 or 1 implies new character token
|
||||
if (bits < 2) {
|
||||
maxpower = (8 + 8 * bits);
|
||||
bits = power = 0;
|
||||
while (power != maxpower) {
|
||||
// shifting has precedence over bitmasking
|
||||
bits += (data_val >> --data_position & 1) << power++;
|
||||
if (data_position == 0) {
|
||||
data_position = resetBits;
|
||||
data_val = getNextValue(data_index++);
|
||||
}
|
||||
}
|
||||
dictionary[dictSize] = f(bits);
|
||||
bits = dictSize++;
|
||||
if (--enlargeIn == 0) {
|
||||
enlargeIn = 1 << numBits++;
|
||||
}
|
||||
} else if (bits == 2) {
|
||||
// end of stream token
|
||||
return result.join('');
|
||||
}
|
||||
|
||||
if (bits > dictionary.length) {
|
||||
return null;
|
||||
}
|
||||
entry = bits < dictionary.length ? dictionary[bits] : w + w.charAt(0);
|
||||
result.push(entry);
|
||||
// Add w+entry[0] to the dictionary.
|
||||
dictionary[dictSize++] = w + entry.charAt(0);
|
||||
|
||||
w = entry;
|
||||
|
||||
if (--enlargeIn == 0) {
|
||||
enlargeIn = 1 << numBits++;
|
||||
}
|
||||
|
||||
}
|
||||
return "";
|
||||
}
|
||||
};
|
||||
return LZString;
|
||||
}
|
||||
)();
|
||||
|
||||
if (typeof define === 'function' && define.amd) {
|
||||
define(function () { return LZStringUnsafe; });
|
||||
} else if (typeof module !== 'undefined' && module != null) {
|
||||
module.exports = LZStringUnsafe
|
||||
} else if (typeof angular !== 'undefined' && angular != null) {
|
||||
angular.module('LZStringUnsafe', [])
|
||||
.factory('LZStringUnsafe', function () {
|
||||
return LZStringUnsafe;
|
||||
});
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user