mirror of
https://github.com/boxgaming/qbjs.git
synced 2024-05-12 08:00:12 +00:00
1641 lines
79 KiB
JavaScript
1641 lines
79 KiB
JavaScript
/*!
|
|
LZ-UTF8 v0.6.2
|
|
|
|
Copyright (c) 2021, Rotem Dan
|
|
Released under the MIT license.
|
|
|
|
Build date: 2022-04-22
|
|
|
|
Please report any issue at https://github.com/rotemdan/lzutf8.js/issues
|
|
*/
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
LZUTF8.runningInNodeJS = function () {
|
|
return ((typeof process === "object") && (typeof process.versions === "object") && (typeof process.versions.node === "string"));
|
|
};
|
|
LZUTF8.runningInMainNodeJSModule = function () {
|
|
return LZUTF8.runningInNodeJS() && require.main === module;
|
|
};
|
|
LZUTF8.commonJSAvailable = function () {
|
|
return typeof module === "object" && typeof module.exports === "object";
|
|
};
|
|
LZUTF8.runningInWebWorker = function () {
|
|
return typeof window === "undefined" && typeof self === "object" && typeof self.addEventListener === "function" && typeof self.close === "function";
|
|
};
|
|
LZUTF8.runningInNodeChildProcess = function () {
|
|
return LZUTF8.runningInNodeJS() && typeof process.send === "function";
|
|
};
|
|
LZUTF8.runningInNullOrigin = function () {
|
|
if (typeof window !== "object" || typeof window.location !== "object" || typeof document !== "object")
|
|
return false;
|
|
return document.location.protocol !== 'http:' && document.location.protocol !== 'https:';
|
|
};
|
|
LZUTF8.webWorkersAvailable = function () {
|
|
if (typeof Worker !== "function" || LZUTF8.runningInNullOrigin())
|
|
return false;
|
|
if (LZUTF8.runningInNodeJS())
|
|
return false;
|
|
if (navigator && navigator.userAgent && navigator.userAgent.indexOf("Android 4.3") >= 0)
|
|
return false;
|
|
return true;
|
|
};
|
|
LZUTF8.log = function (message, appendToDocument) {
|
|
if (appendToDocument === void 0) { appendToDocument = false; }
|
|
if (typeof console !== "object")
|
|
return;
|
|
console.log(message);
|
|
if (appendToDocument && typeof document == "object")
|
|
document.body.innerHTML += message + "<br/>";
|
|
};
|
|
LZUTF8.createErrorMessage = function (exception, title) {
|
|
if (title === void 0) { title = "Unhandled exception"; }
|
|
if (exception == null)
|
|
return title;
|
|
title += ": ";
|
|
if (typeof exception.content === "object") {
|
|
if (LZUTF8.runningInNodeJS()) {
|
|
return title + exception.content.stack;
|
|
}
|
|
else {
|
|
var exceptionJSON = JSON.stringify(exception.content);
|
|
if (exceptionJSON !== "{}")
|
|
return title + exceptionJSON;
|
|
else
|
|
return title + exception.content;
|
|
}
|
|
}
|
|
else if (typeof exception.content === "string") {
|
|
return title + exception.content;
|
|
}
|
|
else {
|
|
return title + exception;
|
|
}
|
|
};
|
|
LZUTF8.printExceptionAndStackTraceToConsole = function (exception, title) {
|
|
if (title === void 0) { title = "Unhandled exception"; }
|
|
LZUTF8.log(LZUTF8.createErrorMessage(exception, title));
|
|
};
|
|
LZUTF8.getGlobalObject = function () {
|
|
if (typeof global === "object")
|
|
return global;
|
|
else if (typeof window === "object")
|
|
return window;
|
|
else if (typeof self === "object")
|
|
return self;
|
|
else
|
|
return {};
|
|
};
|
|
LZUTF8.toString = Object.prototype.toString;
|
|
if (LZUTF8.commonJSAvailable())
|
|
module.exports = LZUTF8;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var IE10SubarrayBugPatcher;
|
|
(function (IE10SubarrayBugPatcher) {
|
|
if (typeof Uint8Array === "function" && new Uint8Array(1).subarray(1).byteLength !== 0) {
|
|
var subarray = function (start, end) {
|
|
var clamp = function (v, min, max) { return v < min ? min : v > max ? max : v; };
|
|
start = start | 0;
|
|
end = end | 0;
|
|
if (arguments.length < 1)
|
|
start = 0;
|
|
if (arguments.length < 2)
|
|
end = this.length;
|
|
if (start < 0)
|
|
start = this.length + start;
|
|
if (end < 0)
|
|
end = this.length + end;
|
|
start = clamp(start, 0, this.length);
|
|
end = clamp(end, 0, this.length);
|
|
var len = end - start;
|
|
if (len < 0)
|
|
len = 0;
|
|
return new this.constructor(this.buffer, this.byteOffset + start * this.BYTES_PER_ELEMENT, len);
|
|
};
|
|
var types = ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'];
|
|
var globalObject = void 0;
|
|
if (typeof window === "object")
|
|
globalObject = window;
|
|
else if (typeof self === "object")
|
|
globalObject = self;
|
|
if (globalObject !== undefined) {
|
|
for (var i = 0; i < types.length; i++) {
|
|
if (globalObject[types[i]])
|
|
globalObject[types[i]].prototype.subarray = subarray;
|
|
}
|
|
}
|
|
}
|
|
})(IE10SubarrayBugPatcher || (IE10SubarrayBugPatcher = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var AsyncCompressor = (function () {
|
|
function AsyncCompressor() {
|
|
}
|
|
AsyncCompressor.compressAsync = function (input, options, callback) {
|
|
var timer = new LZUTF8.Timer();
|
|
var compressor = new LZUTF8.Compressor();
|
|
if (!callback)
|
|
throw new TypeError("compressAsync: No callback argument given");
|
|
if (typeof input === "string") {
|
|
input = LZUTF8.encodeUTF8(input);
|
|
}
|
|
else if (input == null || !(input instanceof Uint8Array)) {
|
|
callback(undefined, new TypeError("compressAsync: Invalid input argument, only 'string' and 'Uint8Array' are supported"));
|
|
return;
|
|
}
|
|
var sourceBlocks = LZUTF8.ArrayTools.splitByteArray(input, options.blockSize);
|
|
var compressedBlocks = [];
|
|
var compressBlocksStartingAt = function (index) {
|
|
if (index < sourceBlocks.length) {
|
|
var compressedBlock = void 0;
|
|
try {
|
|
compressedBlock = compressor.compressBlock(sourceBlocks[index]);
|
|
}
|
|
catch (e) {
|
|
callback(undefined, e);
|
|
return;
|
|
}
|
|
compressedBlocks.push(compressedBlock);
|
|
if (timer.getElapsedTime() <= 20) {
|
|
compressBlocksStartingAt(index + 1);
|
|
}
|
|
else {
|
|
LZUTF8.enqueueImmediate(function () { return compressBlocksStartingAt(index + 1); });
|
|
timer.restart();
|
|
}
|
|
}
|
|
else {
|
|
var joinedCompressedBlocks_1 = LZUTF8.ArrayTools.concatUint8Arrays(compressedBlocks);
|
|
LZUTF8.enqueueImmediate(function () {
|
|
var result;
|
|
try {
|
|
result = LZUTF8.CompressionCommon.encodeCompressedBytes(joinedCompressedBlocks_1, options.outputEncoding);
|
|
}
|
|
catch (e) {
|
|
callback(undefined, e);
|
|
return;
|
|
}
|
|
LZUTF8.enqueueImmediate(function () { return callback(result); });
|
|
});
|
|
}
|
|
};
|
|
LZUTF8.enqueueImmediate(function () { return compressBlocksStartingAt(0); });
|
|
};
|
|
AsyncCompressor.createCompressionStream = function () {
|
|
var compressor = new LZUTF8.Compressor();
|
|
var NodeStream = require("readable-stream");
|
|
var compressionStream = new NodeStream.Transform({ decodeStrings: true, highWaterMark: 65536 });
|
|
compressionStream._transform = function (data, encoding, done) {
|
|
var buffer;
|
|
try {
|
|
buffer = LZUTF8.BufferTools.uint8ArrayToBuffer(compressor.compressBlock(LZUTF8.BufferTools.bufferToUint8Array(data)));
|
|
}
|
|
catch (e) {
|
|
compressionStream.emit("error", e);
|
|
return;
|
|
}
|
|
compressionStream.push(buffer);
|
|
done();
|
|
};
|
|
return compressionStream;
|
|
};
|
|
return AsyncCompressor;
|
|
}());
|
|
LZUTF8.AsyncCompressor = AsyncCompressor;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var AsyncDecompressor = (function () {
|
|
function AsyncDecompressor() {
|
|
}
|
|
AsyncDecompressor.decompressAsync = function (input, options, callback) {
|
|
if (!callback)
|
|
throw new TypeError("decompressAsync: No callback argument given");
|
|
var timer = new LZUTF8.Timer();
|
|
try {
|
|
input = LZUTF8.CompressionCommon.decodeCompressedBytes(input, options.inputEncoding);
|
|
}
|
|
catch (e) {
|
|
callback(undefined, e);
|
|
return;
|
|
}
|
|
var decompressor = new LZUTF8.Decompressor();
|
|
var sourceBlocks = LZUTF8.ArrayTools.splitByteArray(input, options.blockSize);
|
|
var decompressedBlocks = [];
|
|
var decompressBlocksStartingAt = function (index) {
|
|
if (index < sourceBlocks.length) {
|
|
var decompressedBlock = void 0;
|
|
try {
|
|
decompressedBlock = decompressor.decompressBlock(sourceBlocks[index]);
|
|
}
|
|
catch (e) {
|
|
callback(undefined, e);
|
|
return;
|
|
}
|
|
decompressedBlocks.push(decompressedBlock);
|
|
if (timer.getElapsedTime() <= 20) {
|
|
decompressBlocksStartingAt(index + 1);
|
|
}
|
|
else {
|
|
LZUTF8.enqueueImmediate(function () { return decompressBlocksStartingAt(index + 1); });
|
|
timer.restart();
|
|
}
|
|
}
|
|
else {
|
|
var joinedDecompressedBlocks_1 = LZUTF8.ArrayTools.concatUint8Arrays(decompressedBlocks);
|
|
LZUTF8.enqueueImmediate(function () {
|
|
var result;
|
|
try {
|
|
result = LZUTF8.CompressionCommon.encodeDecompressedBytes(joinedDecompressedBlocks_1, options.outputEncoding);
|
|
}
|
|
catch (e) {
|
|
callback(undefined, e);
|
|
return;
|
|
}
|
|
LZUTF8.enqueueImmediate(function () { return callback(result); });
|
|
});
|
|
}
|
|
};
|
|
LZUTF8.enqueueImmediate(function () { return decompressBlocksStartingAt(0); });
|
|
};
|
|
AsyncDecompressor.createDecompressionStream = function () {
|
|
var decompressor = new LZUTF8.Decompressor();
|
|
var NodeStream = require("readable-stream");
|
|
var decompressionStream = new NodeStream.Transform({ decodeStrings: true, highWaterMark: 65536 });
|
|
decompressionStream._transform = function (data, encoding, done) {
|
|
var buffer;
|
|
try {
|
|
buffer = LZUTF8.BufferTools.uint8ArrayToBuffer(decompressor.decompressBlock(LZUTF8.BufferTools.bufferToUint8Array(data)));
|
|
}
|
|
catch (e) {
|
|
decompressionStream.emit("error", e);
|
|
return;
|
|
}
|
|
decompressionStream.push(buffer);
|
|
done();
|
|
};
|
|
return decompressionStream;
|
|
};
|
|
return AsyncDecompressor;
|
|
}());
|
|
LZUTF8.AsyncDecompressor = AsyncDecompressor;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var WebWorker;
|
|
(function (WebWorker) {
|
|
WebWorker.compressAsync = function (input, options, callback) {
|
|
if (options.inputEncoding == "ByteArray") {
|
|
if (!(input instanceof Uint8Array)) {
|
|
callback(undefined, new TypeError("compressAsync: input is not a Uint8Array"));
|
|
return;
|
|
}
|
|
}
|
|
var request = {
|
|
token: Math.random().toString(),
|
|
type: "compress",
|
|
data: input,
|
|
inputEncoding: options.inputEncoding,
|
|
outputEncoding: options.outputEncoding
|
|
};
|
|
var responseListener = function (e) {
|
|
var response = e.data;
|
|
if (!response || response.token != request.token)
|
|
return;
|
|
WebWorker.globalWorker.removeEventListener("message", responseListener);
|
|
if (response.type == "error")
|
|
callback(undefined, new Error(response.error));
|
|
else
|
|
callback(response.data);
|
|
};
|
|
WebWorker.globalWorker.addEventListener("message", responseListener);
|
|
WebWorker.globalWorker.postMessage(request, []);
|
|
};
|
|
WebWorker.decompressAsync = function (input, options, callback) {
|
|
var request = {
|
|
token: Math.random().toString(),
|
|
type: "decompress",
|
|
data: input,
|
|
inputEncoding: options.inputEncoding,
|
|
outputEncoding: options.outputEncoding
|
|
};
|
|
var responseListener = function (e) {
|
|
var response = e.data;
|
|
if (!response || response.token != request.token)
|
|
return;
|
|
WebWorker.globalWorker.removeEventListener("message", responseListener);
|
|
if (response.type == "error")
|
|
callback(undefined, new Error(response.error));
|
|
else
|
|
callback(response.data);
|
|
};
|
|
WebWorker.globalWorker.addEventListener("message", responseListener);
|
|
WebWorker.globalWorker.postMessage(request, []);
|
|
};
|
|
WebWorker.installWebWorkerIfNeeded = function () {
|
|
if (typeof self == "object" && self.document === undefined && self.addEventListener != undefined) {
|
|
self.addEventListener("message", function (e) {
|
|
var request = e.data;
|
|
if (request.type == "compress") {
|
|
var compressedData = void 0;
|
|
try {
|
|
compressedData = LZUTF8.compress(request.data, { outputEncoding: request.outputEncoding });
|
|
}
|
|
catch (e) {
|
|
self.postMessage({ token: request.token, type: "error", error: LZUTF8.createErrorMessage(e) }, []);
|
|
return;
|
|
}
|
|
var response = {
|
|
token: request.token,
|
|
type: "compressionResult",
|
|
data: compressedData,
|
|
encoding: request.outputEncoding,
|
|
};
|
|
if (response.data instanceof Uint8Array && navigator.appVersion.indexOf("MSIE 10") === -1)
|
|
self.postMessage(response, [response.data.buffer]);
|
|
else
|
|
self.postMessage(response, []);
|
|
}
|
|
else if (request.type == "decompress") {
|
|
var decompressedData = void 0;
|
|
try {
|
|
decompressedData = LZUTF8.decompress(request.data, { inputEncoding: request.inputEncoding, outputEncoding: request.outputEncoding });
|
|
}
|
|
catch (e) {
|
|
self.postMessage({ token: request.token, type: "error", error: LZUTF8.createErrorMessage(e) }, []);
|
|
return;
|
|
}
|
|
var response = {
|
|
token: request.token,
|
|
type: "decompressionResult",
|
|
data: decompressedData,
|
|
encoding: request.outputEncoding,
|
|
};
|
|
if (response.data instanceof Uint8Array && navigator.appVersion.indexOf("MSIE 10") === -1)
|
|
self.postMessage(response, [response.data.buffer]);
|
|
else
|
|
self.postMessage(response, []);
|
|
}
|
|
});
|
|
self.addEventListener("error", function (e) {
|
|
LZUTF8.log(LZUTF8.createErrorMessage(e.error, "Unexpected LZUTF8 WebWorker exception"));
|
|
});
|
|
}
|
|
};
|
|
WebWorker.createGlobalWorkerIfNeeded = function () {
|
|
if (WebWorker.globalWorker)
|
|
return true;
|
|
if (!LZUTF8.webWorkersAvailable())
|
|
return false;
|
|
if (!WebWorker.scriptURI && typeof document === "object") {
|
|
var scriptElement = document.getElementById("lzutf8");
|
|
if (scriptElement != null)
|
|
WebWorker.scriptURI = scriptElement.getAttribute("src") || undefined;
|
|
}
|
|
if (WebWorker.scriptURI) {
|
|
WebWorker.globalWorker = new Worker(WebWorker.scriptURI);
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
};
|
|
WebWorker.terminate = function () {
|
|
if (WebWorker.globalWorker) {
|
|
WebWorker.globalWorker.terminate();
|
|
WebWorker.globalWorker = undefined;
|
|
}
|
|
};
|
|
})(WebWorker = LZUTF8.WebWorker || (LZUTF8.WebWorker = {}));
|
|
WebWorker.installWebWorkerIfNeeded();
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var ArraySegment = (function () {
|
|
function ArraySegment(container, startPosition, length) {
|
|
this.container = container;
|
|
this.startPosition = startPosition;
|
|
this.length = length;
|
|
}
|
|
ArraySegment.prototype.get = function (index) {
|
|
return this.container[this.startPosition + index];
|
|
};
|
|
ArraySegment.prototype.getInReversedOrder = function (reverseIndex) {
|
|
return this.container[this.startPosition + this.length - 1 - reverseIndex];
|
|
};
|
|
ArraySegment.prototype.set = function (index, value) {
|
|
this.container[this.startPosition + index] = value;
|
|
};
|
|
return ArraySegment;
|
|
}());
|
|
LZUTF8.ArraySegment = ArraySegment;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var ArrayTools;
|
|
(function (ArrayTools) {
|
|
ArrayTools.copyElements = function (source, sourceIndex, destination, destinationIndex, count) {
|
|
while (count--)
|
|
destination[destinationIndex++] = source[sourceIndex++];
|
|
};
|
|
ArrayTools.zeroElements = function (collection, index, count) {
|
|
while (count--)
|
|
collection[index++] = 0;
|
|
};
|
|
ArrayTools.countNonzeroValuesInArray = function (array) {
|
|
var result = 0;
|
|
for (var i = 0; i < array.length; i++)
|
|
if (array[i])
|
|
result++;
|
|
return result;
|
|
};
|
|
ArrayTools.truncateStartingElements = function (array, truncatedLength) {
|
|
if (array.length <= truncatedLength)
|
|
throw new RangeError("truncateStartingElements: Requested length should be smaller than array length");
|
|
var sourcePosition = array.length - truncatedLength;
|
|
for (var i = 0; i < truncatedLength; i++)
|
|
array[i] = array[sourcePosition + i];
|
|
array.length = truncatedLength;
|
|
};
|
|
ArrayTools.doubleByteArrayCapacity = function (array) {
|
|
var newArray = new Uint8Array(array.length * 2);
|
|
newArray.set(array);
|
|
return newArray;
|
|
};
|
|
ArrayTools.concatUint8Arrays = function (arrays) {
|
|
var totalLength = 0;
|
|
for (var _i = 0, arrays_1 = arrays; _i < arrays_1.length; _i++) {
|
|
var array = arrays_1[_i];
|
|
totalLength += array.length;
|
|
}
|
|
var result = new Uint8Array(totalLength);
|
|
var offset = 0;
|
|
for (var _a = 0, arrays_2 = arrays; _a < arrays_2.length; _a++) {
|
|
var array = arrays_2[_a];
|
|
result.set(array, offset);
|
|
offset += array.length;
|
|
}
|
|
return result;
|
|
};
|
|
ArrayTools.splitByteArray = function (byteArray, maxPartLength) {
|
|
var result = [];
|
|
for (var offset = 0; offset < byteArray.length;) {
|
|
var blockLength = Math.min(maxPartLength, byteArray.length - offset);
|
|
result.push(byteArray.subarray(offset, offset + blockLength));
|
|
offset += blockLength;
|
|
}
|
|
return result;
|
|
};
|
|
})(ArrayTools = LZUTF8.ArrayTools || (LZUTF8.ArrayTools = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var BufferTools;
|
|
(function (BufferTools) {
|
|
BufferTools.convertToUint8ArrayIfNeeded = function (input) {
|
|
if (typeof Buffer === "function" && Buffer.isBuffer(input))
|
|
return BufferTools.bufferToUint8Array(input);
|
|
else
|
|
return input;
|
|
};
|
|
BufferTools.uint8ArrayToBuffer = function (arr) {
|
|
if (Buffer.prototype instanceof Uint8Array) {
|
|
var arrClone = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
Object["setPrototypeOf"](arrClone, Buffer.prototype);
|
|
return arrClone;
|
|
}
|
|
else {
|
|
var len = arr.length;
|
|
var buf = new Buffer(len);
|
|
for (var i = 0; i < len; i++)
|
|
buf[i] = arr[i];
|
|
return buf;
|
|
}
|
|
};
|
|
BufferTools.bufferToUint8Array = function (buf) {
|
|
if (Buffer.prototype instanceof Uint8Array) {
|
|
return new Uint8Array(buf["buffer"], buf["byteOffset"], buf["byteLength"]);
|
|
}
|
|
else {
|
|
var len = buf.length;
|
|
var arr = new Uint8Array(len);
|
|
for (var i = 0; i < len; i++)
|
|
arr[i] = buf[i];
|
|
return arr;
|
|
}
|
|
};
|
|
})(BufferTools = LZUTF8.BufferTools || (LZUTF8.BufferTools = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var CompressionCommon;
|
|
(function (CompressionCommon) {
|
|
CompressionCommon.getCroppedBuffer = function (buffer, cropStartOffset, cropLength, additionalCapacity) {
|
|
if (additionalCapacity === void 0) { additionalCapacity = 0; }
|
|
var croppedBuffer = new Uint8Array(cropLength + additionalCapacity);
|
|
croppedBuffer.set(buffer.subarray(cropStartOffset, cropStartOffset + cropLength));
|
|
return croppedBuffer;
|
|
};
|
|
CompressionCommon.getCroppedAndAppendedByteArray = function (bytes, cropStartOffset, cropLength, byteArrayToAppend) {
|
|
return LZUTF8.ArrayTools.concatUint8Arrays([bytes.subarray(cropStartOffset, cropStartOffset + cropLength), byteArrayToAppend]);
|
|
};
|
|
CompressionCommon.detectCompressionSourceEncoding = function (input) {
|
|
if (input == null)
|
|
throw new TypeError("detectCompressionSourceEncoding: input is null or undefined");
|
|
if (typeof input === "string")
|
|
return "String";
|
|
else if (input instanceof Uint8Array || (typeof Buffer === "function" && Buffer.isBuffer(input)))
|
|
return "ByteArray";
|
|
else
|
|
throw new TypeError("detectCompressionSourceEncoding: input must be of type 'string', 'Uint8Array' or 'Buffer'");
|
|
};
|
|
CompressionCommon.encodeCompressedBytes = function (compressedBytes, outputEncoding) {
|
|
switch (outputEncoding) {
|
|
case "ByteArray":
|
|
return compressedBytes;
|
|
case "Buffer":
|
|
return LZUTF8.BufferTools.uint8ArrayToBuffer(compressedBytes);
|
|
case "Base64":
|
|
return LZUTF8.encodeBase64(compressedBytes);
|
|
case "BinaryString":
|
|
return LZUTF8.encodeBinaryString(compressedBytes);
|
|
case "StorageBinaryString":
|
|
return LZUTF8.encodeStorageBinaryString(compressedBytes);
|
|
default:
|
|
throw new TypeError("encodeCompressedBytes: invalid output encoding requested");
|
|
}
|
|
};
|
|
CompressionCommon.decodeCompressedBytes = function (compressedData, inputEncoding) {
|
|
if (inputEncoding == null)
|
|
throw new TypeError("decodeCompressedData: Input is null or undefined");
|
|
switch (inputEncoding) {
|
|
case "ByteArray":
|
|
case "Buffer":
|
|
var normalizedBytes = LZUTF8.BufferTools.convertToUint8ArrayIfNeeded(compressedData);
|
|
if (!(normalizedBytes instanceof Uint8Array))
|
|
throw new TypeError("decodeCompressedData: 'ByteArray' or 'Buffer' input type was specified but input is not a Uint8Array or Buffer");
|
|
return normalizedBytes;
|
|
case "Base64":
|
|
if (typeof compressedData !== "string")
|
|
throw new TypeError("decodeCompressedData: 'Base64' input type was specified but input is not a string");
|
|
return LZUTF8.decodeBase64(compressedData);
|
|
case "BinaryString":
|
|
if (typeof compressedData !== "string")
|
|
throw new TypeError("decodeCompressedData: 'BinaryString' input type was specified but input is not a string");
|
|
return LZUTF8.decodeBinaryString(compressedData);
|
|
case "StorageBinaryString":
|
|
if (typeof compressedData !== "string")
|
|
throw new TypeError("decodeCompressedData: 'StorageBinaryString' input type was specified but input is not a string");
|
|
return LZUTF8.decodeStorageBinaryString(compressedData);
|
|
default:
|
|
throw new TypeError("decodeCompressedData: invalid input encoding requested: '".concat(inputEncoding, "'"));
|
|
}
|
|
};
|
|
CompressionCommon.encodeDecompressedBytes = function (decompressedBytes, outputEncoding) {
|
|
switch (outputEncoding) {
|
|
case "String":
|
|
return LZUTF8.decodeUTF8(decompressedBytes);
|
|
case "ByteArray":
|
|
return decompressedBytes;
|
|
case "Buffer":
|
|
if (typeof Buffer !== "function")
|
|
throw new TypeError("encodeDecompressedBytes: a 'Buffer' type was specified but is not supported at the current envirnment");
|
|
return LZUTF8.BufferTools.uint8ArrayToBuffer(decompressedBytes);
|
|
default:
|
|
throw new TypeError("encodeDecompressedBytes: invalid output encoding requested");
|
|
}
|
|
};
|
|
})(CompressionCommon = LZUTF8.CompressionCommon || (LZUTF8.CompressionCommon = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var EventLoop;
|
|
(function (EventLoop) {
|
|
var queuedFunctions = [];
|
|
var asyncFlushFunc;
|
|
EventLoop.enqueueImmediate = function (func) {
|
|
queuedFunctions.push(func);
|
|
if (queuedFunctions.length === 1)
|
|
asyncFlushFunc();
|
|
};
|
|
EventLoop.initializeScheduler = function () {
|
|
var flush = function () {
|
|
for (var _i = 0, queuedFunctions_1 = queuedFunctions; _i < queuedFunctions_1.length; _i++) {
|
|
var func = queuedFunctions_1[_i];
|
|
try {
|
|
func.call(undefined);
|
|
}
|
|
catch (exception) {
|
|
LZUTF8.printExceptionAndStackTraceToConsole(exception, "enqueueImmediate exception");
|
|
}
|
|
}
|
|
queuedFunctions.length = 0;
|
|
};
|
|
if (LZUTF8.runningInNodeJS()) {
|
|
asyncFlushFunc = function () { return setImmediate(function () { return flush(); }); };
|
|
}
|
|
if (typeof window === "object" && typeof window.addEventListener === "function" && typeof window.postMessage === "function") {
|
|
var token_1 = "enqueueImmediate-" + Math.random().toString();
|
|
window.addEventListener("message", function (event) {
|
|
if (event.data === token_1)
|
|
flush();
|
|
});
|
|
var targetOrigin_1;
|
|
if (LZUTF8.runningInNullOrigin())
|
|
targetOrigin_1 = '*';
|
|
else
|
|
targetOrigin_1 = window.location.href;
|
|
asyncFlushFunc = function () { return window.postMessage(token_1, targetOrigin_1); };
|
|
}
|
|
else if (typeof MessageChannel === "function" && typeof MessagePort === "function") {
|
|
var channel_1 = new MessageChannel();
|
|
channel_1.port1.onmessage = function () { return flush(); };
|
|
asyncFlushFunc = function () { return channel_1.port2.postMessage(0); };
|
|
}
|
|
else {
|
|
asyncFlushFunc = function () { return setTimeout(function () { return flush(); }, 0); };
|
|
}
|
|
};
|
|
EventLoop.initializeScheduler();
|
|
})(EventLoop = LZUTF8.EventLoop || (LZUTF8.EventLoop = {}));
|
|
LZUTF8.enqueueImmediate = function (func) { return EventLoop.enqueueImmediate(func); };
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var ObjectTools;
|
|
(function (ObjectTools) {
|
|
ObjectTools.override = function (obj, newPropertyValues) {
|
|
return ObjectTools.extend(obj, newPropertyValues);
|
|
};
|
|
ObjectTools.extend = function (obj, newProperties) {
|
|
if (obj == null)
|
|
throw new TypeError("obj is null or undefined");
|
|
if (typeof obj !== "object")
|
|
throw new TypeError("obj is not an object");
|
|
if (newProperties == null)
|
|
newProperties = {};
|
|
if (typeof newProperties !== "object")
|
|
throw new TypeError("newProperties is not an object");
|
|
if (newProperties != null) {
|
|
for (var property in newProperties)
|
|
obj[property] = newProperties[property];
|
|
}
|
|
return obj;
|
|
};
|
|
})(ObjectTools = LZUTF8.ObjectTools || (LZUTF8.ObjectTools = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
LZUTF8.getRandomIntegerInRange = function (low, high) {
|
|
return low + Math.floor(Math.random() * (high - low));
|
|
};
|
|
LZUTF8.getRandomUTF16StringOfLength = function (length) {
|
|
var randomString = "";
|
|
for (var i = 0; i < length; i++) {
|
|
var randomCodePoint = void 0;
|
|
do {
|
|
randomCodePoint = LZUTF8.getRandomIntegerInRange(0, 0x10FFFF + 1);
|
|
} while (randomCodePoint >= 0xD800 && randomCodePoint <= 0xDFFF);
|
|
randomString += LZUTF8.Encoding.CodePoint.decodeToString(randomCodePoint);
|
|
}
|
|
return randomString;
|
|
};
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var StringBuilder = (function () {
|
|
function StringBuilder(outputBufferCapacity) {
|
|
if (outputBufferCapacity === void 0) { outputBufferCapacity = 1024; }
|
|
this.outputBufferCapacity = outputBufferCapacity;
|
|
this.outputPosition = 0;
|
|
this.outputString = "";
|
|
this.outputBuffer = new Uint16Array(this.outputBufferCapacity);
|
|
}
|
|
StringBuilder.prototype.appendCharCode = function (charCode) {
|
|
this.outputBuffer[this.outputPosition++] = charCode;
|
|
if (this.outputPosition === this.outputBufferCapacity)
|
|
this.flushBufferToOutputString();
|
|
};
|
|
StringBuilder.prototype.appendCharCodes = function (charCodes) {
|
|
for (var i = 0, length_1 = charCodes.length; i < length_1; i++)
|
|
this.appendCharCode(charCodes[i]);
|
|
};
|
|
StringBuilder.prototype.appendString = function (str) {
|
|
for (var i = 0, length_2 = str.length; i < length_2; i++)
|
|
this.appendCharCode(str.charCodeAt(i));
|
|
};
|
|
StringBuilder.prototype.appendCodePoint = function (codePoint) {
|
|
if (codePoint <= 0xFFFF) {
|
|
this.appendCharCode(codePoint);
|
|
}
|
|
else if (codePoint <= 0x10FFFF) {
|
|
this.appendCharCode(0xD800 + ((codePoint - 0x10000) >>> 10));
|
|
this.appendCharCode(0xDC00 + ((codePoint - 0x10000) & 1023));
|
|
}
|
|
else
|
|
throw new Error("appendCodePoint: A code point of ".concat(codePoint, " cannot be encoded in UTF-16"));
|
|
};
|
|
StringBuilder.prototype.getOutputString = function () {
|
|
this.flushBufferToOutputString();
|
|
return this.outputString;
|
|
};
|
|
StringBuilder.prototype.flushBufferToOutputString = function () {
|
|
if (this.outputPosition === this.outputBufferCapacity)
|
|
this.outputString += String.fromCharCode.apply(null, this.outputBuffer);
|
|
else
|
|
this.outputString += String.fromCharCode.apply(null, this.outputBuffer.subarray(0, this.outputPosition));
|
|
this.outputPosition = 0;
|
|
};
|
|
return StringBuilder;
|
|
}());
|
|
LZUTF8.StringBuilder = StringBuilder;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Timer = (function () {
|
|
function Timer() {
|
|
this.restart();
|
|
}
|
|
Timer.prototype.restart = function () {
|
|
this.startTime = Timer.getTimestamp();
|
|
};
|
|
Timer.prototype.getElapsedTime = function () {
|
|
return Timer.getTimestamp() - this.startTime;
|
|
};
|
|
Timer.prototype.getElapsedTimeAndRestart = function () {
|
|
var elapsedTime = this.getElapsedTime();
|
|
this.restart();
|
|
return elapsedTime;
|
|
};
|
|
Timer.prototype.logAndRestart = function (title, logToDocument) {
|
|
if (logToDocument === void 0) { logToDocument = true; }
|
|
var elapsedTime = this.getElapsedTime();
|
|
var message = "".concat(title, ": ").concat(elapsedTime.toFixed(3), "ms");
|
|
LZUTF8.log(message, logToDocument);
|
|
this.restart();
|
|
return elapsedTime;
|
|
};
|
|
Timer.getTimestamp = function () {
|
|
if (!this.timestampFunc)
|
|
this.createGlobalTimestampFunction();
|
|
return this.timestampFunc();
|
|
};
|
|
Timer.getMicrosecondTimestamp = function () {
|
|
return Math.floor(Timer.getTimestamp() * 1000);
|
|
};
|
|
Timer.createGlobalTimestampFunction = function () {
|
|
if (typeof process === "object" && typeof process.hrtime === "function") {
|
|
var baseTimestamp_1 = 0;
|
|
this.timestampFunc = function () {
|
|
var nodeTimeStamp = process.hrtime();
|
|
var millisecondTime = (nodeTimeStamp[0] * 1000) + (nodeTimeStamp[1] / 1000000);
|
|
return baseTimestamp_1 + millisecondTime;
|
|
};
|
|
baseTimestamp_1 = Date.now() - this.timestampFunc();
|
|
}
|
|
else if (typeof chrome === "object" && chrome.Interval) {
|
|
var baseTimestamp_2 = Date.now();
|
|
var chromeIntervalObject_1 = new chrome.Interval();
|
|
chromeIntervalObject_1.start();
|
|
this.timestampFunc = function () { return baseTimestamp_2 + chromeIntervalObject_1.microseconds() / 1000; };
|
|
}
|
|
else if (typeof performance === "object" && performance.now) {
|
|
var baseTimestamp_3 = Date.now() - performance.now();
|
|
this.timestampFunc = function () { return baseTimestamp_3 + performance.now(); };
|
|
}
|
|
else if (Date.now) {
|
|
this.timestampFunc = function () { return Date.now(); };
|
|
}
|
|
else {
|
|
this.timestampFunc = function () { return (new Date()).getTime(); };
|
|
}
|
|
};
|
|
return Timer;
|
|
}());
|
|
LZUTF8.Timer = Timer;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Compressor = (function () {
|
|
function Compressor(useCustomHashTable) {
|
|
if (useCustomHashTable === void 0) { useCustomHashTable = true; }
|
|
this.MinimumSequenceLength = 4;
|
|
this.MaximumSequenceLength = 31;
|
|
this.MaximumMatchDistance = 32767;
|
|
this.PrefixHashTableSize = 65537;
|
|
this.inputBufferStreamOffset = 1;
|
|
if (useCustomHashTable && typeof Uint32Array == "function")
|
|
this.prefixHashTable = new LZUTF8.CompressorCustomHashTable(this.PrefixHashTableSize);
|
|
else
|
|
this.prefixHashTable = new LZUTF8.CompressorSimpleHashTable(this.PrefixHashTableSize);
|
|
}
|
|
Compressor.prototype.compressBlock = function (input) {
|
|
if (input === undefined || input === null)
|
|
throw new TypeError("compressBlock: undefined or null input received");
|
|
if (typeof input == "string")
|
|
input = LZUTF8.encodeUTF8(input);
|
|
input = LZUTF8.BufferTools.convertToUint8ArrayIfNeeded(input);
|
|
return this.compressUtf8Block(input);
|
|
};
|
|
Compressor.prototype.compressUtf8Block = function (utf8Bytes) {
|
|
if (!utf8Bytes || utf8Bytes.length == 0)
|
|
return new Uint8Array(0);
|
|
var bufferStartingReadOffset = this.cropAndAddNewBytesToInputBuffer(utf8Bytes);
|
|
var inputBuffer = this.inputBuffer;
|
|
var inputBufferLength = this.inputBuffer.length;
|
|
this.outputBuffer = new Uint8Array(utf8Bytes.length);
|
|
this.outputBufferPosition = 0;
|
|
var latestMatchEndPosition = 0;
|
|
for (var readPosition = bufferStartingReadOffset; readPosition < inputBufferLength; readPosition++) {
|
|
var inputValue = inputBuffer[readPosition];
|
|
var withinAMatchedRange = readPosition < latestMatchEndPosition;
|
|
if (readPosition > inputBufferLength - this.MinimumSequenceLength) {
|
|
if (!withinAMatchedRange)
|
|
this.outputRawByte(inputValue);
|
|
continue;
|
|
}
|
|
var targetBucketIndex = this.getBucketIndexForPrefix(readPosition);
|
|
if (!withinAMatchedRange) {
|
|
var matchLocator = this.findLongestMatch(readPosition, targetBucketIndex);
|
|
if (matchLocator != null) {
|
|
this.outputPointerBytes(matchLocator.length, matchLocator.distance);
|
|
latestMatchEndPosition = readPosition + matchLocator.length;
|
|
withinAMatchedRange = true;
|
|
}
|
|
}
|
|
if (!withinAMatchedRange)
|
|
this.outputRawByte(inputValue);
|
|
var inputStreamPosition = this.inputBufferStreamOffset + readPosition;
|
|
this.prefixHashTable.addValueToBucket(targetBucketIndex, inputStreamPosition);
|
|
}
|
|
return this.outputBuffer.subarray(0, this.outputBufferPosition);
|
|
};
|
|
Compressor.prototype.findLongestMatch = function (matchedSequencePosition, bucketIndex) {
|
|
var bucket = this.prefixHashTable.getArraySegmentForBucketIndex(bucketIndex, this.reusableArraySegmentObject);
|
|
if (bucket == null)
|
|
return null;
|
|
var input = this.inputBuffer;
|
|
var longestMatchDistance;
|
|
var longestMatchLength = 0;
|
|
for (var i = 0; i < bucket.length; i++) {
|
|
var testedSequencePosition = bucket.getInReversedOrder(i) - this.inputBufferStreamOffset;
|
|
var testedSequenceDistance = matchedSequencePosition - testedSequencePosition;
|
|
var lengthToSurpass = void 0;
|
|
if (longestMatchDistance === undefined)
|
|
lengthToSurpass = this.MinimumSequenceLength - 1;
|
|
else if (longestMatchDistance < 128 && testedSequenceDistance >= 128)
|
|
lengthToSurpass = longestMatchLength + (longestMatchLength >>> 1);
|
|
else
|
|
lengthToSurpass = longestMatchLength;
|
|
if (testedSequenceDistance > this.MaximumMatchDistance ||
|
|
lengthToSurpass >= this.MaximumSequenceLength ||
|
|
matchedSequencePosition + lengthToSurpass >= input.length)
|
|
break;
|
|
if (input[testedSequencePosition + lengthToSurpass] !== input[matchedSequencePosition + lengthToSurpass])
|
|
continue;
|
|
for (var offset = 0;; offset++) {
|
|
if (matchedSequencePosition + offset === input.length ||
|
|
input[testedSequencePosition + offset] !== input[matchedSequencePosition + offset]) {
|
|
if (offset > lengthToSurpass) {
|
|
longestMatchDistance = testedSequenceDistance;
|
|
longestMatchLength = offset;
|
|
}
|
|
break;
|
|
}
|
|
else if (offset === this.MaximumSequenceLength)
|
|
return { distance: testedSequenceDistance, length: this.MaximumSequenceLength };
|
|
}
|
|
}
|
|
if (longestMatchDistance !== undefined)
|
|
return { distance: longestMatchDistance, length: longestMatchLength };
|
|
else
|
|
return null;
|
|
};
|
|
Compressor.prototype.getBucketIndexForPrefix = function (startPosition) {
|
|
return (this.inputBuffer[startPosition] * 7880599 +
|
|
this.inputBuffer[startPosition + 1] * 39601 +
|
|
this.inputBuffer[startPosition + 2] * 199 +
|
|
this.inputBuffer[startPosition + 3]) % this.PrefixHashTableSize;
|
|
};
|
|
Compressor.prototype.outputPointerBytes = function (length, distance) {
|
|
if (distance < 128) {
|
|
this.outputRawByte(192 | length);
|
|
this.outputRawByte(distance);
|
|
}
|
|
else {
|
|
this.outputRawByte(224 | length);
|
|
this.outputRawByte(distance >>> 8);
|
|
this.outputRawByte(distance & 255);
|
|
}
|
|
};
|
|
Compressor.prototype.outputRawByte = function (value) {
|
|
this.outputBuffer[this.outputBufferPosition++] = value;
|
|
};
|
|
Compressor.prototype.cropAndAddNewBytesToInputBuffer = function (newInput) {
|
|
if (this.inputBuffer === undefined) {
|
|
this.inputBuffer = newInput;
|
|
return 0;
|
|
}
|
|
else {
|
|
var cropLength = Math.min(this.inputBuffer.length, this.MaximumMatchDistance);
|
|
var cropStartOffset = this.inputBuffer.length - cropLength;
|
|
this.inputBuffer = LZUTF8.CompressionCommon.getCroppedAndAppendedByteArray(this.inputBuffer, cropStartOffset, cropLength, newInput);
|
|
this.inputBufferStreamOffset += cropStartOffset;
|
|
return cropLength;
|
|
}
|
|
};
|
|
return Compressor;
|
|
}());
|
|
LZUTF8.Compressor = Compressor;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var CompressorCustomHashTable = (function () {
|
|
function CompressorCustomHashTable(bucketCount) {
|
|
this.minimumBucketCapacity = 4;
|
|
this.maximumBucketCapacity = 64;
|
|
this.bucketLocators = new Uint32Array(bucketCount * 2);
|
|
this.storage = new Uint32Array(bucketCount * 2);
|
|
this.storageIndex = 1;
|
|
}
|
|
CompressorCustomHashTable.prototype.addValueToBucket = function (bucketIndex, valueToAdd) {
|
|
bucketIndex <<= 1;
|
|
if (this.storageIndex >= (this.storage.length >>> 1))
|
|
this.compact();
|
|
var startPosition = this.bucketLocators[bucketIndex];
|
|
var length;
|
|
if (startPosition === 0) {
|
|
startPosition = this.storageIndex;
|
|
length = 1;
|
|
this.storage[this.storageIndex] = valueToAdd;
|
|
this.storageIndex += this.minimumBucketCapacity;
|
|
}
|
|
else {
|
|
length = this.bucketLocators[bucketIndex + 1];
|
|
if (length === this.maximumBucketCapacity - 1)
|
|
length = this.truncateBucketToNewerElements(startPosition, length, this.maximumBucketCapacity / 2);
|
|
var endPosition = startPosition + length;
|
|
if (this.storage[endPosition] === 0) {
|
|
this.storage[endPosition] = valueToAdd;
|
|
if (endPosition === this.storageIndex)
|
|
this.storageIndex += length;
|
|
}
|
|
else {
|
|
LZUTF8.ArrayTools.copyElements(this.storage, startPosition, this.storage, this.storageIndex, length);
|
|
startPosition = this.storageIndex;
|
|
this.storageIndex += length;
|
|
this.storage[this.storageIndex++] = valueToAdd;
|
|
this.storageIndex += length;
|
|
}
|
|
length++;
|
|
}
|
|
this.bucketLocators[bucketIndex] = startPosition;
|
|
this.bucketLocators[bucketIndex + 1] = length;
|
|
};
|
|
CompressorCustomHashTable.prototype.truncateBucketToNewerElements = function (startPosition, bucketLength, truncatedBucketLength) {
|
|
var sourcePosition = startPosition + bucketLength - truncatedBucketLength;
|
|
LZUTF8.ArrayTools.copyElements(this.storage, sourcePosition, this.storage, startPosition, truncatedBucketLength);
|
|
LZUTF8.ArrayTools.zeroElements(this.storage, startPosition + truncatedBucketLength, bucketLength - truncatedBucketLength);
|
|
return truncatedBucketLength;
|
|
};
|
|
CompressorCustomHashTable.prototype.compact = function () {
|
|
var oldBucketLocators = this.bucketLocators;
|
|
var oldStorage = this.storage;
|
|
this.bucketLocators = new Uint32Array(this.bucketLocators.length);
|
|
this.storageIndex = 1;
|
|
for (var bucketIndex = 0; bucketIndex < oldBucketLocators.length; bucketIndex += 2) {
|
|
var length_3 = oldBucketLocators[bucketIndex + 1];
|
|
if (length_3 === 0)
|
|
continue;
|
|
this.bucketLocators[bucketIndex] = this.storageIndex;
|
|
this.bucketLocators[bucketIndex + 1] = length_3;
|
|
this.storageIndex += Math.max(Math.min(length_3 * 2, this.maximumBucketCapacity), this.minimumBucketCapacity);
|
|
}
|
|
this.storage = new Uint32Array(this.storageIndex * 8);
|
|
for (var bucketIndex = 0; bucketIndex < oldBucketLocators.length; bucketIndex += 2) {
|
|
var sourcePosition = oldBucketLocators[bucketIndex];
|
|
if (sourcePosition === 0)
|
|
continue;
|
|
var destPosition = this.bucketLocators[bucketIndex];
|
|
var length_4 = this.bucketLocators[bucketIndex + 1];
|
|
LZUTF8.ArrayTools.copyElements(oldStorage, sourcePosition, this.storage, destPosition, length_4);
|
|
}
|
|
};
|
|
CompressorCustomHashTable.prototype.getArraySegmentForBucketIndex = function (bucketIndex, outputObject) {
|
|
bucketIndex <<= 1;
|
|
var startPosition = this.bucketLocators[bucketIndex];
|
|
if (startPosition === 0)
|
|
return null;
|
|
if (outputObject === undefined)
|
|
outputObject = new LZUTF8.ArraySegment(this.storage, startPosition, this.bucketLocators[bucketIndex + 1]);
|
|
return outputObject;
|
|
};
|
|
CompressorCustomHashTable.prototype.getUsedBucketCount = function () {
|
|
return Math.floor(LZUTF8.ArrayTools.countNonzeroValuesInArray(this.bucketLocators) / 2);
|
|
};
|
|
CompressorCustomHashTable.prototype.getTotalElementCount = function () {
|
|
var result = 0;
|
|
for (var i = 0; i < this.bucketLocators.length; i += 2)
|
|
result += this.bucketLocators[i + 1];
|
|
return result;
|
|
};
|
|
return CompressorCustomHashTable;
|
|
}());
|
|
LZUTF8.CompressorCustomHashTable = CompressorCustomHashTable;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var CompressorSimpleHashTable = (function () {
|
|
function CompressorSimpleHashTable(size) {
|
|
this.maximumBucketCapacity = 64;
|
|
this.buckets = new Array(size);
|
|
}
|
|
CompressorSimpleHashTable.prototype.addValueToBucket = function (bucketIndex, valueToAdd) {
|
|
var bucket = this.buckets[bucketIndex];
|
|
if (bucket === undefined) {
|
|
this.buckets[bucketIndex] = [valueToAdd];
|
|
}
|
|
else {
|
|
if (bucket.length === this.maximumBucketCapacity - 1)
|
|
LZUTF8.ArrayTools.truncateStartingElements(bucket, this.maximumBucketCapacity / 2);
|
|
bucket.push(valueToAdd);
|
|
}
|
|
};
|
|
CompressorSimpleHashTable.prototype.getArraySegmentForBucketIndex = function (bucketIndex, outputObject) {
|
|
var bucket = this.buckets[bucketIndex];
|
|
if (bucket === undefined)
|
|
return null;
|
|
if (outputObject === undefined)
|
|
outputObject = new LZUTF8.ArraySegment(bucket, 0, bucket.length);
|
|
return outputObject;
|
|
};
|
|
CompressorSimpleHashTable.prototype.getUsedBucketCount = function () {
|
|
return LZUTF8.ArrayTools.countNonzeroValuesInArray(this.buckets);
|
|
};
|
|
CompressorSimpleHashTable.prototype.getTotalElementCount = function () {
|
|
var currentSum = 0;
|
|
for (var i = 0; i < this.buckets.length; i++) {
|
|
if (this.buckets[i] !== undefined)
|
|
currentSum += this.buckets[i].length;
|
|
}
|
|
return currentSum;
|
|
};
|
|
return CompressorSimpleHashTable;
|
|
}());
|
|
LZUTF8.CompressorSimpleHashTable = CompressorSimpleHashTable;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Decompressor = (function () {
|
|
function Decompressor() {
|
|
this.MaximumMatchDistance = 32767;
|
|
this.outputPosition = 0;
|
|
}
|
|
Decompressor.prototype.decompressBlockToString = function (input) {
|
|
input = LZUTF8.BufferTools.convertToUint8ArrayIfNeeded(input);
|
|
return LZUTF8.decodeUTF8(this.decompressBlock(input));
|
|
};
|
|
Decompressor.prototype.decompressBlock = function (input) {
|
|
if (this.inputBufferRemainder) {
|
|
input = LZUTF8.ArrayTools.concatUint8Arrays([this.inputBufferRemainder, input]);
|
|
this.inputBufferRemainder = undefined;
|
|
}
|
|
var outputStartPosition = this.cropOutputBufferToWindowAndInitialize(Math.max(input.length * 4, 1024));
|
|
for (var readPosition = 0, inputLength = input.length; readPosition < inputLength; readPosition++) {
|
|
var inputValue = input[readPosition];
|
|
if (inputValue >>> 6 != 3) {
|
|
this.outputByte(inputValue);
|
|
continue;
|
|
}
|
|
var sequenceLengthIdentifier = inputValue >>> 5;
|
|
if (readPosition == inputLength - 1 ||
|
|
(readPosition == inputLength - 2 && sequenceLengthIdentifier == 7)) {
|
|
this.inputBufferRemainder = input.subarray(readPosition);
|
|
break;
|
|
}
|
|
if (input[readPosition + 1] >>> 7 === 1) {
|
|
this.outputByte(inputValue);
|
|
}
|
|
else {
|
|
var matchLength = inputValue & 31;
|
|
var matchDistance = void 0;
|
|
if (sequenceLengthIdentifier == 6) {
|
|
matchDistance = input[readPosition + 1];
|
|
readPosition += 1;
|
|
}
|
|
else {
|
|
matchDistance = (input[readPosition + 1] << 8) | (input[readPosition + 2]);
|
|
readPosition += 2;
|
|
}
|
|
var matchPosition = this.outputPosition - matchDistance;
|
|
for (var offset = 0; offset < matchLength; offset++)
|
|
this.outputByte(this.outputBuffer[matchPosition + offset]);
|
|
}
|
|
}
|
|
this.rollBackIfOutputBufferEndsWithATruncatedMultibyteSequence();
|
|
return LZUTF8.CompressionCommon.getCroppedBuffer(this.outputBuffer, outputStartPosition, this.outputPosition - outputStartPosition);
|
|
};
|
|
Decompressor.prototype.outputByte = function (value) {
|
|
if (this.outputPosition === this.outputBuffer.length)
|
|
this.outputBuffer = LZUTF8.ArrayTools.doubleByteArrayCapacity(this.outputBuffer);
|
|
this.outputBuffer[this.outputPosition++] = value;
|
|
};
|
|
Decompressor.prototype.cropOutputBufferToWindowAndInitialize = function (initialCapacity) {
|
|
if (!this.outputBuffer) {
|
|
this.outputBuffer = new Uint8Array(initialCapacity);
|
|
return 0;
|
|
}
|
|
var cropLength = Math.min(this.outputPosition, this.MaximumMatchDistance);
|
|
this.outputBuffer = LZUTF8.CompressionCommon.getCroppedBuffer(this.outputBuffer, this.outputPosition - cropLength, cropLength, initialCapacity);
|
|
this.outputPosition = cropLength;
|
|
if (this.outputBufferRemainder) {
|
|
for (var i = 0; i < this.outputBufferRemainder.length; i++)
|
|
this.outputByte(this.outputBufferRemainder[i]);
|
|
this.outputBufferRemainder = undefined;
|
|
}
|
|
return cropLength;
|
|
};
|
|
Decompressor.prototype.rollBackIfOutputBufferEndsWithATruncatedMultibyteSequence = function () {
|
|
for (var offset = 1; offset <= 4 && this.outputPosition - offset >= 0; offset++) {
|
|
var value = this.outputBuffer[this.outputPosition - offset];
|
|
if ((offset < 4 && (value >>> 3) === 30) ||
|
|
(offset < 3 && (value >>> 4) === 14) ||
|
|
(offset < 2 && (value >>> 5) === 6)) {
|
|
this.outputBufferRemainder = this.outputBuffer.subarray(this.outputPosition - offset, this.outputPosition);
|
|
this.outputPosition -= offset;
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
return Decompressor;
|
|
}());
|
|
LZUTF8.Decompressor = Decompressor;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Encoding;
|
|
(function (Encoding) {
|
|
var Base64;
|
|
(function (Base64) {
|
|
var charCodeMap = new Uint8Array([65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47]);
|
|
var reverseCharCodeMap = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255]);
|
|
var paddingCharacter = "=";
|
|
var paddingCharCode = 61;
|
|
Base64.encode = function (inputBytes) {
|
|
if (!inputBytes || inputBytes.length == 0)
|
|
return "";
|
|
if (LZUTF8.runningInNodeJS()) {
|
|
return (LZUTF8.BufferTools.uint8ArrayToBuffer(inputBytes)).toString("base64");
|
|
}
|
|
else {
|
|
return Base64.encodeWithJS(inputBytes);
|
|
}
|
|
};
|
|
Base64.decode = function (base64String) {
|
|
if (!base64String)
|
|
return new Uint8Array(0);
|
|
if (LZUTF8.runningInNodeJS()) {
|
|
return LZUTF8.BufferTools.bufferToUint8Array(Buffer.from(base64String, "base64"));
|
|
}
|
|
else {
|
|
return Base64.decodeWithJS(base64String);
|
|
}
|
|
};
|
|
Base64.encodeWithJS = function (inputBytes, addPadding) {
|
|
if (addPadding === void 0) { addPadding = true; }
|
|
if (!inputBytes || inputBytes.length == 0)
|
|
return "";
|
|
var map = charCodeMap;
|
|
var output = new LZUTF8.StringBuilder();
|
|
var uint24;
|
|
for (var readPosition = 0, length_5 = inputBytes.length; readPosition < length_5; readPosition += 3) {
|
|
if (readPosition <= length_5 - 3) {
|
|
uint24 = inputBytes[readPosition] << 16 | inputBytes[readPosition + 1] << 8 | inputBytes[readPosition + 2];
|
|
output.appendCharCode(map[(uint24 >>> 18) & 63]);
|
|
output.appendCharCode(map[(uint24 >>> 12) & 63]);
|
|
output.appendCharCode(map[(uint24 >>> 6) & 63]);
|
|
output.appendCharCode(map[(uint24) & 63]);
|
|
uint24 = 0;
|
|
}
|
|
else if (readPosition === length_5 - 2) {
|
|
uint24 = inputBytes[readPosition] << 16 | inputBytes[readPosition + 1] << 8;
|
|
output.appendCharCode(map[(uint24 >>> 18) & 63]);
|
|
output.appendCharCode(map[(uint24 >>> 12) & 63]);
|
|
output.appendCharCode(map[(uint24 >>> 6) & 63]);
|
|
if (addPadding)
|
|
output.appendCharCode(paddingCharCode);
|
|
}
|
|
else if (readPosition === length_5 - 1) {
|
|
uint24 = inputBytes[readPosition] << 16;
|
|
output.appendCharCode(map[(uint24 >>> 18) & 63]);
|
|
output.appendCharCode(map[(uint24 >>> 12) & 63]);
|
|
if (addPadding) {
|
|
output.appendCharCode(paddingCharCode);
|
|
output.appendCharCode(paddingCharCode);
|
|
}
|
|
}
|
|
}
|
|
return output.getOutputString();
|
|
};
|
|
Base64.decodeWithJS = function (base64String, outputBuffer) {
|
|
if (!base64String || base64String.length == 0)
|
|
return new Uint8Array(0);
|
|
var lengthModulo4 = base64String.length % 4;
|
|
if (lengthModulo4 === 1)
|
|
throw new Error("Invalid Base64 string: length % 4 == 1");
|
|
else if (lengthModulo4 === 2)
|
|
base64String += paddingCharacter + paddingCharacter;
|
|
else if (lengthModulo4 === 3)
|
|
base64String += paddingCharacter;
|
|
if (!outputBuffer)
|
|
outputBuffer = new Uint8Array(base64String.length);
|
|
var outputPosition = 0;
|
|
var length = base64String.length;
|
|
for (var i = 0; i < length; i += 4) {
|
|
var uint24 = (reverseCharCodeMap[base64String.charCodeAt(i)] << 18) |
|
|
(reverseCharCodeMap[base64String.charCodeAt(i + 1)] << 12) |
|
|
(reverseCharCodeMap[base64String.charCodeAt(i + 2)] << 6) |
|
|
(reverseCharCodeMap[base64String.charCodeAt(i + 3)]);
|
|
outputBuffer[outputPosition++] = (uint24 >>> 16) & 255;
|
|
outputBuffer[outputPosition++] = (uint24 >>> 8) & 255;
|
|
outputBuffer[outputPosition++] = (uint24) & 255;
|
|
}
|
|
if (base64String.charCodeAt(length - 1) == paddingCharCode)
|
|
outputPosition--;
|
|
if (base64String.charCodeAt(length - 2) == paddingCharCode)
|
|
outputPosition--;
|
|
return outputBuffer.subarray(0, outputPosition);
|
|
};
|
|
})(Base64 = Encoding.Base64 || (Encoding.Base64 = {}));
|
|
})(Encoding = LZUTF8.Encoding || (LZUTF8.Encoding = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Encoding;
|
|
(function (Encoding) {
|
|
var BinaryString;
|
|
(function (BinaryString) {
|
|
BinaryString.encode = function (input) {
|
|
if (input == null)
|
|
throw new TypeError("BinaryString.encode: undefined or null input received");
|
|
if (input.length === 0)
|
|
return "";
|
|
var inputLength = input.length;
|
|
var outputStringBuilder = new LZUTF8.StringBuilder();
|
|
var remainder = 0;
|
|
var state = 1;
|
|
for (var i = 0; i < inputLength; i += 2) {
|
|
var value = void 0;
|
|
if (i == inputLength - 1)
|
|
value = (input[i] << 8);
|
|
else
|
|
value = (input[i] << 8) | input[i + 1];
|
|
outputStringBuilder.appendCharCode((remainder << (16 - state)) | value >>> state);
|
|
remainder = value & ((1 << state) - 1);
|
|
if (state === 15) {
|
|
outputStringBuilder.appendCharCode(remainder);
|
|
remainder = 0;
|
|
state = 1;
|
|
}
|
|
else {
|
|
state += 1;
|
|
}
|
|
if (i >= inputLength - 2)
|
|
outputStringBuilder.appendCharCode(remainder << (16 - state));
|
|
}
|
|
outputStringBuilder.appendCharCode(32768 | (inputLength % 2));
|
|
return outputStringBuilder.getOutputString();
|
|
};
|
|
BinaryString.decode = function (input) {
|
|
if (typeof input !== "string")
|
|
throw new TypeError("BinaryString.decode: invalid input type");
|
|
if (input == "")
|
|
return new Uint8Array(0);
|
|
var output = new Uint8Array(input.length * 3);
|
|
var outputPosition = 0;
|
|
var appendToOutput = function (value) {
|
|
output[outputPosition++] = value >>> 8;
|
|
output[outputPosition++] = value & 255;
|
|
};
|
|
var remainder = 0;
|
|
var state = 0;
|
|
for (var i = 0; i < input.length; i++) {
|
|
var value = input.charCodeAt(i);
|
|
if (value >= 32768) {
|
|
if (value == (32768 | 1))
|
|
outputPosition--;
|
|
state = 0;
|
|
continue;
|
|
}
|
|
if (state == 0) {
|
|
remainder = value;
|
|
}
|
|
else {
|
|
appendToOutput((remainder << state) | (value >>> (15 - state)));
|
|
remainder = value & ((1 << (15 - state)) - 1);
|
|
}
|
|
if (state == 15)
|
|
state = 0;
|
|
else
|
|
state += 1;
|
|
}
|
|
return output.subarray(0, outputPosition);
|
|
};
|
|
})(BinaryString = Encoding.BinaryString || (Encoding.BinaryString = {}));
|
|
})(Encoding = LZUTF8.Encoding || (LZUTF8.Encoding = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Encoding;
|
|
(function (Encoding) {
|
|
var CodePoint;
|
|
(function (CodePoint) {
|
|
CodePoint.encodeFromString = function (str, position) {
|
|
var charCode = str.charCodeAt(position);
|
|
if (charCode < 0xD800 || charCode > 0xDBFF)
|
|
return charCode;
|
|
else {
|
|
var nextCharCode = str.charCodeAt(position + 1);
|
|
if (nextCharCode >= 0xDC00 && nextCharCode <= 0xDFFF)
|
|
return 0x10000 + (((charCode - 0xD800) << 10) + (nextCharCode - 0xDC00));
|
|
else
|
|
throw new Error("getUnicodeCodePoint: Received a lead surrogate character, char code ".concat(charCode, ", followed by ").concat(nextCharCode, ", which is not a trailing surrogate character code."));
|
|
}
|
|
};
|
|
CodePoint.decodeToString = function (codePoint) {
|
|
if (codePoint <= 0xFFFF)
|
|
return String.fromCharCode(codePoint);
|
|
else if (codePoint <= 0x10FFFF)
|
|
return String.fromCharCode(0xD800 + ((codePoint - 0x10000) >>> 10), 0xDC00 + ((codePoint - 0x10000) & 1023));
|
|
else
|
|
throw new Error("getStringFromUnicodeCodePoint: A code point of ".concat(codePoint, " cannot be encoded in UTF-16"));
|
|
};
|
|
})(CodePoint = Encoding.CodePoint || (Encoding.CodePoint = {}));
|
|
})(Encoding = LZUTF8.Encoding || (LZUTF8.Encoding = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Encoding;
|
|
(function (Encoding) {
|
|
var DecimalString;
|
|
(function (DecimalString) {
|
|
var lookupTable = ["000", "001", "002", "003", "004", "005", "006", "007", "008", "009", "010", "011", "012", "013", "014", "015", "016", "017", "018", "019", "020", "021", "022", "023", "024", "025", "026", "027", "028", "029", "030", "031", "032", "033", "034", "035", "036", "037", "038", "039", "040", "041", "042", "043", "044", "045", "046", "047", "048", "049", "050", "051", "052", "053", "054", "055", "056", "057", "058", "059", "060", "061", "062", "063", "064", "065", "066", "067", "068", "069", "070", "071", "072", "073", "074", "075", "076", "077", "078", "079", "080", "081", "082", "083", "084", "085", "086", "087", "088", "089", "090", "091", "092", "093", "094", "095", "096", "097", "098", "099", "100", "101", "102", "103", "104", "105", "106", "107", "108", "109", "110", "111", "112", "113", "114", "115", "116", "117", "118", "119", "120", "121", "122", "123", "124", "125", "126", "127", "128", "129", "130", "131", "132", "133", "134", "135", "136", "137", "138", "139", "140", "141", "142", "143", "144", "145", "146", "147", "148", "149", "150", "151", "152", "153", "154", "155", "156", "157", "158", "159", "160", "161", "162", "163", "164", "165", "166", "167", "168", "169", "170", "171", "172", "173", "174", "175", "176", "177", "178", "179", "180", "181", "182", "183", "184", "185", "186", "187", "188", "189", "190", "191", "192", "193", "194", "195", "196", "197", "198", "199", "200", "201", "202", "203", "204", "205", "206", "207", "208", "209", "210", "211", "212", "213", "214", "215", "216", "217", "218", "219", "220", "221", "222", "223", "224", "225", "226", "227", "228", "229", "230", "231", "232", "233", "234", "235", "236", "237", "238", "239", "240", "241", "242", "243", "244", "245", "246", "247", "248", "249", "250", "251", "252", "253", "254", "255"];
|
|
DecimalString.encode = function (binaryBytes) {
|
|
var resultArray = [];
|
|
for (var i = 0; i < binaryBytes.length; i++)
|
|
resultArray.push(lookupTable[binaryBytes[i]]);
|
|
return resultArray.join(" ");
|
|
};
|
|
})(DecimalString = Encoding.DecimalString || (Encoding.DecimalString = {}));
|
|
})(Encoding = LZUTF8.Encoding || (LZUTF8.Encoding = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Encoding;
|
|
(function (Encoding) {
|
|
var StorageBinaryString;
|
|
(function (StorageBinaryString) {
|
|
StorageBinaryString.encode = function (input) {
|
|
return Encoding.BinaryString.encode(input).replace(/\0/g, '\u8002');
|
|
};
|
|
StorageBinaryString.decode = function (input) {
|
|
return Encoding.BinaryString.decode(input.replace(/\u8002/g, '\0'));
|
|
};
|
|
})(StorageBinaryString = Encoding.StorageBinaryString || (Encoding.StorageBinaryString = {}));
|
|
})(Encoding = LZUTF8.Encoding || (LZUTF8.Encoding = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
var Encoding;
|
|
(function (Encoding) {
|
|
var UTF8;
|
|
(function (UTF8) {
|
|
var nativeTextEncoder;
|
|
var nativeTextDecoder;
|
|
UTF8.encode = function (str) {
|
|
if (!str || str.length == 0)
|
|
return new Uint8Array(0);
|
|
if (LZUTF8.runningInNodeJS()) {
|
|
return LZUTF8.BufferTools.bufferToUint8Array(Buffer.from(str, "utf8"));
|
|
}
|
|
else if (UTF8.createNativeTextEncoderAndDecoderIfAvailable()) {
|
|
return nativeTextEncoder.encode(str);
|
|
}
|
|
else {
|
|
return UTF8.encodeWithJS(str);
|
|
}
|
|
};
|
|
UTF8.decode = function (utf8Bytes) {
|
|
if (!utf8Bytes || utf8Bytes.length == 0)
|
|
return "";
|
|
if (LZUTF8.runningInNodeJS()) {
|
|
return LZUTF8.BufferTools.uint8ArrayToBuffer(utf8Bytes).toString("utf8");
|
|
}
|
|
else if (UTF8.createNativeTextEncoderAndDecoderIfAvailable()) {
|
|
return nativeTextDecoder.decode(utf8Bytes);
|
|
}
|
|
else {
|
|
return UTF8.decodeWithJS(utf8Bytes);
|
|
}
|
|
};
|
|
UTF8.encodeWithJS = function (str, outputArray) {
|
|
if (!str || str.length == 0)
|
|
return new Uint8Array(0);
|
|
if (!outputArray)
|
|
outputArray = new Uint8Array(str.length * 4);
|
|
var writeIndex = 0;
|
|
for (var readIndex = 0; readIndex < str.length; readIndex++) {
|
|
var charCode = Encoding.CodePoint.encodeFromString(str, readIndex);
|
|
if (charCode <= 0x7F) {
|
|
outputArray[writeIndex++] = charCode;
|
|
}
|
|
else if (charCode <= 0x7FF) {
|
|
outputArray[writeIndex++] = 0xC0 | (charCode >>> 6);
|
|
outputArray[writeIndex++] = 0x80 | (charCode & 63);
|
|
}
|
|
else if (charCode <= 0xFFFF) {
|
|
outputArray[writeIndex++] = 0xE0 | (charCode >>> 12);
|
|
outputArray[writeIndex++] = 0x80 | ((charCode >>> 6) & 63);
|
|
outputArray[writeIndex++] = 0x80 | (charCode & 63);
|
|
}
|
|
else if (charCode <= 0x10FFFF) {
|
|
outputArray[writeIndex++] = 0xF0 | (charCode >>> 18);
|
|
outputArray[writeIndex++] = 0x80 | ((charCode >>> 12) & 63);
|
|
outputArray[writeIndex++] = 0x80 | ((charCode >>> 6) & 63);
|
|
outputArray[writeIndex++] = 0x80 | (charCode & 63);
|
|
readIndex++;
|
|
}
|
|
else
|
|
throw new Error("Invalid UTF-16 string: Encountered a character unsupported by UTF-8/16 (RFC 3629)");
|
|
}
|
|
return outputArray.subarray(0, writeIndex);
|
|
};
|
|
UTF8.decodeWithJS = function (utf8Bytes, startOffset, endOffset) {
|
|
if (startOffset === void 0) { startOffset = 0; }
|
|
if (!utf8Bytes || utf8Bytes.length == 0)
|
|
return "";
|
|
if (endOffset === undefined)
|
|
endOffset = utf8Bytes.length;
|
|
var output = new LZUTF8.StringBuilder();
|
|
var outputCodePoint;
|
|
var leadByte;
|
|
for (var readIndex = startOffset, length_6 = endOffset; readIndex < length_6;) {
|
|
leadByte = utf8Bytes[readIndex];
|
|
if ((leadByte >>> 7) === 0) {
|
|
outputCodePoint = leadByte;
|
|
readIndex += 1;
|
|
}
|
|
else if ((leadByte >>> 5) === 6) {
|
|
if (readIndex + 1 >= endOffset)
|
|
throw new Error("Invalid UTF-8 stream: Truncated codepoint sequence encountered at position " + readIndex);
|
|
outputCodePoint = ((leadByte & 31) << 6) | (utf8Bytes[readIndex + 1] & 63);
|
|
readIndex += 2;
|
|
}
|
|
else if ((leadByte >>> 4) === 14) {
|
|
if (readIndex + 2 >= endOffset)
|
|
throw new Error("Invalid UTF-8 stream: Truncated codepoint sequence encountered at position " + readIndex);
|
|
outputCodePoint = ((leadByte & 15) << 12) | ((utf8Bytes[readIndex + 1] & 63) << 6) | (utf8Bytes[readIndex + 2] & 63);
|
|
readIndex += 3;
|
|
}
|
|
else if ((leadByte >>> 3) === 30) {
|
|
if (readIndex + 3 >= endOffset)
|
|
throw new Error("Invalid UTF-8 stream: Truncated codepoint sequence encountered at position " + readIndex);
|
|
outputCodePoint = ((leadByte & 7) << 18) | ((utf8Bytes[readIndex + 1] & 63) << 12) | ((utf8Bytes[readIndex + 2] & 63) << 6) | (utf8Bytes[readIndex + 3] & 63);
|
|
readIndex += 4;
|
|
}
|
|
else
|
|
throw new Error("Invalid UTF-8 stream: An invalid lead byte value encountered at position " + readIndex);
|
|
output.appendCodePoint(outputCodePoint);
|
|
}
|
|
return output.getOutputString();
|
|
};
|
|
UTF8.createNativeTextEncoderAndDecoderIfAvailable = function () {
|
|
if (nativeTextEncoder)
|
|
return true;
|
|
if (typeof TextEncoder == "function") {
|
|
nativeTextEncoder = new TextEncoder("utf-8");
|
|
nativeTextDecoder = new TextDecoder("utf-8");
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
};
|
|
})(UTF8 = Encoding.UTF8 || (Encoding.UTF8 = {}));
|
|
})(Encoding = LZUTF8.Encoding || (LZUTF8.Encoding = {}));
|
|
})(LZUTF8 || (LZUTF8 = {}));
|
|
var LZUTF8;
|
|
(function (LZUTF8) {
|
|
function compress(input, options) {
|
|
if (options === void 0) { options = {}; }
|
|
if (input == null)
|
|
throw new TypeError("compress: undefined or null input received");
|
|
var inputEncoding = LZUTF8.CompressionCommon.detectCompressionSourceEncoding(input);
|
|
options = LZUTF8.ObjectTools.override({ inputEncoding: inputEncoding, outputEncoding: "ByteArray" }, options);
|
|
var compressor = new LZUTF8.Compressor();
|
|
var compressedBytes = compressor.compressBlock(input);
|
|
return LZUTF8.CompressionCommon.encodeCompressedBytes(compressedBytes, options.outputEncoding);
|
|
}
|
|
LZUTF8.compress = compress;
|
|
function decompress(input, options) {
|
|
if (options === void 0) { options = {}; }
|
|
if (input == null)
|
|
throw new TypeError("decompress: undefined or null input received");
|
|
options = LZUTF8.ObjectTools.override({ inputEncoding: "ByteArray", outputEncoding: "String" }, options);
|
|
var inputBytes = LZUTF8.CompressionCommon.decodeCompressedBytes(input, options.inputEncoding);
|
|
var decompressor = new LZUTF8.Decompressor();
|
|
var decompressedBytes = decompressor.decompressBlock(inputBytes);
|
|
return LZUTF8.CompressionCommon.encodeDecompressedBytes(decompressedBytes, options.outputEncoding);
|
|
}
|
|
LZUTF8.decompress = decompress;
|
|
function compressAsync(input, options, callback) {
|
|
if (callback == null)
|
|
callback = function () { };
|
|
var inputEncoding;
|
|
try {
|
|
inputEncoding = LZUTF8.CompressionCommon.detectCompressionSourceEncoding(input);
|
|
}
|
|
catch (e) {
|
|
callback(undefined, e);
|
|
return;
|
|
}
|
|
options = LZUTF8.ObjectTools.override({
|
|
inputEncoding: inputEncoding,
|
|
outputEncoding: "ByteArray",
|
|
useWebWorker: true,
|
|
blockSize: 65536
|
|
}, options);
|
|
LZUTF8.enqueueImmediate(function () {
|
|
if (options.useWebWorker && LZUTF8.WebWorker.createGlobalWorkerIfNeeded()) {
|
|
LZUTF8.WebWorker.compressAsync(input, options, callback);
|
|
}
|
|
else {
|
|
LZUTF8.AsyncCompressor.compressAsync(input, options, callback);
|
|
}
|
|
});
|
|
}
|
|
LZUTF8.compressAsync = compressAsync;
|
|
function decompressAsync(input, options, callback) {
|
|
if (callback == null)
|
|
callback = function () { };
|
|
if (input == null) {
|
|
callback(undefined, new TypeError("decompressAsync: undefined or null input received"));
|
|
return;
|
|
}
|
|
options = LZUTF8.ObjectTools.override({
|
|
inputEncoding: "ByteArray",
|
|
outputEncoding: "String",
|
|
useWebWorker: true,
|
|
blockSize: 65536
|
|
}, options);
|
|
var normalizedInput = LZUTF8.BufferTools.convertToUint8ArrayIfNeeded(input);
|
|
LZUTF8.EventLoop.enqueueImmediate(function () {
|
|
if (options.useWebWorker && LZUTF8.WebWorker.createGlobalWorkerIfNeeded()) {
|
|
LZUTF8.WebWorker.decompressAsync(normalizedInput, options, callback);
|
|
}
|
|
else {
|
|
LZUTF8.AsyncDecompressor.decompressAsync(input, options, callback);
|
|
}
|
|
});
|
|
}
|
|
LZUTF8.decompressAsync = decompressAsync;
|
|
function createCompressionStream() {
|
|
return LZUTF8.AsyncCompressor.createCompressionStream();
|
|
}
|
|
LZUTF8.createCompressionStream = createCompressionStream;
|
|
function createDecompressionStream() {
|
|
return LZUTF8.AsyncDecompressor.createDecompressionStream();
|
|
}
|
|
LZUTF8.createDecompressionStream = createDecompressionStream;
|
|
function encodeUTF8(str) {
|
|
return LZUTF8.Encoding.UTF8.encode(str);
|
|
}
|
|
LZUTF8.encodeUTF8 = encodeUTF8;
|
|
function decodeUTF8(input) {
|
|
return LZUTF8.Encoding.UTF8.decode(input);
|
|
}
|
|
LZUTF8.decodeUTF8 = decodeUTF8;
|
|
function encodeBase64(input) {
|
|
return LZUTF8.Encoding.Base64.encode(input);
|
|
}
|
|
LZUTF8.encodeBase64 = encodeBase64;
|
|
function decodeBase64(str) {
|
|
return LZUTF8.Encoding.Base64.decode(str);
|
|
}
|
|
LZUTF8.decodeBase64 = decodeBase64;
|
|
function encodeBinaryString(input) {
|
|
return LZUTF8.Encoding.BinaryString.encode(input);
|
|
}
|
|
LZUTF8.encodeBinaryString = encodeBinaryString;
|
|
function decodeBinaryString(str) {
|
|
return LZUTF8.Encoding.BinaryString.decode(str);
|
|
}
|
|
LZUTF8.decodeBinaryString = decodeBinaryString;
|
|
function encodeStorageBinaryString(input) {
|
|
return LZUTF8.Encoding.StorageBinaryString.encode(input);
|
|
}
|
|
LZUTF8.encodeStorageBinaryString = encodeStorageBinaryString;
|
|
function decodeStorageBinaryString(str) {
|
|
return LZUTF8.Encoding.StorageBinaryString.decode(str);
|
|
}
|
|
LZUTF8.decodeStorageBinaryString = decodeStorageBinaryString;
|
|
})(LZUTF8 || (LZUTF8 = {}));
|