strc 1.1.0 → 2.0.0-test

package/index.js

@@ -2,7 +2,7 @@
 
 MIT License
 
-Copyright (c) 2025 JustDeveloper <https://justdeveloper.is-a.dev/>
+Copyright (c) 2025-2026 JustDeveloper <https://justdeveloper.is-a.dev/>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -37,15 +37,14 @@ SOFTWARE.
 
 (function (root, factory) {
     if (typeof define === 'function' && define.amd) {
-        define([], factory);        /*   amd    */
+        define(['justc'], factory);                 /*   amd    */
     } else if (typeof module === 'object' && module.exports) {
-        module.exports = factory(); /*   node   */
+        module.exports = factory(require('justc')); /*   node   */
     } else {
-        root.JSSC = factory();      /* browsers */
+        root.JSSC = factory(root.JUSTC);            /* browsers */
         Object.freeze(root.JSSC);
     }
-}(typeof self !== 'undefined' ? self : this, function () {
-
+}(typeof self !== 'undefined' ? self : this, function (JUSTC) {
     if ((String.fromCharCode(65536).charCodeAt(0) === 65536) || !(String.fromCharCode(256).charCodeAt(0) === 256)) {
         throw new Error('Supported UTF-16 only!')
     }
@@ -135,6 +134,9 @@ SOFTWARE.
         'JA':    9,
         'Telu': 10,
         'MR':   11,
+        'B':    12,
+        'E':    13,
+        'AR':   14
     };
     _JSSC.BASE = function() { /* Base */
         const chrsBase = charsBase();
@@ -397,6 +399,29 @@ SOFTWARE.
         }
         return chrsBase;
     };
+    _JSSC.B = function() { /* Baltic */
+        const chrsBase = charsLatin();
+        for (let i = 0x100; i < 0x17F; i++) {
+            chrsBase[i - 128] = _JSSC._char(i);
+        }
+        chrsBase[255] = _JSSC._char(0x17F); /* U+017F */
+        return chrsBase;
+    };
+    _JSSC.E = function() { /* European */
+        const chrsBase = charsLatin();
+        for (let i = 0x80; i < 0xFF; i++) {
+            chrsBase[i] = _JSSC._char(i);
+        }
+        chrsBase[255] = _JSSC._char(0x17F); /* U+017F */
+        return chrsBase;
+    };
+    _JSSC.AR = function() { /* Arabic */
+        const chrsBase = {};
+        for (let i = 0x600; i < 0x6FF; i++) {
+            chrsBase[i - 1536] = _JSSC._char(i);
+        }
+        return chrsBase;
+    }
     _JSSC.use = class {
         constructor() {
             let output = {};
@@ -417,7 +442,8 @@ SOFTWARE.
     function cryptCharCode(
         code, get = false,
         repeatBefore = false, repeatAfter = false,
-        beginId = -1, code2 = 0, sequences = false
+        beginId = -1, code2 = 0, sequences = false,
+        code3 = -1
     ) {
         if (get) {
             const codeBin = decToBin(code, 16);
@@ -431,23 +457,38 @@ SOFTWARE.
                 beginId: codeSet[2] === '1' ? begid : -1,
                 code2: binToDec(codeBin.slice(0,4)),
                 sequences: codeBin.slice(4,5) === '1',
-                code3: codeSet[2] === '0' ? begid : -1, /* currently unused */
+                code3: codeSet[2] === '0' ? begid : -1,
                 bin: codeBin,
             }
         } else {
-            const sixteenBits =                                 /* 16-bit Data/Header character */
-
-                decToBin(code2, 4) +                            /* Bits  0-3  :           code2 */
-                (sequences ? '1' : '0') +                       /* Bit    4   :      sequences? */
-                (beginId >= 0 ? decToBin(beginId, 3) : '000') + /* Bits  5-7  : beginID | code3 */
-                (repeatBefore ? '1' : '0') +                    /* Bit    8   :      input RLE? */
-                (repeatAfter ? '1' : '0') +                     /* Bit    9   :     output RLE? */
-                (beginId >= 0 ? '1' : '0') +                    /* Bit   10   :        beginID? */
-                decToBin(code, 5);                              /* Bits 11-15 :           code1 */
+            const sixteenBits =                                               /* 16-bit Data/Header character */
+
+                decToBin(code2, 4) +                                          /* Bits  0-3  :           code2 */
+                (sequences ? '1' : '0') +                                     /* Bit    4   : sequences?|odd? */
+                decToBin(beginId >= 0 ? beginId : code3 < 0 ? 0 : code3, 3) + /* Bits  5-7  : beginID | code3 */
+                (repeatBefore ? '1' : '0') +                                  /* Bit    8   : inp RLE? | num? */
+                (repeatAfter ? '1' : '0') +                                   /* Bit    9   :     output RLE? */
+                (beginId >= 0 ? '1' : '0') +                                  /* Bit   10   :        beginID? */
+                decToBin(code, 5);                                            /* Bits 11-15 :           code1 */
             
             return binToDec(sixteenBits);
         }
     }
+    /* Code 1 usage table */
+    /* ------------------ */
+    /* 00: No compression */
+    /* 01: CharCode.len=2 */
+    /* 02: ASCII in UTF16 */ /* Yeah ik thats not actually matches ASCII */
+    /* 03: Integers (Any) */
+    /* 04: Build Alphabet */
+    /* 05: Char Encodings */
+    /* 06: Integers (>15) */
+    /* 07: Frequency  Map */
+    /* 08: URL to  binary */
+    /* 09: Segmt compress */
+    /* 10: Repeating strs */
+    /* 11 - 30:  Reserved */
+    /* 31: Rcrsv compress */
 
     const SEQUENCE_MARKER = '\uDBFF'; /* Private Use Area */
 
@@ -598,95 +639,395 @@ SOFTWARE.
         return result;
     }
 
+    const freqMap = {
+        ESCAPE_BYTE: 0xFF,
+        TOP_COUNT: 254,
+        SPLITTER: " \u200B",
+
+        compress(text, splitter = this.SPLITTER) {
+            const freq = {};
+            for (let char of text) {
+                freq[char] = (freq[char] || 0) + 1;
+            }
+
+            const topChars = Object.entries(freq)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, this.TOP_COUNT)
+                .map(entry => entry[0]);
+
+            const charToIndex = new Map(topChars.map((char, i) => [char, i]));
+            
+            let header = String.fromCharCode(topChars.length) + topChars.join('');
+            
+            let bytes = [];
+            for (let char of text) {
+                if (charToIndex.has(char)) {
+                    /* frequent */
+                    bytes.push(charToIndex.get(char));
+                } else {
+                    /* rare */
+                    bytes.push(this.ESCAPE_BYTE);
+                    const code = char.charCodeAt(0);
+                    bytes.push((code >> 8) & 0xFF);
+                    bytes.push(code & 0xFF);
+                }
+            }
+
+            /* to UTF16 */
+            let compressedBody = "";
+            for (let i = 0; i < bytes.length; i += 2) {
+                const b1 = bytes[i];
+                const b2 = (i + 1 < bytes.length) ? bytes[i + 1] : 0x00;
+                compressedBody += String.fromCharCode((b1 << 8) | b2);
+            }
+
+            return header + splitter + compressedBody;
+        },
+
+        decompress(compressedText, splitter = this.SPLITTER) {
+            const parts = compressedText.split(splitter);
+
+            if (parts.length < 2) {
+                throw new Error('Invalid freqMap data: splitter not found');
+            }
+
+            const headerPart = parts[0];
+            const bodyPart = parts.slice(1).join(splitter);
+
+            const topCount = headerPart.charCodeAt(0);
+            const topChars = headerPart.substring(1, topCount + 1);
+            
+            let bytes = [];
+            for (let i = 0; i < bodyPart.length; i++) {
+                const code = bodyPart.charCodeAt(i);
+                bytes.push((code >> 8) & 0xFF);
+                bytes.push(code & 0xFF);
+            }
+
+            let result = "";
+            for (let i = 0; i < bytes.length; i++) {
+                const b = bytes[i];
+                if (b === this.ESCAPE_BYTE) {
+                    const charCode = (bytes[i + 1] << 8) | bytes[i + 2];
+                    result += String.fromCharCode(charCode);
+                    i += 2;
+                } else if (b < topCount) {
+                    result += topChars[b];
+                }
+            }
+            return result;
+        },
+
+        /**
+         * 0 = Fail
+         * 1 = Success
+         * 2 = Remove last character (Success)
+         * @param {string} text
+         * @param {string?} splitter
+         * @returns {number|[number, number, string, string]}
+         */
+        test(text, splitter = this.SPLITTER) {
+            try {
+                if (text.includes(splitter)) return 0;
+                const packed = this.compress(text, splitter);
+                const unpacked = this.decompress(packed, splitter);
+                if (packed.length < text.length) {
+                    if (unpacked == text) return [1, packed.length, splitter, packed];
+                    else if (unpacked.slice(0,-1) == text) return [2, packed.length, splitter, packed];
+                    else return 0;
+                }
+                return 0;
+            } catch (_) {
+                return 0;
+            }
+        }
+    };
+    
+    const freqMapSplitters = [
+        " \u200B","\u0000",
+        "\u001F", "\u0001",
+        "\uFFFD", "\u2022",
+        "|§|",    "\uFEFF"
+    ];
+
+    function segments(str) {
+        if (typeof str !== 'string' || str.length === 0) return [];
+
+        const THRESHOLD = 128;
+        const segs = [];
+        let currentSeg = str[0];
+
+        for (let i = 1; i < str.length; i++) {
+            const prevCode = str.charCodeAt(i - 1);
+            const currCode = str.charCodeAt(i);
+
+            if (Math.abs(currCode - prevCode) > THRESHOLD) {
+                segs.push(currentSeg);
+                currentSeg = str[i];
+            } else {
+                currentSeg += str[i];
+            }
+        }
+
+        if (currentSeg) segs.push(currentSeg);
+
+        return segs;
+    }
+
+    async function tryRecursive(base, opts) {
+        if (!opts.recursivecompression) return base;
+
+        let cur = base;
+        let depth = 0;
+
+        while (depth < 15) {
+            depth++;
+            const next = await compress(cur, {
+                ...opts,
+                recursivecompression: false
+            });
+
+            if (next.length >= cur.length) break;
+
+            const dec = await decompress(next, true);
+            if (dec !== cur) break;
+
+            cur = next;
+        }
+
+        if (depth === 0) return null;
+
+        return (
+            charCode(
+                cryptCharCode(
+                    31,
+                    false,
+                    false,
+                    false,
+                    -1,
+                    depth,
+                    false,
+                    -1
+                )
+            ) + cur
+        );
+    }
+
     /**
      * **JavaScript String Compressor - compress function.**
-     * @param {string} str string
-     * @returns {string} Compressed string
-     * @example compress('Hello, World!');
+     * @param {string|object|number} input string
+     * @param {{segmentation?: boolean, recursiveCompression?: boolean, JUSTC?: boolean}} [options]
+     * @returns {Promise<string>} Compressed string
+     * @example await compress('Hello, World!');
      * @since 1.0.0
      */
-    function compress(str) {
-        if (typeof str != 'string') throw new Error('Invalid input.');
+    async function compress(input, options) {
+        if (typeof input != 'string' && typeof input != 'object' && typeof input != 'number') throw new Error('Invalid input.');
+        const opts = {
+            segmentation: true,
+            recursivecompression: true,
+            justc: JUSTC ? true : false,
+        };
+
+        /* Read options */
+        if (options) {
+            if (typeof options != 'object') throw new Error('Invalid options input.');
+            for (const [key, value] of Object.entries(options)) {
+                if (typeof value != 'boolean') throw new Error('Invalid options input.');
+                if (key.toLowerCase() in opts) {
+                    opts[key.toLowerCase()] = value;
+                    continue;
+                }
+                console.warn(`Unknown option: "${key}".`);
+            }
+        }
+
+        const originalInput = input;
+        let str = input;
+        let isNum = false;
+
+        if (typeof str === 'number') {
+            isNum = true;
+            str = str.toString();
+            if (str.includes('.')) throw new Error('Invalid input.');
+        }
+
         let repeatBefore = false;
         function repeatChars(txt) {
             return txt.replace(/(.)\1+/g, ( a , b ) => b + a.length);
         }
+
         let beginId = -1;
-        for (const begin of _JSSC._begin) {
+        if (typeof str == 'string') for (const begin of _JSSC._begin) {
             if (str.startsWith(begin)) {
                 beginId = _JSSC._begin.indexOf(begin);
                 str = str.slice(begin.length);
                 break;
             }
+        };
+
+        let code3 = -1;
+        async function toJUSTC(obj) {
+            try {
+                const result = await JUSTC.stringify(obj);
+                if (result && typeof result.then === 'function') {
+                    return await result;
+                }
+                return result;
+            } catch (_) {
+                /* Browsers */
+                await JUSTC.initialize();
+                return JUSTC.stringify(obj);
+            }
         }
-        const d = (txt) => !/\d/.test(txt);
-        if (d(str)) {
+        if (beginId == -1) {
+            /* JSON Array (as object) */
+            if (typeof str == 'object' && Array.isArray(str)) {
+                str = JSON.stringify(str).slice(1,-1);
+                code3 = 4;
+            } else
+            /* JSON Object (as object) */
+            if (typeof str == 'object') try {
+                if (opts.justc) {
+                    const JUSTCobj = await toJUSTC(str);
+                    str = JUSTCobj;
+                    code3 = 2;
+                } else {
+                    str = JSON.stringify(str);
+                    code3 = 6;
+                }
+            } catch (error) {
+                const msg = new Error('Invalid input.');
+                throw new AggregateError([msg, error], msg.message);
+            } else
+            /* JSON Object (as string) */
+            try {
+                const obj = JSON.parse(str);
+                if (!Array.isArray(obj)) {
+                
+                const JUSTCobj = opts.justc ? await toJUSTC(obj) : false;
+
+                if (JUSTCobj && JUSTCobj.length < str.length && str == JSON.stringify(obj)) {                
+                    str = JUSTCobj;
+                    code3 = 1;
+                } else {
+                    str = str.slice(1,-1);
+                    code3 = 5;
+                }
+            } else {
+            /* JSON Array (as string) */
+            str = str.slice(1,-1);
+            code3 = 3;
+            }} catch (_) {
+        }}
+
+        if (!/\d/.test(str)) {
             str = repeatChars(str);
             repeatBefore = true;
         }
-        const strdata = stringCodes(str);
-        const ascii = strdata.maxCharCode < 256;
-        let repeatAfter = false;
-        let sequences = false;
         
-        function processCompression(output) {
+        function processOutput(output, disableSeq = false) {
+            let repeatAfter = false;
+            let sequences = false;
+
             const hasDigits = /\d/.test(output);
             if (!hasDigits) {
                 repeatAfter = true;
                 output = repeatChars(output);
             }
             
-            if (true) {
+            if (!disableSeq) {
                 const compressed = compressSequences(output);
                 if (compressed.sequences) {
                     sequences = true;
-                    return compressed.compressed;
+                    return [compressed.compressed, repeatAfter, sequences];
                 }
             }
             
-            return output;
+            return [output, repeatAfter, sequences];
         }
 
-        const UniqueCodes = [...new Set(strdata.output)];
-        if (/^\d+$/.test(str)) { /* Numbers */
-            /* Up to 8:1 compression ratio */
-            const convertNums = {
-                'A': 10,
-                'B': 11,
-                'C': 12,
-                'D': 13,
-                'E': 14
-            };
-            const inputt = str
-                .replaceAll('10', 'A')
-                .replaceAll('11', 'B')
-                .replaceAll('12', 'C')
-                .replaceAll('13', 'D')
-                .replaceAll('14', 'E');
-            const binOut = [];
-            for (const character of inputt.split('')) {
-                if (/\d/.test(character)) {
-                    binOut.push(decToBin(parseInt(character), 4));
-                } else {
-                    binOut.push(decToBin(convertNums[character], 4));
-                }
-            };
-            let output = '';
-            function binPadStart(bin) {
-                if (bin.length < 16) {
-                    const numm = 4 - stringChunks(bin, 4).length;
-                    return decToBin(15, 4).repeat(numm)+bin;
-                } else return bin;
+        const safeTry = async (fn) => {
+            try {
+                return await fn();
+            } catch {
+                return null;
             }
-            for (const character of chunkArray(binOut, 4)) {
-                output += String.fromCharCode(binToDec(binPadStart(character.join(''))));
+        };
+
+        const validate = async (compressed) => {
+            try {
+                const dec = await decompress(compressed, true);
+                return dec === String(originalInput);
+            } catch {
+                return false;
             }
-            output = processCompression(output);
-            return charCode(cryptCharCode(3, false, false, repeatAfter, -1, 0, sequences)) + output;
-            
-        } else if (strdata.max === 2 && strdata.min === 2) {
+        };
+
+        const candidates = [];
+
+        if (/^\d+$/.test(str)) {
+            /* Integers ( < 15 ) */
+            candidates.push(async () => {
+                const out = await (async () => {
+                    const num = parseInt(str);
+                    if (num < 15) {
+                        return charCode(
+                            cryptCharCode(isNum ? 6 : 0, false, false, false, -1, num + 1, false, code3)
+                        );
+                    }
+                    return null;
+                })();
+                if (!out) return null;
+                if (!(await validate(out))) return null;
+                return out;
+            });
+            /* Integers (any) */
+            candidates.push(async () => {
+                const convertNums = {
+                    'A': 10,
+                    'B': 11,
+                    'C': 12,
+                    'D': 13,
+                    'E': 14
+                };
+                const inputt = str
+                    .replaceAll('10', 'A')
+                    .replaceAll('11', 'B')
+                    .replaceAll('12', 'C')
+                    .replaceAll('13', 'D')
+                    .replaceAll('14', 'E');
+                const binOut = [];
+                for (const character of inputt.split('')) {
+                    if (/\d/.test(character)) {
+                        binOut.push(decToBin(parseInt(character), 4));
+                    } else {
+                        binOut.push(decToBin(convertNums[character], 4));
+                    }
+                };
+                let [output, RLE, sequences] = ['', false, false];
+                function binPadStart(bin) {
+                    if (bin.length < 16) {
+                        const numm = 4 - stringChunks(bin, 4).length;
+                        return decToBin(15, 4).repeat(numm)+bin;
+                    } else return bin;
+                }
+                for (const character of chunkArray(binOut, 4)) {
+                    output += String.fromCharCode(binToDec(binPadStart(character.join(''))));
+                }
+                [output, RLE, sequences] = processOutput(output);
+                output = charCode(cryptCharCode(3, false, isNum, RLE, -1, 0, sequences, code3)) + output;
+                if (!(await validate(output))) return null;
+                return output;
+            });
+        }
+
+        candidates.push(async () => {
+            const strdata = stringCodes(str);
+            if (!(strdata.max === 2 && strdata.min === 2)) return null;
+
             let chars = strdata.output;
-            let output = '';
+            let [output, repeatAfter, seq] = ['', false, false];
             function addChar(codee) {
                 output += String.fromCharCode(codee);
             }
@@ -717,42 +1058,32 @@ SOFTWARE.
                     }
                 }
             }
-            output = processCompression(output);
-            return charCode(cryptCharCode(1, false, repeatBefore, repeatAfter, beginId, 0, sequences)) + output;
-            
-        } else if (ascii) {
-            /* Up to 2:1 compression ratio */
-            /*
-                Bytes
-
-                ---
+            [output, repeatAfter, seq] = processOutput(out);
+            const res = charCode(cryptCharCode(1, false, repeatBefore, repeatAfter, beginId, 0, seq, code3)) + output;
+            if (!(await validate(res))) return null;
+            return res;
+        });
 
-                UTF16 : xxxx xxxx  xxxx xxxx
-                ASCII : xxxx xxxx
+        /* ASCII in UTF-16 */
+        candidates.push(async () => {
+            const strdata = stringCodes(str);
+            if (strdata.maxCharCode >= 256) return null;
 
-                ---
+            let [out, repeatAfter, seq] = ['', false, false];
+            for (const pair of stringChunks(str, 2)) {
+                let bin = '';
+                for (const c of pair) bin += decToBin(c.charCodeAt(0), 8);
+                out += String.fromCharCode(binToDec(bin));
+            }
 
-                input: UTF16 => ASCII
+            [out, repeatAfter, seq] = processOutput(out);
+            const res = charCode(cryptCharCode(2, false, repeatBefore, repeatAfter, beginId, 0, seq, code3)) + out;
+            if (!(await validate(res))) return null;
+            return res;
+        });
 
-                output: ASCII => UTF16
-                        1 UTF16 char = 2 ASCII chars
-            */
-            const twoChars = [];
-            let output = '';
-            for (const chars_ of stringChunks(str, 2)) {
-                let charsCode = '';
-                for (const char of chars_.split('')) {
-                    charsCode += decToBin(char.charCodeAt(0), 8);
-                }
-                twoChars.push(charsCode);
-            }
-            for (const char of twoChars) {
-                output += String.fromCharCode(binToDec(char));
-            }
-            output = processCompression(output);
-            return charCode(cryptCharCode(2, false, repeatBefore, repeatAfter, beginId, 0, sequences)) + output;
-            
-        } else {
+        /* Character encodings */
+        candidates.push(async () => {
             const characterEncodings = new _JSSC.use();
             const stringArray = str.split('');
             let useCharacterEncoding;
@@ -789,61 +1120,239 @@ SOFTWARE.
                 for (const binCharCodes of chunkArray(binaryCharCodes, 2)) {
                     convertCharCodes.push(binCharCodes.join('').padStart(16, '0'));
                 }
-                let outputStr = '';
+                let [outputStr, repeatAfter, seq] = ['', false, false];
                 for (const characterCode of convertCharCodes) {
                     outputStr += String.fromCharCode(binToDec(characterCode))
                 }
-                /* Up to 2:1 compression ratio */
-                outputStr = processCompression(outputStr);
-                return charCode(cryptCharCode(charEncodingID + 5, false, repeatBefore, repeatAfter, beginId, 0, sequences)) + outputStr;
-                
-            } else if (UniqueCodes.length < 16) {
-                /* Up to 4:1 compression ratio */
-                const chars = UniqueCodes;
-                let output = '';
-                for (const char of chars) {
-                    output += String.fromCharCode(char);
+
+                [outputStr, repeatAfter, seq] = processOutput(outputStr);
+                outputStr = charCode(cryptCharCode(5, false, repeatBefore, repeatAfter, beginId, charEncodingID, seq, code3)) + outputStr;
+                if (await validate(outputStr)) return outputStr;
+            }
+            return null;
+        });
+
+        /* Build alphabet */
+        candidates.push(async () => {
+            const uniq = [...new Set(str.split('').map(c => c.charCodeAt(0)))];
+            if (uniq.length >= 16) return null;
+
+            let out = uniq.map(c => String.fromCharCode(c)).join('');
+            let buf = [];
+            let [repeatAfter, seq] = [false, false];
+
+            for (const c of str) {
+                buf.push(uniq.indexOf(c.charCodeAt(0)));
+                if (buf.length === 4) {
+                    out += String.fromCharCode(binToDec(buf.map(n => decToBin(n, 4)).join('')));
+                    buf = [];
                 }
-                
-                let char_ = [];
-                for (const charCode of strdata.output) {
-                    const index = UniqueCodes.indexOf(charCode);
-                    
-                    if (char_.length === 4) {
-                        let outchar = '';
-                        for (const index of char_) {
-                            outchar += decToBin(index, 4);
-                        }
-                        output += String.fromCharCode(binToDec(outchar));
-                        char_ = [];
+            }
+
+            if (buf.length) {
+                out += String.fromCharCode(
+                    binToDec(buf.map(n => decToBin(n, 4)).join('').padStart(16, '1'))
+                );
+            }
+
+            [out, repeatAfter, seq] = processOutput(out);
+            const res = charCode(cryptCharCode(4, false, repeatBefore, repeatAfter, beginId, uniq.length, seq, code3)) + out;
+            if (!(await validate(res))) return null;
+            return res;
+        });
+
+        /* Frequency map */
+        candidates.push(async () => {
+            for (const splitter of freqMapSplitters) {
+                const test = freqMap.test(str, splitter);
+                if (!Array.isArray(test)) continue;
+
+                const [, , sp, packed] = test;
+                const code2 = binToDec((test[0] - 1).toString() + decToBin(freqMapSplitters.indexOf(sp), 3));
+                const res = charCode(cryptCharCode(7, false, false, false, -1, code2)) + packed;
+
+                if (await validate(res)) return res;
+            }
+            return null;
+        });
+
+        /* URL */
+        candidates.push(async () => {
+            if (typeof str !== 'string') return null;
+
+            let url;
+            try {
+                url = new URL(_JSSC._begin[beginId] + str);
+            } catch {
+                return null;
+            }
+
+            const originalHref = url.href;
+
+            let hasPercent = /%[0-9A-Fa-f]{2}/.test(originalHref);
+            let hasPunycode = url.hostname.includes('xn--');
+            let hasQuery = !!url.search;
+            let hasFragment = !!url.hash;
+
+            /* normalize */
+            let normalized = originalHref.slice(_JSSC._begin[beginId].length);
+
+            /* punycode to unicode */
+            if (hasPunycode && typeof punycode !== 'undefined') {
+                url.hostname = punycode.toUnicode(url.hostname);
+                normalized = url.href.slice(_JSSC._begin[beginId].length);
+            }
+
+            /* percent to bytes */
+            let bytes = [];
+            for (let i = 0; i < normalized.length; i++) {
+                const ch = normalized[i];
+                if (ch === '%' && i + 2 < normalized.length) {
+                    const hex = normalized.slice(i + 1, i + 3);
+                    if (/^[0-9A-Fa-f]{2}$/.test(hex)) {
+                        bytes.push(parseInt(hex, 16));
+                        i += 2;
+                        continue;
                     }
-                    char_.push(index);
                 }
-                
-                if (char_.length > 0) {
-                    let outchar = '';
-                    for (const index of char_) {
-                        outchar += decToBin(index, 4);
-                    }
-                    output += String.fromCharCode(binToDec(outchar.padStart(16, '1')));
+                bytes.push(normalized.charCodeAt(i));
+            }
+            
+            let odd = bytes.length & 1;
+            if (odd) bytes.push(0);
+
+            /* bytes to UTF16 */
+            let out = '';
+            for (let i = 0; i < bytes.length; i += 2) {
+                out += String.fromCharCode(
+                    (bytes[i] << 8) | (bytes[i + 1] ?? 0)
+                );
+            }
+
+            let code2 =
+                (hasPercent ? 1 : 0) |
+                (hasPunycode ? 2 : 0) |
+                (hasQuery ? 4 : 0) |
+                (hasFragment ? 8 : 0);
+
+            let repeatAfter = false;
+            [out, repeatAfter,] = processOutput(out, true);
+
+            const res =
+                charCode(
+                    cryptCharCode(
+                        8,
+                        false,
+                        repeatBefore,
+                        repeatAfter,
+                        beginId,
+                        code2,
+                        odd,
+                        code3
+                    )
+                ) + out;
+
+            if (!(await validate(res))) return null;
+            return res;
+        });
+
+        /* Segmentation */
+        if (opts.segmentation) candidates.push(async () => {
+            const segs = segments(str);
+
+            if (segs.length < 2) return null;
+
+            let out = segs.length - 2 < 15 ? '' : String.fromCharCode(segs.length - 2);
+
+            for (const seg of segs) {
+                const segOpts = {
+                    ...opts,
+                    segmentation: false
                 }
-                
-                output = processCompression(output);
-                return charCode(cryptCharCode(4, false, repeatBefore, repeatAfter, beginId, UniqueCodes.length, sequences)) + output;
+                const compressed = await compress(seg, segOpts);
+
+                out += String.fromCharCode(seg.length);
+                out += compressed;
             }
 
-            /* 1:1 compression ratio (no compression) */
-            let output = processCompression(str);
-            return charCode(cryptCharCode(0, false, repeatBefore, repeatAfter, beginId, 0, sequences)) + output;
-        }
+            const res =
+                charCode(
+                    cryptCharCode(
+                        9,
+                        false,
+                        repeatBefore,
+                        opts.justc,
+                        beginId,
+                        Math.min(segs.length - 2, 15),
+                        opts.recursivecompression,
+                        code3
+                    )
+                ) + out;
+
+            if (!(await validate(res))) return null;
+            return res;
+        });
+
+        /* Repeating string */
+        const rcheck = str.match(/^(.{1,7}?)(?:\1)+$/);
+        if (rcheck) candidates.push(async () => {
+            const main = rcheck[1];
+            const count = str.length / main.length;
+            if (Math.floor(count) != count || count < 1 || count > 65535 + 15) return null;
+            let [out, repeatAfter, seq] = ['', false, false];
+            [out, repeatAfter, seq] = processOutput(main);
+
+            const res =
+                charCode(
+                    cryptCharCode(
+                        10,
+                        false,
+                        repeatBefore,
+                        repeatAfter,
+                        beginId,
+                        Math.min(count - 1, 15),
+                        seq,
+                        code3
+                    )
+                ) + (
+                    (count - 1) > 14 ? String.fromCharCode(count - 15) : ''
+                ) + out;
+
+            if (!(await validate(res))) return null;
+            return res;
+        });
+
+        /* run all */
+        const results = (await Promise.all(candidates.map(fn => safeTry(fn))))
+            .filter(r => typeof r === 'string' && r.length <= String(str).length);
+
+        let best;
+        if (!results.length) {
+            let [repeatAfter, sequences] = [false, false];
+            const savedStr = str;
+            [str, repeatAfter, sequences] = processOutput(str);
+            if (await validate(str)) best = charCode(cryptCharCode(0, false, repeatBefore, repeatAfter, beginId, 0, sequences, code3)) + str;
+            else best = charCode(cryptCharCode(0, false, repeatBefore, false, beginId, 0, false, code3)) + savedStr;
+        } else best = results.reduce((a, b) => (b.length < a.length ? b : a));
+
+        if (opts.recursivecompression) try {
+            for (const r of results) {
+                const rc = await tryRecursive(r, opts);
+                if (rc && rc.length <= best.length && await validate(rc)) {
+                    best = rc;
+                }
+            }
+        } catch (_){};
+
+        return best;
     }
 
-    function characterEncodings(strcode, realstr) {
+    function characterEncodings(id, realstr) {
         const strcode2charencoding = {};
         for (const [name, code] of Object.entries(_JSSC._IDs)) {
             strcode2charencoding[code] = name
         }
-        const possibleCharEncoding = strcode2charencoding[strcode - 5];
+        const possibleCharEncoding = strcode2charencoding[id];
         if (possibleCharEncoding) {
             const characterEncodings_ = new _JSSC.use();
             const characterEncoding = characterEncodings_['JSSC'+possibleCharEncoding]();
@@ -866,13 +1375,43 @@ SOFTWARE.
         }
     }
 
+    async function parseJUSTC(str) {
+        try {
+            const result = JUSTC.parse(str);
+
+            if (result && typeof result.then === 'function') {
+                return await result;
+            }
+
+            return result;
+        } catch (err) {
+            if (typeof window !== 'undefined') { /* Browsers */
+                try {
+                    await JUSTC.initialize();
+
+                    const retry = JUSTC.parse(str);
+                    if (retry && typeof retry.then === 'function') {
+                        return await retry;
+                    }
+
+                    return retry;
+                } catch {
+                    return null;
+                }
+            }
+
+            return null;
+        }
+    }
+
     /**
      * **JavaScript String Compressor - decompress function.**
      * @param {string} str Compressed string
-     * @returns {string} Decompressed string
+     * @param {boolean?} [stringify] Return only string in any way
+     * @returns {Promise<string|object|number>} Decompressed string/object/integer
      * @since 1.0.0
      */
-    function decompress(str) {
+    async function decompress(str, stringify = false) {
         if (typeof str != 'string') throw new Error('Invalid input.');
         const strcodes = cryptCharCode(str.charCodeAt(0) - 32, true);
         const strcode = strcodes.code;
@@ -883,31 +1422,51 @@ SOFTWARE.
         
         /* sequences */
         let realstr = str.slice(1);
-        if (strcodes.sequences) {
+        if (strcodes.sequences && strcode != 8 && strcode != 9) {
             realstr = decompressSequences(realstr);
         }
         
         /* RLE */
-        if (strcodes.repeatAfter) {
+        if (strcodes.repeatAfter && strcode != 9) {
             realstr = repeatChars(realstr);
         }
         
-        function begin(out) {
+        async function begin(out) {
             if (strcodes.beginId >= 0) {
                 return _JSSC._begin[strcodes.beginId] + out;
+            } else if (strcodes.code3 == 1 || strcodes.code3 == 2) {
+                /* JSON Object */
+                const result = await parseJUSTC(out);
+                if (result && typeof result.then === 'function') {
+                    return JSON.stringify(await result);
+                } else return JSON.stringify(result);
             } else return out;
         }
         
-        function processOutput(out) {
-            if (strcodes.repeatBefore) {
-                return repeatChars(begin(out));
-            } else return begin(out);
+        async function processOutput(out) {
+            let output = out;
+            if (strcodes.repeatBefore && strcode != 3) {
+                output = repeatChars(await begin(out));
+            } else output = await begin(out);
+
+            if ((strcodes.repeatBefore && strcode == 3) || strcode == 30) output = parseInt(output); else {     /*            Integer            */
+            if (strcodes.code3 == 3 || strcodes.code3 == 4) output = '[' + output + ']';                        /*          JSON  Array          */
+            else if (strcodes.code3 == 5) output = '{' + output + '}';                                          /*    JSON Object (as string)    */
+            if (strcodes.code3 == 2 || strcodes.code3 == 4 || strcodes.code3 == 6) output = JSON.parse(output);} /* JSON Object/Array (as object) */
+
+            if (stringify) {
+                if (typeof output == 'object') output = JSON.stringify(output);
+                else if (typeof output == 'number') output = output.toString();
+            }
+
+            return output;
         }
         
         let output = '';
         switch (strcode) {
-            case 0:
-                return processOutput(realstr);
+            case 0: case 6:
+                if (strcodes.code2 > 0) return await processOutput(String(strcodes.code2 - 1));
+                return await processOutput(realstr);
             case 1:
                 function addChar(cde) {
                     output += String.fromCharCode(cde);
@@ -923,7 +1482,7 @@ SOFTWARE.
                         addChar(char.charCodeAt(0));
                     }
                 }
-                return processOutput(output);
+                return await processOutput(output);
             case 2:
                 function toChar(binCode) {
                     return String.fromCharCode(binToDec(binCode));
@@ -939,7 +1498,7 @@ SOFTWARE.
                         output += toChar(binCode8);
                     }
                 }
-                return processOutput(output);
+                return await processOutput(output);
             case 3:
                 for (const char of realstr.split('')) {
                     const binCodes = stringChunks(decToBin(char.charCodeAt(0), 16), 4);
@@ -950,7 +1509,7 @@ SOFTWARE.
                         }
                     }
                 }
-                return processOutput(output);
+                return await processOutput(output);
             case 4:
                 const chars = [];
                 for (const char of realstr.slice(0, strcodes.code2).split('')) {
@@ -965,12 +1524,87 @@ SOFTWARE.
                         }
                     }
                 }
-                return processOutput(output);
-            default:
-                const decoded = characterEncodings(strcode, realstr);
+                return await processOutput(output);
+            case 5:
+                const decoded = characterEncodings(strcodes.code2, realstr);
                 if (decoded) {
-                    return processOutput(decoded);
+                    return await processOutput(decoded);
+                } else throw new Error('Invalid compressed string');
+            case 7:
+                const splitter = freqMapSplitters[binToDec(decToBin(strcodes.code2).slice(1))];
+                output = freqMap.decompress(realstr, splitter);
+                if (parseInt(decToBin(strcodes.code2).slice(0,1)) == 1) output = output.slice(0,-1);
+                return await processOutput(output);
+            case 8: {
+                let bytes = [];
+                for (const ch of realstr) {
+                    const c = ch.charCodeAt(0);
+                    bytes.push((c >> 8) & 0xFF, c & 0xFF);
+                }
+                if (strcodes.sequences) bytes.pop();
+
+                let out = '';
+                for (const b of bytes) {
+                    out += String.fromCharCode(b);
+                }
+
+                /* percent restore if needed */
+                if (strcodes.code2 & 1) {
+                    out = out.replace(
+                        /[\x00-\x20\x7F-\xFF]/g,
+                        c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0').toUpperCase()
+                    );
+                }
+
+                /* punycode restore */
+                if (strcodes.code2 & 2 && typeof punycode !== 'undefined') {
+                    const u = new URL(out);
+                    u.hostname = punycode.toASCII(u.hostname);
+                    out = u.href;
+                }
+
+                return await processOutput(out);}
+            case 9: {
+                let idx = 0;
+                const segCount = strcodes.code2 < 15 ? strcodes.code2 + 2 : realstr.charCodeAt(idx++) + 2;
+                let out = '';
+
+                for (let i = 0; i < segCount; i++) {
+                    const len = realstr.charCodeAt(idx++);
+                    const segmentCompressed = realstr.slice(idx);
+
+                    const seg = (await decompress(
+                        segmentCompressed, true
+                    )).slice(0, len);
+
+                    out += seg;
+                    idx += (await compress(seg, {segmentation: false, justc: strcodes.repeatAfter, recursivecompression: strcodes.sequences})).length;
                 }
+
+                return await processOutput(out);}
+            case 10:
+                const sliceChar = strcodes.code2 == 15;
+                const repeatCount = sliceChar ? realstr.charCodeAt(0) + 15 : strcodes.code2;
+                if (sliceChar) realstr = realstr.slice(1);
+                return await processOutput(realstr.repeat(repeatCount));
+            case 31: {
+                let out = realstr;
+                const depth = strcodes.code2;
+
+                for (let i = 0; i < depth; i++) {
+                    const first = out.charCodeAt(0) - 32;
+                    const meta = cryptCharCode(first, true);
+
+                    if (meta.code === 31) {
+                        throw new Error('Attempt to nested recursive compression');
+                    }
+
+                    out = await decompress(out, true);
+                }
+
+                return out;
+            }
+            default:
                 throw new Error('Invalid compressed string');
         }
     }