@ddunigma/node 1.0.26 → 1.1.0

package/dist/cjs/index.js

@@ -1,331 +1,12 @@
 "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.Ddu64 = exports.BaseDdu = exports.DduSetSymbol = void 0;
+// Export enums
+var types_1 = require("./types");
+Object.defineProperty(exports, "DduSetSymbol", { enumerable: true, get: function () { return types_1.DduSetSymbol; } });
+// Export base classes
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseDdu", { enumerable: true, get: function () { return base_1.BaseDdu; } });
+// Export encoders
+var encoders_1 = require("./encoders");
+Object.defineProperty(exports, "Ddu64", { enumerable: true, get: function () { return encoders_1.Ddu64; } });

package/dist/cjs/types/DduDefaultTypes.d.ts

@@ -0,0 +1,3 @@
+import { DduConstructorOptions } from "./DduInterface";
+declare const dduDefaultConstructorOptions: DduConstructorOptions;
+export { dduDefaultConstructorOptions };

package/dist/cjs/types/DduDefaultTypes.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dduDefaultConstructorOptions = void 0;
+const DduEnums_1 = require("./DduEnums");
+const dduDefaultConstructorOptions = {
+    dduSetSymbol: DduEnums_1.DduSetSymbol.DDU,
+    usePowerOfTwo: true,
+    requiredLength: 8,
+    bitLength: 3,
+    useBuildErrorReturn: false,
+};
+exports.dduDefaultConstructorOptions = dduDefaultConstructorOptions;

package/dist/cjs/types/DduEnums.d.ts

@@ -0,0 +1,6 @@
+export declare enum DduSetSymbol {
+    DDU = "ddu",
+    ONECHARSET = "oneCharSet",
+    TWOCHARSET = "twoCharSet",
+    THREECHARSET = "threeCharSet"
+}

package/dist/cjs/types/DduEnums.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DduSetSymbol = void 0;
+var DduSetSymbol;
+(function (DduSetSymbol) {
+    DduSetSymbol["DDU"] = "ddu";
+    DduSetSymbol["ONECHARSET"] = "oneCharSet";
+    DduSetSymbol["TWOCHARSET"] = "twoCharSet";
+    DduSetSymbol["THREECHARSET"] = "threeCharSet";
+})(DduSetSymbol || (exports.DduSetSymbol = DduSetSymbol = {}));

package/dist/cjs/types/DduInterface.d.ts

@@ -0,0 +1,24 @@
+import { DduSetSymbol } from "./DduEnums";
+export interface CharSetConfig {
+    symbol: DduSetSymbol;
+    charSet: string[];
+    maxRequiredLength: number;
+    bitLength: number;
+    paddingChar: string;
+}
+export interface DduOptions {
+}
+export interface DduConstructorOptions {
+    dduSetSymbol?: DduSetSymbol;
+    dduChar?: string[] | string;
+    paddingChar?: string;
+    requiredLength?: number;
+    bitLength?: number;
+    usePowerOfTwo?: boolean;
+    useBuildErrorReturn?: boolean;
+    encoding?: BufferEncoding;
+}
+export interface BufferToDduBinaryResult {
+    dduBinary: string[];
+    padding: number;
+}

package/dist/cjs/types/DduInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DduEnums";
+export * from "./DduInterface";
+export * from "./DduDefaultTypes";

package/dist/cjs/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DduEnums"), exports);
+__exportStar(require("./DduInterface"), exports);
+__exportStar(require("./DduDefaultTypes"), exports);

package/dist/mjs/base/BaseDdu.d.ts

@@ -0,0 +1,38 @@
+import { DduOptions, BufferToDduBinaryResult } from "../types";
+export declare abstract class BaseDdu {
+    protected readonly defaultEncoding: BufferEncoding;
+    /**
+     * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
+     */
+    protected readonly binaryLookup: string[];
+    /**
+     * 정규표현식 특수문자 이스케이프
+     */
+    protected escapeRegExp(str: string): string;
+    /**
+     * 문자열을 지정된 길이로 분할하는 제너레이터
+     */
+    protected splitString(s: string, length: number): Generator<string>;
+    /**
+     * 2의 거듭제곱 길이 계산
+     */
+    protected getLargestPowerOfTwo(n: number): number;
+    /**
+     * 2의 거듭제곱 지수 계산
+     */
+    protected getLargestPowerOfTwoExponent(n: number): number;
+    /**
+     * 비트 길이 계산
+     */
+    protected getBitLength(setLength: number): number;
+    /**
+     * Buffer를 DDU Binary 배열로 변환
+     */
+    protected bufferToDduBinary(input: Buffer, bitLength: number): BufferToDduBinaryResult;
+    /**
+     * DDU Binary를 Buffer로 변환
+     */
+    protected dduBinaryToBuffer(decodedBin: string, paddingBits: number): Buffer;
+    abstract encode(input: Buffer | string, options?: DduOptions): string;
+    abstract decode(input: string, options?: DduOptions): string;
+}

package/dist/mjs/base/BaseDdu.js

@@ -0,0 +1,72 @@
+export class BaseDdu {
+    defaultEncoding = "utf-8";
+    /**
+     * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
+     */
+    binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
+    /**
+     * 정규표현식 특수문자 이스케이프
+     */
+    escapeRegExp(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    /**
+     * 문자열을 지정된 길이로 분할하는 제너레이터
+     */
+    *splitString(s, length) {
+        for (let i = 0; i < s.length; i += length) {
+            yield s.slice(i, Math.min(i + length, s.length));
+        }
+    }
+    /**
+     * 2의 거듭제곱 길이 계산
+     */
+    getLargestPowerOfTwo(n) {
+        return 2 ** Math.floor(Math.log2(n));
+    }
+    /**
+     * 2의 거듭제곱 지수 계산
+     */
+    getLargestPowerOfTwoExponent(n) {
+        return Math.floor(Math.log2(n));
+    }
+    /**
+     * 비트 길이 계산
+     */
+    getBitLength(setLength) {
+        return Math.ceil(Math.log2(setLength));
+    }
+    /**
+     * Buffer를 DDU Binary 배열로 변환
+     */
+    bufferToDduBinary(input, bitLength) {
+        // 성능 최적화: reduce 대신 for loop + join 사용
+        if (input.length === 0) {
+            return { dduBinary: [], padding: 0 };
+        }
+        const binaryParts = new Array(input.length);
+        for (let i = 0; i < input.length; i++) {
+            binaryParts[i] = this.binaryLookup[input[i]];
+        }
+        const encodedBin = binaryParts.join("");
+        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 };
+    }
+    /**
+     * DDU Binary를 Buffer로 변환
+     */
+    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);
+    }
+}

package/dist/mjs/base/index.d.ts

@@ -0,0 +1 @@
+export { BaseDdu } from "./BaseDdu";

package/dist/mjs/base/index.js

@@ -0,0 +1 @@
+export { BaseDdu } from "./BaseDdu";

package/dist/mjs/charSets/index.d.ts

@@ -0,0 +1,4 @@
+import { CharSetConfig, DduSetSymbol } from "../types";
+export declare function getCharSet(symbol: DduSetSymbol): CharSetConfig | undefined;
+export declare function getAllSymbols(): DduSetSymbol[];
+export declare function hasCharSet(symbol: DduSetSymbol): boolean;