ts-client-lib 0.0.7

package/utils/TSDate.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSDate = void 0;
+var TSString_1 = require("./TSString");
+var TSDate = /** @class */ (function () {
+    function TSDate() {
+    }
+    TSDate.utc = function (type, data, set) {
+        if (['Milliseconds', 'Seconds', 'Minutes', 'Hours', 'Date', 'Month', 'FullYear'].indexOf(type) === -1) {
+            throw Error("[TSDate::utc] Type (".concat(type, ") not supported."));
+        }
+        var date = new Date();
+        var anyDate = date;
+        if (set) {
+            anyDate['setUTC' + type].apply(anyDate, set);
+        }
+        anyDate['setUTC' + type](anyDate['getUTC' + type]() + data);
+        return date;
+    };
+    TSDate.key = function (max, date) {
+        if (max === void 0) { max = 12; }
+        if (date === void 0) { date = new Date(); }
+        return date.toISOString().replace(/[^0-9]/g, '').substring(0, max);
+    };
+    TSDate.parse = function (date, data, set) {
+        if (data === void 0) { data = 0; }
+        if (set === void 0) { set = [24, 0, 0, 0]; }
+        var dts = Date.parse(date);
+        if (isNaN(dts)) {
+            return TSDate.utc('Hours', data, set).toISOString();
+        }
+        return new Date(date).toISOString();
+    };
+    TSDate.yyyymmddhhss = function (date) {
+        var parts = date.toString().match(/\d{2}/g);
+        if (!parts || parts.length < 6) {
+            return new Date(NaN);
+        }
+        var y1 = parts[0], y2 = parts[1], m = parts[2], d = parts[3], h = parts[4], mm = parts[5];
+        return new Date("".concat(y1).concat(y2, "-").concat(m, "-").concat(d, "T").concat(h, ":").concat(mm, ":00.000Z"));
+    };
+    TSDate.format = function (timestamp, format, cb) {
+        if (timestamp === void 0) { timestamp = Date.now(); }
+        var d = new Date(timestamp), _a = d.toUTCString().split(/[\s+,:]+/), day = _a[0], date = _a[1], month = _a[2], year = _a[3], hours = _a[4], minutes = _a[5], seconds = _a[6], timezone = _a[7], data = { day: day, date: date, month: month, year: year, hours: hours, minutes: minutes, seconds: seconds, timezone: timezone };
+        data['_'] = d;
+        return TSString_1.TSString.parseAndReplace(format, cb ? cb(data) : data);
+    };
+    TSDate.timer = function (milliseconds, format, cb) {
+        var data = {
+            days: function (t) { return t / (1000 * 60 * 60 * 24); },
+            hours: function (t) { return (t / (1000 * 60 * 60)) % 24; },
+            minutes: function (t) { return (t / 1000 / 60) % 60; },
+            seconds: function (t) { return (t / 1000) % 60; }
+        };
+        for (var p in data) {
+            if (Object.hasOwn(data, p)) {
+                var fn = data[p];
+                if (typeof fn === 'function') {
+                    data[p] = TSString_1.TSString.pad(Math.floor(fn(milliseconds)), 2, '0');
+                }
+            }
+        }
+        return TSString_1.TSString.parseAndReplace(format, cb ? cb(data) : data);
+    };
+    return TSDate;
+}());
+exports.TSDate = TSDate;

package/utils/TSHeuristic.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Class TSHeuristic - Holds static functions to deal with Heuristic
+ */
+export declare class TSHeuristic {
+    static levenshtein(str1: string, str2: string): number;
+    private static levenshteinStepRow;
+    static sift4(s1: string, s2: string, maxOffset: number, maxDistance?: number): number;
+    private static sift4OnMatch;
+    private static sift4OnMismatch;
+    /** Increment cursors, optional early exit when distance exceeds maxDistance, normalize at string end. */
+    private static sift4StepCursors;
+    /** Updates transposition bookkeeping when characters match. */
+    private static sift4ProcessOffsets;
+    /** Try nearby columns when current chars differ (Sift4 local search). */
+    private static sift4ShiftCursorsForNearMatch;
+    static getHeuristicDistance(s1?: string, s2?: string): number;
+    static distance(s1?: string, s2?: string): number;
+    static similarity(s1: string, s2: string): number;
+    static removeDiacritics(str: string): string;
+}

