strc 2.0.3 → 2.0.5

package/dist/jssc.cjs

@@ -41,13 +41,10 @@ SOFTWARE.
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const JUSTC = require('justc');
+var JUSTC = require('justc');
 
 const name__ = 'JSSC';
 const prefix = name__+': ';
-if ((String.fromCharCode(65536).charCodeAt(0) === 65536) || !(String.fromCharCode(256).charCodeAt(0) === 256)) {
-    throw new Error(prefix+'Supported UTF-16 only!')
-}
 
 function stringCodes(str) {
     let output = [];
@@ -93,6 +90,121 @@ function binToDec(str) {
     return parseInt(str, 2);
 }
 
+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(prefix+'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"
+];
+
+if ((String.fromCharCode(65536).charCodeAt(0) === 65536) || !(String.fromCharCode(256).charCodeAt(0) === 256)) {
+    throw new Error(prefix+'Supported UTF-16 only!')
+}
+
 function charsBase() {
     const charsBase = {};
     function addChar(i) {
@@ -631,117 +743,6 @@ function decompressSequences(str) {
     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(prefix+'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 [];
 

package/dist/jssc.js

@@ -38,18 +38,13 @@ SOFTWARE.
 */
 
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JSSC = {}));
-})(this, (function (exports) { 'use strict';
-
-    const JUSTC = require('justc');
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('justc')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'justc'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.JSSC = {}, global.JUSTC));
+})(this, (function (exports, JUSTC) { 'use strict';
 
     const name__ = 'JSSC';
     const prefix = name__+': ';
-    if ((String.fromCharCode(65536).charCodeAt(0) === 65536) || !(String.fromCharCode(256).charCodeAt(0) === 256)) {
-        throw new Error(prefix+'Supported UTF-16 only!')
-    }
 
     function stringCodes(str) {
         let output = [];
@@ -95,6 +90,121 @@ SOFTWARE.
         return parseInt(str, 2);
     }
 
+    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(prefix+'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"
+    ];
+
+    if ((String.fromCharCode(65536).charCodeAt(0) === 65536) || !(String.fromCharCode(256).charCodeAt(0) === 256)) {
+        throw new Error(prefix+'Supported UTF-16 only!')
+    }
+
     function charsBase() {
         const charsBase = {};
         function addChar(i) {
@@ -633,117 +743,6 @@ 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(prefix+'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 [];