@ddunigma/node 1.0.26 → 1.0.27

package/dist/cjs/index.js

@@ -1,331 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Custom64 = exports.Ddu64 = void 0;
-class Ddu64 {
-    constructor(dduChar, paddingChar) {
-        this.dduCharKr = [
-            "뜌",
-            "땨",
-            "이",
-            "우",
-            "야",
-            "!",
-            "?",
-            ".",
-        ];
-        this.paddingCharKr = "뭐";
-        this.defaultEncoding = "utf-8";
-        this.bitLengthMap = new Map();
-        this.binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
-        this.dduBinaryLookup = new Map();
-        this.dduBinaryLookupKr = new Map();
-        this.paddingRegex = new Map();
-        if (typeof dduChar === "string") {
-            const removeDuplicatesString = [...new Set(dduChar.trim())].join("");
-            this.dduChar = removeDuplicatesString.trim().split("");
-        }
-        else {
-            this.dduChar = dduChar || this.dduCharKr;
-        }
-        this.paddingChar = paddingChar || this.paddingCharKr;
-        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
-        this.dduCharKr.forEach((char, index) => this.dduBinaryLookupKr.set(char, index));
-        this.paddingRegex.set("default", new RegExp(this.paddingChar, "g"));
-        this.paddingRegex.set("KR", new RegExp(this.paddingCharKr, "g"));
-    }
-    getBitLength(setLength) {
-        let cached = this.bitLengthMap.get(setLength);
-        if (cached === undefined) {
-            cached = Math.ceil(Math.log2(setLength));
-            this.bitLengthMap.set(setLength, cached);
-        }
-        return cached;
-    }
-    getLargestPowerOfTwo(n) {
-        return Math.pow(2, Math.floor(Math.log2(n)));
-    }
-    *splitString(s, length) {
-        for (let i = 0; i < s.length; i += length) {
-            yield s.slice(i, Math.min(i + length, s.length));
-        }
-    }
-    getSelectedSets(dduSetSymbol, usePowerOfTwo) {
-        const isKR = dduSetSymbol === "KR";
-        const dduSet = isKR ? this.dduCharKr : this.dduChar;
-        const padChar = isKR ? this.paddingCharKr : this.paddingChar;
-        let dduLength = dduSet.length;
-        if (usePowerOfTwo) {
-            const powerOfTwoLength = this.getLargestPowerOfTwo(dduLength);
-            dduLength = powerOfTwoLength;
-        }
-        return {
-            dduSet: usePowerOfTwo ? dduSet.slice(0, dduLength) : dduSet,
-            padChar,
-            dduLength,
-            bitLength: this.getBitLength(dduLength),
-            lookupTable: isKR ? this.dduBinaryLookupKr : this.dduBinaryLookup,
-            paddingRegExp: this.paddingRegex.get(isKR ? "KR" : "default"),
-        };
-    }
-    bufferToDduBinary(input, bitLength) {
-        const encodedBin = input.reduce((acc, byte) => acc + this.binaryLookup[byte], "");
-        const dduBinary = Array.from(this.splitString(encodedBin, bitLength));
-        const padding = bitLength - dduBinary[dduBinary.length - 1].length;
-        if (padding > 0) {
-            dduBinary[dduBinary.length - 1] += "0".repeat(padding);
-        }
-        return { dduBinary, padding };
-    }
-    dduBinaryToBuffer(decodedBin, paddingBits) {
-        if (paddingBits > 0) {
-            decodedBin = decodedBin.slice(0, -paddingBits);
-        }
-        const buffer = [];
-        for (let i = 0; i < decodedBin.length; i += 8) {
-            buffer.push(parseInt(decodedBin.slice(i, i + 8), 2));
-        }
-        return Buffer.from(buffer);
-    }
-    encode(input, options = {}) {
-        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = true, } = options;
-        const bufferInput = typeof input === "string" ? Buffer.from(input, encoding) : input;
-        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
-        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
-        let resultString = "";
-        for (const binaryChunk of dduBinary) {
-            const charInt = parseInt(binaryChunk, 2);
-            if (usePowerOfTwo) {
-                resultString += dduSet[charInt];
-            }
-            else {
-                const quotient = Math.floor(charInt / dduLength);
-                const remainder = charInt % dduLength;
-                resultString += dduSet[quotient] + dduSet[remainder];
-            }
-        }
-        return padding > 0
-            ? resultString + padChar.repeat(Math.floor(padding / 2))
-            : resultString;
-    }
-    decode(input, options = {}) {
-        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = true, } = options;
-        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
-        const paddingCount = (input.match(paddingRegExp) || []).length;
-        const paddingBits = paddingCount * 2;
-        input = input.replace(paddingRegExp, "");
-        let dduBinary = "";
-        for (let i = 0; i < input.length; i += usePowerOfTwo ? 1 : 2) {
-            const firstChar = input[i];
-            const secondChar = input[i + 1];
-            if (usePowerOfTwo) {
-                const charIndex = lookupTable.get(firstChar);
-                if (charIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar}`);
-                dduBinary += charIndex.toString(2).padStart(bitLength, "0");
-            }
-            else {
-                const firstIndex = lookupTable.get(firstChar);
-                const secondIndex = lookupTable.get(secondChar);
-                if (firstIndex === undefined || secondIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
-                const value = firstIndex * dduLength + secondIndex;
-                dduBinary += value.toString(2).padStart(bitLength, "0");
-            }
-        }
-        const decoded = this.dduBinaryToBuffer(dduBinary, usePowerOfTwo ? paddingBits : paddingCount * bitLength);
-        return decoded.toString(encoding);
-    }
-}
-exports.Ddu64 = Ddu64;
-class Custom64 {
-    constructor(dduChar, paddingChar) {
-        this.dduCharKr = [
-            "A",
-            "s",
-            "q",
-            "r",
-            "0",
-            "z",
-            "3",
-            "t",
-            "y",
-            "1",
-            "5",
-            "2",
-            "4",
-            "E",
-            "B",
-            "C",
-            "Q",
-            "F",
-            "R",
-            "T",
-            "U",
-            "W",
-            "V",
-            "X",
-            "Y",
-            "Z",
-            "b",
-            "a",
-            "c",
-            "d",
-            "D",
-            "G",
-            "L",
-            "H",
-            "I",
-            "+",
-            "J",
-            "K",
-            "M",
-            "O",
-            "N",
-            "f",
-            "e",
-            "h",
-            "g",
-            "P",
-            "i",
-            "S",
-            "k",
-            "l",
-            "m",
-            "u",
-            "j",
-            "v",
-            "n",
-            "o",
-            "p",
-            "9",
-            "w",
-            "6",
-            "7",
-            "8",
-            "x",
-            "/",
-        ];
-        this.paddingCharKr = "=";
-        this.defaultEncoding = "utf-8";
-        this.bitLengthMap = new Map();
-        this.binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
-        this.dduBinaryLookup = new Map();
-        this.dduBinaryLookupKr = new Map();
-        this.paddingRegex = new Map();
-        if (typeof dduChar === "string") {
-            const removeDuplicatesString = [...new Set(dduChar.trim())].join("");
-            this.dduChar = removeDuplicatesString.trim().split("");
-        }
-        else {
-            this.dduChar = dduChar || this.dduCharKr;
-        }
-        this.paddingChar = paddingChar || this.paddingCharKr;
-        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
-        this.dduCharKr.forEach((char, index) => this.dduBinaryLookupKr.set(char, index));
-        this.paddingRegex.set("default", new RegExp(this.paddingChar, "g"));
-        this.paddingRegex.set("KR", new RegExp(this.paddingCharKr, "g"));
-    }
-    getBitLength(setLength) {
-        let cached = this.bitLengthMap.get(setLength);
-        if (cached === undefined) {
-            cached = Math.ceil(Math.log2(setLength));
-            this.bitLengthMap.set(setLength, cached);
-        }
-        return cached;
-    }
-    getLargestPowerOfTwo(n) {
-        return Math.pow(2, Math.floor(Math.log2(n)));
-    }
-    *splitString(s, length) {
-        for (let i = 0; i < s.length; i += length) {
-            yield s.slice(i, Math.min(i + length, s.length));
-        }
-    }
-    getSelectedSets(dduSetSymbol, usePowerOfTwo) {
-        const isKR = dduSetSymbol === "KR";
-        const dduSet = isKR ? this.dduCharKr : this.dduChar;
-        const padChar = isKR ? this.paddingCharKr : this.paddingChar;
-        let dduLength = dduSet.length;
-        if (usePowerOfTwo) {
-            const powerOfTwoLength = this.getLargestPowerOfTwo(dduLength);
-            dduLength = powerOfTwoLength;
-        }
-        return {
-            dduSet: usePowerOfTwo ? dduSet.slice(0, dduLength) : dduSet,
-            padChar,
-            dduLength,
-            bitLength: this.getBitLength(dduLength),
-            lookupTable: isKR ? this.dduBinaryLookupKr : this.dduBinaryLookup,
-            paddingRegExp: this.paddingRegex.get(isKR ? "KR" : "default"),
-        };
-    }
-    bufferToDduBinary(input, bitLength) {
-        const encodedBin = input.reduce((acc, byte) => acc + this.binaryLookup[byte], "");
-        const dduBinary = Array.from(this.splitString(encodedBin, bitLength));
-        const padding = bitLength - dduBinary[dduBinary.length - 1].length;
-        if (padding > 0) {
-            dduBinary[dduBinary.length - 1] += "0".repeat(padding);
-        }
-        return { dduBinary, padding };
-    }
-    dduBinaryToBuffer(decodedBin, paddingBits) {
-        if (paddingBits > 0) {
-            decodedBin = decodedBin.slice(0, -paddingBits);
-        }
-        const buffer = [];
-        for (let i = 0; i < decodedBin.length; i += 8) {
-            buffer.push(parseInt(decodedBin.slice(i, i + 8), 2));
-        }
-        return Buffer.from(buffer);
-    }
-    encode(input, options = {}) {
-        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = true, } = options;
-        const bufferInput = typeof input === "string" ? Buffer.from(input, encoding) : input;
-        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
-        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
-        let resultString = "";
-        for (const binaryChunk of dduBinary) {
-            const charInt = parseInt(binaryChunk, 2);
-            if (usePowerOfTwo) {
-                resultString += dduSet[charInt];
-            }
-            else {
-                const quotient = Math.floor(charInt / dduLength);
-                const remainder = charInt % dduLength;
-                resultString += dduSet[quotient] + dduSet[remainder];
-            }
-        }
-        return padding > 0
-            ? resultString + padChar.repeat(Math.floor(padding / 2))
-            : resultString;
-    }
-    decode(input, options = {}) {
-        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = true, } = options;
-        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
-        const paddingCount = (input.match(paddingRegExp) || []).length;
-        const paddingBits = paddingCount * 2;
-        input = input.replace(paddingRegExp, "");
-        let dduBinary = "";
-        for (let i = 0; i < input.length; i += usePowerOfTwo ? 1 : 2) {
-            const firstChar = input[i];
-            const secondChar = input[i + 1];
-            if (usePowerOfTwo) {
-                const charIndex = lookupTable.get(firstChar);
-                if (charIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar}`);
-                dduBinary += charIndex.toString(2).padStart(bitLength, "0");
-            }
-            else {
-                const firstIndex = lookupTable.get(firstChar);
-                const secondIndex = lookupTable.get(secondChar);
-                if (firstIndex === undefined || secondIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
-                const value = firstIndex * dduLength + secondIndex;
-                dduBinary += value.toString(2).padStart(bitLength, "0");
-            }
-        }
-        const decoded = this.dduBinaryToBuffer(dduBinary, usePowerOfTwo ? paddingBits : paddingCount * bitLength);
-        return decoded.toString(encoding);
-    }
-}
-exports.Custom64 = Custom64;
+exports.Ddu1024 = exports.Ddu512 = exports.Ddu128 = exports.Custom64 = exports.Ddu64 = void 0;
+var Ddu64_js_1 = require("./Ddu64.js");
+Object.defineProperty(exports, "Ddu64", { enumerable: true, get: function () { return Ddu64_js_1.Ddu64; } });
+var Custom64_js_1 = require("./Custom64.js");
+Object.defineProperty(exports, "Custom64", { enumerable: true, get: function () { return Custom64_js_1.Custom64; } });
+var Ddu128_js_1 = require("./Ddu128.js");
+Object.defineProperty(exports, "Ddu128", { enumerable: true, get: function () { return Ddu128_js_1.Ddu128; } });
+var Ddu512_js_1 = require("./Ddu512.js");
+Object.defineProperty(exports, "Ddu512", { enumerable: true, get: function () { return Ddu512_js_1.Ddu512; } });
+var Ddu1024_js_1 = require("./Ddu1024.js");
+Object.defineProperty(exports, "Ddu1024", { enumerable: true, get: function () { return Ddu1024_js_1.Ddu1024; } });