package/utils/TSHeuristic.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * Class TSHeuristic - Holds static functions to deal with Heuristic
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSHeuristic = void 0;
+var diacritics_removal_map_1 = require("./diacritics-removal-map");
+var TSHeuristic = /** @class */ (function () {
+    function TSHeuristic() {
+    }
+    TSHeuristic.levenshtein = function (str1, str2) {
+        // base cases
+        if (str1 === str2) {
+            return 0;
+        }
+        if (str1.length === 0) {
+            return str2.length;
+        }
+        if (str2.length === 0) {
+            return str1.length;
+        }
+        // two rows
+        var prevRow = new Array(str2.length + 1);
+        var nextCol = 0, i, j;
+        // initialise previous row
+        for (i = 0; i < prevRow.length; ++i) {
+            prevRow[i] = i;
+        }
+        // calculate current row distance from previous row
+        for (i = 0; i < str1.length; ++i) {
+            nextCol = i + 1;
+            for (j = 0; j < str2.length; ++j) {
+                nextCol = TSHeuristic.levenshteinStepRow(str1, str2, i, j, prevRow, nextCol);
+            }
+            prevRow[j] = nextCol;
+        }
+        return nextCol;
+    };
+    TSHeuristic.levenshteinStepRow = function (str1, str2, i, j, prevRow, nextCol) {
+        var curCol = nextCol;
+        var next = prevRow[j] + ((str1.charAt(i) === str2.charAt(j)) ? 0 : 1);
+        var tmp = curCol + 1;
+        if (next > tmp)
+            next = tmp;
+        tmp = prevRow[j + 1] + 1;
+        if (next > tmp)
+            next = tmp;
+        prevRow[j] = curCol;
+        return next;
+    };
+    TSHeuristic.sift4 = function (s1, s2, maxOffset, maxDistance) {
+        if (!s1 || !s1.length) {
+            if (!s2) {
+                return 0;
+            }
+            return s2.length;
+        }
+        if (!s2 || !s2.length) {
+            return s1.length;
+        }
+        var l1 = s1.length, l2 = s2.length;
+        var c1 = 0, c2 = 0;
+        var lcss = 0;
+        var local_cs = 0;
+        var trans = 0;
+        var offset_arr = [];
+        while ((c1 < l1) && (c2 < l2)) {
+            if (s1.charAt(c1) === s2.charAt(c2)) {
+                var m = TSHeuristic.sift4OnMatch(offset_arr, c1, c2, local_cs, trans);
+                local_cs = m.local_cs;
+                trans = m.trans;
+            }
+            else {
+                var mm = TSHeuristic.sift4OnMismatch(s1, s2, c1, c2, maxOffset, l1, l2, lcss, local_cs);
+                c1 = mm.c1;
+                c2 = mm.c2;
+                lcss = mm.lcss;
+                local_cs = mm.local_cs;
+            }
+            var stepped = TSHeuristic.sift4StepCursors(c1, c2, l1, l2, maxDistance, lcss, trans, local_cs);
+            c1 = stepped.c1;
+            c2 = stepped.c2;
+            lcss = stepped.lcss;
+            local_cs = stepped.local_cs;
+            if (stepped.earlyExit !== undefined)
+                return stepped.earlyExit;
+        }
+        lcss += local_cs;
+        return Math.round(Math.max(l1, l2) - lcss + trans);
+    };
+    TSHeuristic.sift4OnMatch = function (offset_arr, c1, c2, local_cs, trans) {
+        local_cs++;
+        var _a = TSHeuristic.sift4ProcessOffsets(offset_arr, c1, c2), nextTrans = _a.nextTrans, isTrans = _a.isTrans;
+        trans += nextTrans;
+        offset_arr.push({ c1: c1, c2: c2, trans: isTrans });
+        return { local_cs: local_cs, trans: trans };
+    };
+    TSHeuristic.sift4OnMismatch = function (s1, s2, c1, c2, maxOffset, l1, l2, lcss, local_cs) {
+        lcss += local_cs;
+        local_cs = 0;
+        if (c1 !== c2) {
+            c1 = c2 = Math.min(c1, c2);
+        }
+        var shifted = TSHeuristic.sift4ShiftCursorsForNearMatch(s1, s2, c1, c2, maxOffset, l1, l2);
+        c1 = shifted.c1;
+        c2 = shifted.c2;
+        return { c1: c1, c2: c2, lcss: lcss, local_cs: local_cs };
+    };
+    /** Increment cursors, optional early exit when distance exceeds maxDistance, normalize at string end. */
+    TSHeuristic.sift4StepCursors = function (c1, c2, l1, l2, maxDistance, lcss, trans, local_cs) {
+        c1++;
+        c2++;
+        if (maxDistance) {
+            var temporaryDistance = Math.max(c1, c2) - lcss + trans;
+            if (temporaryDistance >= maxDistance) {
+                return { c1: c1, c2: c2, lcss: lcss, local_cs: local_cs, earlyExit: Math.round(temporaryDistance) };
+            }
+        }
+        if ((c1 >= l1) || (c2 >= l2)) {
+            lcss += local_cs;
+            local_cs = 0;
+            c1 = c2 = Math.min(c1, c2);
+        }
+        return { c1: c1, c2: c2, lcss: lcss, local_cs: local_cs };
+    };
+    /** Updates transposition bookkeeping when characters match. */
+    TSHeuristic.sift4ProcessOffsets = function (offset_arr, c1, c2) {
+        var nextTrans = 0;
+        var isTrans = false;
+        var i = 0;
+        while (i < offset_arr.length) {
+            var ofs = offset_arr[i];
+            if (c1 <= ofs.c1 || c2 <= ofs.c2) {
+                isTrans = Math.abs(c2 - c1) >= Math.abs(ofs.c2 - ofs.c1);
+                if (isTrans) {
+                    nextTrans++;
+                }
+                else if (!ofs.trans) {
+                    ofs.trans = true;
+                    nextTrans++;
+                }
+                break;
+            }
+            if (c1 > ofs.c2 && c2 > ofs.c1) {
+                offset_arr.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+        return { nextTrans: nextTrans, isTrans: isTrans };
+    };
+    /** Try nearby columns when current chars differ (Sift4 local search). */
+    TSHeuristic.sift4ShiftCursorsForNearMatch = function (s1, s2, c1, c2, maxOffset, l1, l2) {
+        var nc1 = c1, nc2 = c2;
+        for (var i = 0; i < maxOffset && (c1 + i < l1 || c2 + i < l2); i++) {
+            if ((c1 + i < l1) && (s1.charAt(c1 + i) === s2.charAt(c2))) {
+                nc1 = c1 + i - 1;
+                nc2 = c2 - 1;
+                break;
+            }
+            if ((c2 + i < l2) && (s1.charAt(c1) === s2.charAt(c2 + i))) {
+                nc1 = c1 - 1;
+                nc2 = c2 + i - 1;
+                break;
+            }
+        }
+        return { c1: nc1, c2: nc2 };
+    };
+    TSHeuristic.getHeuristicDistance = function (s1, s2) {
+        if (s1 === void 0) { s1 = ''; }
+        if (s2 === void 0) { s2 = ''; }
+        var maxDistance = Math.floor(Math.max(s1.length, s2.length) / 2), approximateDistance = this.sift4(s1, s2, 5);
+        // if the distance is close, perform an exact computation
+        if (approximateDistance <= maxDistance) {
+            return this.levenshtein(s1, s2);
+        }
+        return approximateDistance;
+    };
+    TSHeuristic.distance = function (s1, s2) {
+        if (s1 === void 0) { s1 = ''; }
+        if (s2 === void 0) { s2 = ''; }
+        return (this.getHeuristicDistance(s1, s2) / Math.max(s1.length, s2.length)) * 100;
+    };
+    TSHeuristic.similarity = function (s1, s2) {
+        return 100 - this.distance(s1, s2);
+    };
+    TSHeuristic.removeDiacritics = function (str) {
+        for (var _i = 0, DIACRITICS_REMOVAL_MAP_1 = diacritics_removal_map_1.DIACRITICS_REMOVAL_MAP; _i < DIACRITICS_REMOVAL_MAP_1.length; _i++) {
+            var rule = DIACRITICS_REMOVAL_MAP_1[_i];
+            str = str.replace(rule.letters, rule.base);
+        }
+        return str;
+    };
+    return TSHeuristic;
+}());
+exports.TSHeuristic = TSHeuristic;

package/utils/TSLZS.d.ts

@@ -0,0 +1,42 @@
+export declare class TSLZS {
+    private f;
+    private keyStrBase64;
+    private keyStrUriSafe;
+    private baseReverseDic;
+    /** Read one packed bit field from the input stream (shared LZ pattern). */
+    /** When enlarge counter is zero, widen the code bit width (LZ decompress bookkeeping). */
+    private decompressExpandCodebookIfNeeded;
+    private decompressAppendLiteralToDictionary;
+    private decompressResolveEntry;
+    private decompressReadBits;
+    private compressAppendBit;
+    private compressWriteBitsFromValue;
+    private compressWritePlainBits;
+    /** First emitted bit is 1, remaining bits are 0 (LZ literal header). */
+    private compressWriteBitsFirstOne;
+    private compressWriteDictIndexBits;
+    /** Emit bits for a phrase still being added to the dictionary (literal path). */
+    private compressEmitPendingLiteral;
+    /** LZ "enlarge" step: decrement counter and widen bit width when it hits zero. */
+    private compressDecrementEnlargeIn;
+    /**
+     * Emit bits for the current phrase: pending literal (still being created) or dictionary index.
+     * @returns whether the phrase was a pending literal (caller may delete from dictionaryToCreate).
+     */
+    private compressEmitPendingOrDict;
+    /** Final LZ stream padding: emit control bits then align to character boundary. */
+    private compressPadStreamTerminator;
+    private getBaseValue;
+    compressToBase64(input: string | null): string;
+    decompressFromBase64(input: string | null): string | null;
+    compressToUTF16(input: string | null): string;
+    decompressFromUTF16(compressed: string | null): string | null;
+    compressToUint8Array(uncompressed: string): Uint8Array;
+    decompressFromUint8Array(compressed: Uint8Array | null | undefined): string | null;
+    compressToEncodedURIComponent(input: string | null): string;
+    decompressFromEncodedURIComponent(input: string | null): string | null;
+    compress(uncompressed: string | null): string;
+    _compress(uncompressed: string | null, bitsPerChar: number, getCharFromInt: (a: number) => string): string;
+    decompress(compressed: string | null): string | null;
+    _decompress(length: number, resetValue: number, getNextValue: (index: number) => number): string | null;
+}

package/utils/TSLZS.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSLZS = void 0;
+var TSLZS = /** @class */ (function () {
+    function TSLZS() {
+        this.f = String.fromCharCode;
+        this.keyStrBase64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        this.keyStrUriSafe = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$';
+        this.baseReverseDic = {};
+    }
+    /** Read one packed bit field from the input stream (shared LZ pattern). */
+    /** When enlarge counter is zero, widen the code bit width (LZ decompress bookkeeping). */
+    TSLZS.prototype.decompressExpandCodebookIfNeeded = function (enlargeIn, numBits) {
+        if (enlargeIn !== 0)
+            return [enlargeIn, numBits];
+        return [Math.pow(2, numBits), numBits + 1];
+    };
+    TSLZS.prototype.decompressAppendLiteralToDictionary = function (data, resetValue, getNextValue, dictionary, dictSize, bitWidth) {
+        var bits = this.decompressReadBits(data, resetValue, getNextValue, Math.pow(2, bitWidth));
+        dictionary[dictSize++] = this.f(bits);
+        return { code: dictSize - 1, dictSize: dictSize };
+    };
+    TSLZS.prototype.decompressResolveEntry = function (dictionary, c, dictSize, w) {
+        if (dictionary[c] != null) {
+            return String(dictionary[c]);
+        }
+        if (c === dictSize) {
+            return w + w.charAt(0);
+        }
+        return null;
+    };
+    TSLZS.prototype.decompressReadBits = function (data, resetValue, getNextValue, maxPower) {
+        var bits = 0;
+        var power = 1;
+        while (power !== maxPower) {
+            var resb = data.val & data.position;
+            data.position >>= 1;
+            if (data.position === 0) {
+                data.position = resetValue;
+                data.val = getNextValue(data.index++);
+            }
+            bits |= (resb > 0 ? 1 : 0) * power;
+            power <<= 1;
+        }
+        return bits;
+    };
+    TSLZS.prototype.compressAppendBit = function (s, bitsPerChar, getCharFromInt, bit) {
+        s.context_data_val = bit === undefined
+            ? (s.context_data_val << 1)
+            : (s.context_data_val << 1) | bit;
+        if (s.context_data_position === bitsPerChar - 1) {
+            s.context_data_position = 0;
+            s.context_data.push(getCharFromInt(s.context_data_val));
+            s.context_data_val = 0;
+        }
+        else {
+            s.context_data_position++;
+        }
+    };
+    TSLZS.prototype.compressWriteBitsFromValue = function (s, bitsPerChar, getCharFromInt, value, width) {
+        var v = value;
+        for (var i = 0; i < width; i++) {
+            this.compressAppendBit(s, bitsPerChar, getCharFromInt, v & 1);
+            v >>= 1;
+        }
+    };
+    TSLZS.prototype.compressWritePlainBits = function (s, bitsPerChar, getCharFromInt, count) {
+        for (var i = 0; i < count; i++) {
+            this.compressAppendBit(s, bitsPerChar, getCharFromInt);
+        }
+    };
+    /** First emitted bit is 1, remaining bits are 0 (LZ literal header). */
+    TSLZS.prototype.compressWriteBitsFirstOne = function (s, bitsPerChar, getCharFromInt, n) {
+        for (var i = 0; i < n; i++) {
+            this.compressAppendBit(s, bitsPerChar, getCharFromInt, i === 0 ? 1 : 0);
+        }
+    };
+    TSLZS.prototype.compressWriteDictIndexBits = function (s, bitsPerChar, getCharFromInt, context_numBits, value) {
+        for (var i = 0; i < context_numBits; i++) {
+            this.compressAppendBit(s, bitsPerChar, getCharFromInt, value & 1);
+            value >>= 1;
+        }
+    };
+    /** Emit bits for a phrase still being added to the dictionary (literal path). */
+    TSLZS.prototype.compressEmitPendingLiteral = function (context_w, context_dictionaryToCreate, bitState, bitsPerChar, getCharFromInt, context_numBits) {
+        if (!Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w))
+            return;
+        if (context_w.charCodeAt(0) < 256) {
+            this.compressWritePlainBits(bitState, bitsPerChar, getCharFromInt, context_numBits);
+            this.compressWriteBitsFromValue(bitState, bitsPerChar, getCharFromInt, context_w.charCodeAt(0), 8);
+        }
+        else {
+            this.compressWriteBitsFirstOne(bitState, bitsPerChar, getCharFromInt, context_numBits);
+            this.compressWriteBitsFromValue(bitState, bitsPerChar, getCharFromInt, context_w.charCodeAt(0), 16);
+        }
+    };
+    /** LZ "enlarge" step: decrement counter and widen bit width when it hits zero. */
+    TSLZS.prototype.compressDecrementEnlargeIn = function (enlargeIn, numBits) {
+        var ei = enlargeIn - 1;
+        var nb = numBits;
+        if (ei === 0) {
+            ei = Math.pow(2, nb);
+            nb++;
+        }
+        return [ei, nb];
+    };
+    /**
+     * Emit bits for the current phrase: pending literal (still being created) or dictionary index.
+     * @returns whether the phrase was a pending literal (caller may delete from dictionaryToCreate).
+     */
+    TSLZS.prototype.compressEmitPendingOrDict = function (context_w, context_dictionary, context_dictionaryToCreate, bitState, bitsPerChar, getCharFromInt, context_numBits) {
+        var pending = Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w);
+        if (pending) {
+            this.compressEmitPendingLiteral(context_w, context_dictionaryToCreate, bitState, bitsPerChar, getCharFromInt, context_numBits);
+        }
+        else {
+            var value = context_dictionary[context_w];
+            this.compressWriteDictIndexBits(bitState, bitsPerChar, getCharFromInt, context_numBits, value);
+        }
+        return pending;
+    };
+    /** Final LZ stream padding: emit control bits then align to character boundary. */
+    TSLZS.prototype.compressPadStreamTerminator = function (bitState, bitsPerChar, getCharFromInt, context_numBits) {
+        var value = 2;
+        for (var i = 0; i < context_numBits; i++) {
+            this.compressAppendBit(bitState, bitsPerChar, getCharFromInt, value & 1);
+            value >>= 1;
+        }
+        while (true) {
+            bitState.context_data_val = (bitState.context_data_val << 1);
+            if (bitState.context_data_position === bitsPerChar - 1) {
+                bitState.context_data.push(getCharFromInt(bitState.context_data_val));
+                break;
+            }
+            bitState.context_data_position++;
+        }
+    };
+    TSLZS.prototype.getBaseValue = function (alphabet, character) {
+        if (!this.baseReverseDic[alphabet]) {
+            this.baseReverseDic[alphabet] = {};
+            for (var i = 0; i < alphabet.length; i++) {
+                this.baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+            }
+        }
+        return this.baseReverseDic[alphabet][character];
+    };
+    TSLZS.prototype.compressToBase64 = function (input) {
+        var _this = this;
+        if (input == null)
+            return '';
+        var res = this._compress(input, 6, function (a) { return _this.keyStrBase64.charAt(a); });
+        switch (res.length % 4) { // To produce valid Base64
+            default: // When could this happen ?
+            case 0: return res;
+            case 1: return res + '===';
+            case 2: return res + '==';
+            case 3: return res + '=';
+        }
+    };
+    TSLZS.prototype.decompressFromBase64 = function (input) {
+        var _this = this;
+        if (input == null)
+            return '';
+        if (input == '')
+            return null;
+        return this._decompress(input.length, 32, function (index) { return _this.getBaseValue(_this.keyStrBase64, input.charAt(index)); });
+    };
+    TSLZS.prototype.compressToUTF16 = function (input) {
+        var _this = this;
+        if (input == null)
+            return '';
+        return this._compress(input, 15, function (a) { return _this.f(a + 32); }) + ' ';
+    };
+    TSLZS.prototype.decompressFromUTF16 = function (compressed) {
+        if (compressed == null)
+            return '';
+        if (compressed == '')
+            return null;
+        return this._decompress(compressed.length, 16384, function (index) { return compressed.charCodeAt(index) - 32; });
+    };
+    TSLZS.prototype.compressToUint8Array = function (uncompressed) {
+        var compressed = this.compress(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.charCodeAt(i);
+            buf[i * 2] = current_value >>> 8;
+            buf[i * 2 + 1] = current_value % 256;
+        }
+        return buf;
+    };
+    TSLZS.prototype.decompressFromUint8Array = function (compressed) {
+        var _this = this;
+        if (compressed === null || compressed === undefined) {
+            return this.decompress(null);
+        }
+        else {
+            var buf = new Array(compressed.length / 2); // 2 bytes per character
+            for (var i = 0, TotalLen = buf.length; i < TotalLen; i++) {
+                buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+            }
+            var result_1 = [];
+            buf.forEach(function (c) { return result_1.push(_this.f(c)); });
+            return this.decompress(result_1.join(''));
+        }
+    };
+    TSLZS.prototype.compressToEncodedURIComponent = function (input) {
+        var _this = this;
+        if (input == null)
+            return '';
+        return this._compress(input, 6, function (a) { return _this.keyStrUriSafe.charAt(a); });
+    };
+    TSLZS.prototype.decompressFromEncodedURIComponent = function (input) {
+        var _this = this;
+        if (input == null)
+            return '';
+        if (input == '')
+            return null;
+        input = input.replace(/ /g, '+');
+        return this._decompress(input.length, 32, function (index) { return _this.getBaseValue(_this.keyStrUriSafe, input.charAt(index)); });
+    };
+    TSLZS.prototype.compress = function (uncompressed) {
+        var _this = this;
+        return this._compress(uncompressed, 16, function (a) { return _this.f(a); });
+    };
+    TSLZS.prototype._compress = function (uncompressed, bitsPerChar, getCharFromInt) {
+        var _a, _b, _c;
+        if (uncompressed == null)
+            return '';
+        var context_dictionary = {}, context_dictionaryToCreate = {}, context_data = [];
+        var context_c, context_wc, context_w = '', context_enlargeIn = 2, // Compensate for the first entry which should not count
+        context_dictSize = 3, context_numBits = 2, ii;
+        var bitState = {
+            context_data_val: 0,
+            context_data_position: 0,
+            context_data: context_data
+        };
+        for (ii = 0; ii < uncompressed.length; ii += 1) {
+            context_c = uncompressed.charAt(ii);
+            if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+                context_dictionary[context_c] = context_dictSize++;
+                context_dictionaryToCreate[context_c] = true;
+            }
+            context_wc = context_w + context_c;
+            if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+                context_w = context_wc;
+            }
+            else {
+                var pendingPhrase = this.compressEmitPendingOrDict(context_w, context_dictionary, context_dictionaryToCreate, bitState, bitsPerChar, getCharFromInt, context_numBits);
+                if (pendingPhrase) {
+                    _a = this.compressDecrementEnlargeIn(context_enlargeIn, context_numBits), context_enlargeIn = _a[0], context_numBits = _a[1];
+                    delete context_dictionaryToCreate[context_w];
+                }
+                _b = this.compressDecrementEnlargeIn(context_enlargeIn, context_numBits), context_enlargeIn = _b[0], context_numBits = _b[1];
+                context_dictionary[context_wc] = context_dictSize++;
+                context_w = String(context_c);
+            }
+        }
+        if (context_w !== '') {
+            var pendingTail = this.compressEmitPendingOrDict(context_w, context_dictionary, context_dictionaryToCreate, bitState, bitsPerChar, getCharFromInt, context_numBits);
+            if (pendingTail) {
+                _c = this.compressDecrementEnlargeIn(context_enlargeIn, context_numBits), context_enlargeIn = _c[0], context_numBits = _c[1];
+                delete context_dictionaryToCreate[context_w];
+            }
+            context_numBits = this.compressDecrementEnlargeIn(context_enlargeIn, context_numBits)[1];
+        }
+        this.compressPadStreamTerminator(bitState, bitsPerChar, getCharFromInt, context_numBits);
+        return bitState.context_data.join('');
+    };
+    TSLZS.prototype.decompress = function (compressed) {
+        if (compressed == null)
+            return '';
+        if (compressed == '')
+            return null;
+        return this._decompress(compressed.length, 32768, function (index) { return compressed.charCodeAt(index); });
+    };
+    TSLZS.prototype._decompress = function (length, resetValue, getNextValue) {
+        var _a, _b;
+        var dictionary = [], result = [], data = { val: getNextValue(0), position: resetValue, index: 1 };
+        var enlargeIn = 4, dictSize = 4, numBits = 3, entry, i, w, bits, c = '';
+        for (i = 0; i < 3; i += 1) {
+            dictionary[i] = i;
+        }
+        bits = this.decompressReadBits(data, resetValue, getNextValue, Math.pow(2, 2));
+        switch (bits) {
+            case 0: {
+                var lit = this.decompressReadBits(data, resetValue, getNextValue, Math.pow(2, 8));
+                c = this.f(lit);
+                break;
+            }
+            case 1: {
+                var lit = this.decompressReadBits(data, resetValue, getNextValue, Math.pow(2, 16));
+                c = this.f(lit);
+                break;
+            }
+            case 2:
+                return '';
+            default:
+                break;
+        }
+        dictionary[3] = c;
+        w = c;
+        result.push(c);
+        while (true) {
+            if (data.index > length) {
+                return '';
+            }
+            bits = this.decompressReadBits(data, resetValue, getNextValue, Math.pow(2, numBits));
+            switch (bits) {
+                case 0: {
+                    var appended = this.decompressAppendLiteralToDictionary(data, resetValue, getNextValue, dictionary, dictSize, 8);
+                    c = appended.code;
+                    dictSize = appended.dictSize;
+                    enlargeIn--;
+                    break;
+                }
+                case 1: {
+                    var appended = this.decompressAppendLiteralToDictionary(data, resetValue, getNextValue, dictionary, dictSize, 16);
+                    c = appended.code;
+                    dictSize = appended.dictSize;
+                    enlargeIn--;
+                    break;
+                }
+                case 2:
+                    return result.join('');
+                default:
+                    c = bits;
+            }
+            _a = this.decompressExpandCodebookIfNeeded(enlargeIn, numBits), enlargeIn = _a[0], numBits = _a[1];
+            var resolvedEntry = this.decompressResolveEntry(dictionary, c, dictSize, w);
+            if (resolvedEntry === null) {
+                return null;
+            }
+            entry = resolvedEntry;
+            result.push(entry);
+            dictionary[dictSize++] = w + entry.charAt(0);
+            enlargeIn--;
+            w = entry;
+            _b = this.decompressExpandCodebookIfNeeded(enlargeIn, numBits), enlargeIn = _b[0], numBits = _b[1];
+        }
+    };
+    return TSLZS;
+}());
+exports.TSLZS = TSLZS;