package/dist/mjs/Custom64.d.ts

@@ -0,0 +1,29 @@
+export declare class Custom64 {
+    private readonly dduChar;
+    private readonly paddingChar;
+    private readonly dduCharDefault;
+    private readonly paddingCharDefault;
+    private readonly defaultEncoding;
+    private readonly bitLengthMap;
+    private readonly binaryLookup;
+    private readonly dduBinaryLookup;
+    private readonly dduBinaryLookupKr;
+    private readonly paddingRegex;
+    constructor(dduChar?: string[] | string, paddingChar?: string);
+    private getBitLength;
+    private getLargestPowerOfTwo;
+    private splitString;
+    private getSelectedSets;
+    private bufferToDduBinary;
+    private dduBinaryToBuffer;
+    encode(input: Buffer | string, options?: {
+        dduSetSymbol?: string;
+        encoding?: BufferEncoding;
+        usePowerOfTwo?: boolean;
+    }): string;
+    decode(input: string, options?: {
+        dduSetSymbol?: string;
+        encoding?: BufferEncoding;
+        usePowerOfTwo?: boolean;
+    }): string;
+}

package/dist/mjs/Custom64.js

@@ -0,0 +1,203 @@
+export class Custom64 {
+    dduChar;
+    paddingChar;
+    dduCharDefault = [
+        "A",
+        "s",
+        "q",
+        "r",
+        "0",
+        "z",
+        "3",
+        "t",
+        "y",
+        "1",
+        "5",
+        "2",
+        "4",
+        "E",
+        "B",
+        "C",
+        "Q",
+        "F",
+        "R",
+        "T",
+        "U",
+        "W",
+        "V",
+        "X",
+        "Y",
+        "Z",
+        "b",
+        "a",
+        "c",
+        "d",
+        "D",
+        "G",
+        "L",
+        "H",
+        "I",
+        "-",
+        "J",
+        "K",
+        "M",
+        "O",
+        "N",
+        "f",
+        "e",
+        "h",
+        "g",
+        "P",
+        "i",
+        "S",
+        "k",
+        "l",
+        "m",
+        "u",
+        "j",
+        "v",
+        "n",
+        "o",
+        "p",
+        "9",
+        "w",
+        "6",
+        "7",
+        "8",
+        "x",
+        "_",
+    ];
+    paddingCharDefault = "=";
+    defaultEncoding = "utf-8";
+    bitLengthMap = new Map();
+    binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
+    dduBinaryLookup = new Map();
+    dduBinaryLookupKr = new Map();
+    paddingRegex = new Map();
+    constructor(dduChar, paddingChar) {
+        if (typeof dduChar === "string") {
+            const removeDuplicatesString = [...new Set(dduChar.trim())].join("");
+            this.dduChar = removeDuplicatesString.trim().split("");
+        }
+        else {
+            this.dduChar = dduChar || this.dduCharDefault;
+        }
+        this.paddingChar = paddingChar || this.paddingCharDefault;
+        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
+        this.dduCharDefault.forEach((char, index) => this.dduBinaryLookupKr.set(char, index));
+        this.paddingRegex.set("default", new RegExp(this.paddingChar, "g"));
+        this.paddingRegex.set("KR", new RegExp(this.paddingCharDefault, "g"));
+    }
+    getBitLength(setLength) {
+        let cached = this.bitLengthMap.get(setLength);
+        if (cached === undefined) {
+            cached = Math.ceil(Math.log2(setLength));
+            this.bitLengthMap.set(setLength, cached);
+        }
+        return cached;
+    }
+    getLargestPowerOfTwo(n) {
+        return 2 ** Math.floor(Math.log2(n));
+    }
+    *splitString(s, length) {
+        for (let i = 0; i < s.length; i += length) {
+            yield s.slice(i, Math.min(i + length, s.length));
+        }
+    }
+    getSelectedSets(dduSetSymbol, usePowerOfTwo) {
+        const isKR = dduSetSymbol === "KR";
+        const dduSet = isKR ? this.dduCharDefault : this.dduChar;
+        const padChar = isKR ? this.paddingCharDefault : this.paddingChar;
+        let dduLength = dduSet.length;
+        if (usePowerOfTwo) {
+            const powerOfTwoLength = this.getLargestPowerOfTwo(dduLength);
+            dduLength = powerOfTwoLength;
+        }
+        return {
+            dduSet: usePowerOfTwo ? dduSet.slice(0, dduLength) : dduSet,
+            padChar,
+            dduLength,
+            bitLength: this.getBitLength(dduLength),
+            lookupTable: isKR ? this.dduBinaryLookupKr : this.dduBinaryLookup,
+            paddingRegExp: this.paddingRegex.get(isKR ? "KR" : "default"),
+        };
+    }
+    bufferToDduBinary(input, bitLength) {
+        const encodedBin = input.reduce((acc, byte) => acc + this.binaryLookup[byte], "");
+        if (encodedBin.length === 0) {
+            return { dduBinary: [], padding: 0 };
+        }
+        const dduBinary = Array.from(this.splitString(encodedBin, bitLength));
+        const padding = bitLength - dduBinary[dduBinary.length - 1].length;
+        if (padding > 0) {
+            dduBinary[dduBinary.length - 1] += "0".repeat(padding);
+        }
+        return { dduBinary, padding };
+    }
+    dduBinaryToBuffer(decodedBin, paddingBits) {
+        if (paddingBits > 0) {
+            decodedBin = decodedBin.slice(0, -paddingBits);
+        }
+        const buffer = [];
+        for (let i = 0; i < decodedBin.length; i += 8) {
+            buffer.push(parseInt(decodedBin.slice(i, i + 8), 2));
+        }
+        return Buffer.from(buffer);
+    }
+    encode(input, options = {}) {
+        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = true, } = options;
+        const bufferInput = typeof input === "string" ? Buffer.from(input, encoding) : input;
+        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
+        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
+        let resultString = "";
+        for (const binaryChunk of dduBinary) {
+            const charInt = parseInt(binaryChunk, 2);
+            if (usePowerOfTwo) {
+                resultString += dduSet[charInt];
+            }
+            else {
+                const quotient = Math.floor(charInt / dduLength);
+                const remainder = charInt % dduLength;
+                resultString += dduSet[quotient] + dduSet[remainder];
+            }
+        }
+        // 패딩 비트 수를 padChar + 숫자로 명시 (모든 모드)
+        if (padding > 0) {
+            resultString += padChar + padding;
+        }
+        return resultString;
+    }
+    decode(input, options = {}) {
+        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = true, } = options;
+        const { dduSet, dduLength, bitLength, lookupTable, padChar, paddingRegExp } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
+        // 패딩 정보 추출: padChar 이후의 숫자가 패딩 비트 수 (모든 모드)
+        let paddingBits = 0;
+        const padCharIndex = input.indexOf(padChar);
+        if (padCharIndex >= 0) {
+            const paddingStr = input.substring(padCharIndex + padChar.length);
+            paddingBits = parseInt(paddingStr) || 0;
+            input = input.substring(0, padCharIndex);
+        }
+        let dduBinary = "";
+        for (let i = 0; i < input.length; i += usePowerOfTwo ? 1 : 2) {
+            const firstChar = input[i];
+            const secondChar = input[i + 1];
+            if (usePowerOfTwo) {
+                const charIndex = lookupTable.get(firstChar);
+                if (charIndex === undefined)
+                    throw new Error(`Invalid character: ${firstChar}`);
+                dduBinary += charIndex.toString(2).padStart(bitLength, "0");
+            }
+            else {
+                const firstIndex = lookupTable.get(firstChar);
+                const secondIndex = lookupTable.get(secondChar);
+                if (firstIndex === undefined || secondIndex === undefined)
+                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
+                const value = firstIndex * dduLength + secondIndex;
+                dduBinary += value.toString(2).padStart(bitLength, "0");
+            }
+        }
+        const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);
+        return decoded.toString(encoding);
+    }
+}

package/dist/mjs/Ddu1024.d.ts

@@ -0,0 +1,26 @@
+export declare class Ddu1024 {
+    private readonly dduChar;
+    private readonly paddingChar;
+    private readonly charLength;
+    private readonly dduCharDefault;
+    private readonly paddingCharDefault;
+    private readonly defaultEncoding;
+    private readonly binaryLookup;
+    private readonly dduBinaryLookup;
+    private readonly dduBinaryLookupKr;
+    private readonly paddingRegex;
+    constructor(dduChar?: string[], paddingChar?: string);
+    private escapeRegExp;
+    private splitString;
+    private getSelectedSets;
+    private bufferToDduBinary;
+    private dduBinaryToBuffer;
+    encode(input: Buffer | string, options?: {
+        dduSetSymbol?: string;
+        encoding?: BufferEncoding;
+    }): string;
+    decode(input: string, options?: {
+        dduSetSymbol?: string;
+        encoding?: BufferEncoding;
+    }): string;
+}