@ddunigma/node 1.0.27 → 1.1.0

package/dist/cjs/encoders/Ddu64.d.ts

@@ -0,0 +1,49 @@
+import { BaseDdu } from "../base/BaseDdu";
+import { DduConstructorOptions, DduOptions } from "../types";
+export declare class Ddu64 extends BaseDdu {
+    protected readonly dduChar: string[];
+    protected readonly paddingChar: string;
+    protected readonly charLength: number;
+    protected readonly bitLength: number;
+    protected readonly usePowerOfTwo: boolean;
+    protected readonly encoding: BufferEncoding;
+    protected readonly dduBinaryLookup: Map<string, number>;
+    private readonly isPredefinedCharSet;
+    private readonly binaryToIntLookup;
+    constructor(dduChar?: string[] | string, paddingChar?: string, dduOptions?: DduConstructorOptions);
+    /**
+     * charset 초기화 (커스텀 또는 미리 정의된 charset)
+     */
+    private initializeCharSet;
+    /**
+     * 커스텀 charset 처리
+     */
+    private processCustomCharSet;
+    /**
+     * 미리 정의된 charset 처리
+     */
+    private processPredefinedCharSet;
+    /**
+     * 기본 charset 처리
+     */
+    private processDefaultCharSet;
+    /**
+     * fallback charset 가져오기
+     */
+    private getFallbackCharSet;
+    /**
+     * string 또는 배열을 문자 배열로 변환
+     */
+    private convertToCharArray;
+    /**
+     * usePowerOfTwo 옵션 적용
+     */
+    private applyPowerOfTwoOption;
+    /**
+     * 2글자 이상의 문자셋에서 조합으로 인한 중복을 검증
+     * 예: ["AB", "CD"] + padding "AB" 또는 "A" + "B" = "AB" 같은 경우 감지
+     */
+    private validateCombinationDuplicates;
+    encode(input: Buffer | string, _options?: DduOptions): string;
+    decode(input: string, _options?: DduOptions): string;
+}

package/dist/cjs/encoders/Ddu64.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ddu64 = void 0;
+const BaseDdu_1 = require("../base/BaseDdu");
+const types_1 = require("../types");
+const charSets_1 = require("../charSets");
+class Ddu64 extends BaseDdu_1.BaseDdu {
+    constructor(dduChar, paddingChar, dduOptions) {
+        var _a, _b, _c;
+        super();
+        this.dduBinaryLookup = new Map();
+        this.binaryToIntLookup = new Map();
+        // charset 초기화
+        let finalCharSet;
+        let finalPadding;
+        let requiredLength;
+        let bitLength;
+        let isPredefined = false;
+        try {
+            const result = this.initializeCharSet(dduChar, paddingChar, dduOptions);
+            finalCharSet = result.finalCharSet;
+            finalPadding = result.finalPadding;
+            requiredLength = result.requiredLength;
+            bitLength = result.bitLength;
+            isPredefined = result.isPredefined;
+        }
+        catch (error) {
+            // useBuildErrorReturn이 true일 경우 에러를 그대로 throw
+            if ((_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.useBuildErrorReturn) !== null && _a !== void 0 ? _a : false) {
+                throw error;
+            }
+            // fallback 처리
+            const fallbackResult = this.getFallbackCharSet(dduOptions);
+            finalCharSet = fallbackResult.finalCharSet;
+            finalPadding = fallbackResult.finalPadding;
+            requiredLength = fallbackResult.requiredLength;
+            bitLength = fallbackResult.bitLength;
+            isPredefined = true; // fallback도 predefined charset 사용
+        }
+        // 유효성 검사: 최소 requiredLength개 이상의 문자 필요
+        if (finalCharSet.length < requiredLength) {
+            throw new Error(`${this.constructor.name} requires at least ${requiredLength} characters in the character set. Provided: ${finalCharSet.length}`);
+        }
+        // 첫 번째 문자의 길이를 기준으로 설정
+        this.charLength = finalCharSet[0].length;
+        // 모든 문자의 길이가 동일한지 검사
+        for (let i = 0; i < finalCharSet.length; i++) {
+            if (finalCharSet[i].length !== this.charLength) {
+                throw new Error(`All characters must have the same length. Expected: ${this.charLength}, but character at index ${i} ("${finalCharSet[i]}") has length ${finalCharSet[i].length}`);
+            }
+        }
+        // 패딩 문자 길이 검사
+        if (finalPadding.length !== this.charLength) {
+            throw new Error(`Padding character must have the same length as the characters. Expected: ${this.charLength}, but padding character has length ${finalPadding.length}`);
+        }
+        // 중복 검사
+        const uniqueChars = new Set(finalCharSet);
+        if (uniqueChars.size !== finalCharSet.length) {
+            throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${finalCharSet.length}`);
+        }
+        // 패딩 문자가 문자셋에 포함되어 있는지 검사
+        if (uniqueChars.has(finalPadding)) {
+            throw new Error(`Padding character "${finalPadding}" cannot be in the character set`);
+        }
+        // 2글자 이상의 문자셋인 경우 조합 중복 검사 (미리 정의된 charset은 건너뜀)
+        if (this.charLength >= 2 && !isPredefined) {
+            this.validateCombinationDuplicates(finalCharSet, finalPadding, requiredLength);
+        }
+        // 앞에서부터 정확히 requiredLength개만 사용
+        this.dduChar = finalCharSet.slice(0, requiredLength);
+        this.paddingChar = finalPadding;
+        this.bitLength = bitLength;
+        this.isPredefinedCharSet = isPredefined;
+        // requiredLength가 2의 제곱수인 경우 자동으로 usePowerOfTwo 활성화
+        const isPowerOfTwo = (requiredLength & (requiredLength - 1)) === 0 && requiredLength > 0;
+        this.usePowerOfTwo = isPowerOfTwo || ((_b = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) !== null && _b !== void 0 ? _b : true);
+        // encoding 설정
+        this.encoding = (_c = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.encoding) !== null && _c !== void 0 ? _c : this.defaultEncoding;
+        // 룩업 테이블 생성
+        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
+        // parseInt 최적화: 이진수 문자열 → 정수 룩업 테이블 생성
+        // 가능한 모든 비트 패턴을 미리 계산
+        // 성능 최적화: bitLength가 12 이하일 때만 룩업 테이블 사용 (4096 엔트리 이하)
+        // 그 이상은 parseInt가 더 효율적 (캐시 미스 감소)
+        const dduLength = this.dduChar.length;
+        const effectiveBitLength = this.usePowerOfTwo
+            ? this.bitLength
+            : this.getBitLength(dduLength);
+        if (effectiveBitLength <= 12) {
+            const maxValue = Math.pow(2, effectiveBitLength);
+            for (let i = 0; i < maxValue; i++) {
+                const binaryStr = i.toString(2).padStart(effectiveBitLength, "0");
+                this.binaryToIntLookup.set(binaryStr, i);
+            }
+        }
+        // effectiveBitLength > 12인 경우 룩업 테이블을 생성하지 않음 (parseInt 사용)
+    }
+    /**
+     * charset 초기화 (커스텀 또는 미리 정의된 charset)
+     */
+    initializeCharSet(dduChar, paddingChar, dduOptions) {
+        const finalDduChar = dduChar !== null && dduChar !== void 0 ? dduChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduChar;
+        const finalPaddingChar = paddingChar !== null && paddingChar !== void 0 ? paddingChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.paddingChar;
+        // 1. 커스텀 charset 사용
+        if (finalDduChar) {
+            return this.processCustomCharSet(finalDduChar, finalPaddingChar, dduOptions);
+        }
+        // 2. 미리 정의된 charset 사용
+        if (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduSetSymbol) {
+            return this.processPredefinedCharSet(dduOptions.dduSetSymbol, dduOptions);
+        }
+        // 3. 기본 charset 사용
+        return this.processDefaultCharSet();
+    }
+    /**
+     * 커스텀 charset 처리
+     */
+    processCustomCharSet(dduChar, paddingChar, dduOptions) {
+        var _a, _b;
+        if (!paddingChar) {
+            throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
+        }
+        // string 타입을 배열로 변환
+        const dduCharArray = this.convertToCharArray(dduChar);
+        const dduCharLength = (_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.requiredLength) !== null && _a !== void 0 ? _a : dduCharArray.length;
+        if (dduCharArray.length < dduCharLength) {
+            throw new Error(`dduChar must be at least ${dduCharLength} characters long. Provided: ${dduCharArray.length}`);
+        }
+        // usePowerOfTwo 처리
+        const result = this.applyPowerOfTwoOption(dduCharArray, paddingChar, dduCharLength, (_b = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) !== null && _b !== void 0 ? _b : true);
+        return Object.assign(Object.assign({}, result), { isPredefined: false // 커스텀 charset은 검증 필요
+         });
+    }
+    /**
+     * 미리 정의된 charset 처리
+     */
+    processPredefinedCharSet(symbol, dduOptions) {
+        var _a;
+        const fixedCharSet = (0, charSets_1.getCharSet)(symbol);
+        if (!fixedCharSet) {
+            throw new Error(`CharSet with symbol ${symbol} not found`);
+        }
+        const { charSet, paddingChar, maxRequiredLength, bitLength } = fixedCharSet;
+        // usePowerOfTwo 처리
+        if ((_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) !== null && _a !== void 0 ? _a : true) {
+            const result = this.applyPowerOfTwoOption(charSet, paddingChar, maxRequiredLength, true);
+            return Object.assign(Object.assign({}, result), { isPredefined: true // 미리 정의된 charset은 검증 패스
+             });
+        }
+        return {
+            finalCharSet: charSet,
+            finalPadding: paddingChar,
+            requiredLength: maxRequiredLength,
+            bitLength,
+            isPredefined: true // 미리 정의된 charset은 검증 패스
+        };
+    }
+    /**
+     * 기본 charset 처리
+     */
+    processDefaultCharSet() {
+        var _a;
+        const defaultSymbol = (_a = types_1.dduDefaultConstructorOptions.dduSetSymbol) !== null && _a !== void 0 ? _a : types_1.DduSetSymbol.DDU;
+        const fixedCharSet = (0, charSets_1.getCharSet)(defaultSymbol);
+        if (!fixedCharSet) {
+            throw new Error(`Default CharSet with symbol ${defaultSymbol} not found`);
+        }
+        return {
+            finalCharSet: fixedCharSet.charSet,
+            finalPadding: fixedCharSet.paddingChar,
+            requiredLength: fixedCharSet.maxRequiredLength,
+            bitLength: fixedCharSet.bitLength,
+            isPredefined: true // 기본 charset도 미리 정의된 것이므로 검증 패스
+        };
+    }
+    /**
+     * fallback charset 가져오기
+     */
+    getFallbackCharSet(dduOptions) {
+        var _a, _b;
+        const fallbackSymbol = (_b = (_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduSetSymbol) !== null && _a !== void 0 ? _a : types_1.dduDefaultConstructorOptions.dduSetSymbol) !== null && _b !== void 0 ? _b : types_1.DduSetSymbol.DDU;
+        const fixedCharSet = (0, charSets_1.getCharSet)(fallbackSymbol);
+        if (!fixedCharSet) {
+            throw new Error(`Fallback CharSet with symbol ${fallbackSymbol} not found`);
+        }
+        return {
+            finalCharSet: fixedCharSet.charSet,
+            finalPadding: fixedCharSet.paddingChar,
+            requiredLength: fixedCharSet.maxRequiredLength,
+            bitLength: fixedCharSet.bitLength,
+        };
+    }
+    /**
+     * string 또는 배열을 문자 배열로 변환
+     */
+    convertToCharArray(input) {
+        if (typeof input === "string") {
+            return [...new Set(input.trim())].map((c) => c);
+        }
+        return input;
+    }
+    /**
+     * usePowerOfTwo 옵션 적용
+     */
+    applyPowerOfTwoOption(charArray, padding, length, usePowerOfTwo) {
+        if (usePowerOfTwo) {
+            const powerOfTwoExponent = this.getLargestPowerOfTwoExponent(length);
+            const powerOfTwoLength = Math.pow(2, powerOfTwoExponent);
+            return {
+                finalCharSet: charArray.slice(0, powerOfTwoLength),
+                finalPadding: padding,
+                requiredLength: powerOfTwoLength,
+                bitLength: powerOfTwoExponent,
+            };
+        }
+        return {
+            finalCharSet: charArray.slice(0, length),
+            finalPadding: padding,
+            requiredLength: length,
+            bitLength: this.getBitLength(length),
+        };
+    }
+    /**
+     * 2글자 이상의 문자셋에서 조합으로 인한 중복을 검증
+     * 예: ["AB", "CD"] + padding "AB" 또는 "A" + "B" = "AB" 같은 경우 감지
+     */
+    validateCombinationDuplicates(charSet, paddingChar, requiredLength) {
+        const charLength = charSet[0].length;
+        const allStrings = new Set();
+        // 1. 기본 문자셋과 패딩 문자 추가
+        charSet.slice(0, requiredLength).forEach((char) => allStrings.add(char));
+        allStrings.add(paddingChar);
+        // 2. 2개 조합 검사 (charLength * 2 길이)
+        for (let i = 0; i < Math.min(charSet.length, requiredLength); i++) {
+            for (let j = 0; j < Math.min(charSet.length, requiredLength); j++) {
+                const combination = charSet[i] + charSet[j];
+                // 조합이 기존 문자와 중복되는지 확인
+                if (allStrings.has(combination)) {
+                    throw new Error(`Combination conflict detected: "${charSet[i]}" + "${charSet[j]}" = "${combination}" already exists in the character set or padding`);
+                }
+            }
+            // 문자 + 패딩 조합 검사
+            const charPlusPadding = charSet[i] + paddingChar;
+            const paddingPlusChar = paddingChar + charSet[i];
+            if (allStrings.has(charPlusPadding)) {
+                throw new Error(`Combination conflict detected: "${charSet[i]}" + padding "${paddingChar}" = "${charPlusPadding}" already exists in the character set`);
+            }
+            if (allStrings.has(paddingPlusChar)) {
+                throw new Error(`Combination conflict detected: padding "${paddingChar}" + "${charSet[i]}" = "${paddingPlusChar}" already exists in the character set`);
+            }
+        }
+        // 3. 패딩 + 패딩 조합 검사
+        const doublePadding = paddingChar + paddingChar;
+        if (allStrings.has(doublePadding)) {
+            throw new Error(`Combination conflict detected: padding "${paddingChar}" + padding "${paddingChar}" = "${doublePadding}" already exists in the character set`);
+        }
+        // 4. 3개 이상 조합 검사 (선택적, 성능을 위해 샘플링)
+        // 모든 조합을 검사하면 O(n^3)이므로 일부만 샘플링
+        if (charLength >= 2 && requiredLength <= 100) {
+            // 100개 이하일 때만 전체 검사
+            for (let i = 0; i < Math.min(charSet.length, requiredLength); i++) {
+                for (let j = 0; j < Math.min(charSet.length, requiredLength); j++) {
+                    for (let k = 0; k < Math.min(charSet.length, requiredLength); k++) {
+                        const combination = charSet[i] + charSet[j] + charSet[k];
+                        // 조합의 부분 문자열이 기존 문자와 중복되는지 확인
+                        for (let start = 0; start < combination.length - charLength + 1; start++) {
+                            const substring = combination.substring(start, start + charLength);
+                            if (allStrings.has(substring) && substring !== charSet[i] && substring !== charSet[j] && substring !== charSet[k]) {
+                                throw new Error(`Combination conflict detected: substring "${substring}" from "${charSet[i]}" + "${charSet[j]}" + "${charSet[k]}" conflicts with existing character`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    encode(input, _options) {
+        var _a;
+        // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
+        const bufferInput = typeof input === "string" ? Buffer.from(input, this.encoding) : input;
+        // 생성자에서 설정된 값 사용
+        const dduLength = this.dduChar.length;
+        const effectiveBitLength = this.usePowerOfTwo
+            ? this.bitLength
+            : this.getBitLength(dduLength);
+        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, effectiveBitLength);
+        // 문자열 연결 최적화: Array + join 사용
+        const resultParts = new Array(dduBinary.length);
+        // 각 비트 청크를 변환
+        for (let i = 0; i < dduBinary.length; i++) {
+            const binaryChunk = dduBinary[i];
+            // parseInt 최적화: 룩업 테이블 사용
+            const charInt = (_a = this.binaryToIntLookup.get(binaryChunk)) !== null && _a !== void 0 ? _a : parseInt(binaryChunk, 2);
+            if (this.charLength === 1 && !this.usePowerOfTwo) {
+                // 가변 길이 조합 인코딩
+                const quotient = Math.floor(charInt / dduLength);
+                const remainder = charInt % dduLength;
+                resultParts[i] = this.dduChar[quotient] + this.dduChar[remainder];
+            }
+            else {
+                // 고정 길이 직접 매핑
+                resultParts[i] = this.dduChar[charInt];
+            }
+        }
+        let resultString = resultParts.join("");
+        // 패딩 비트 정보를 padChar + 패딩비트수 형태로 추가
+        if (padding > 0) {
+            resultString += this.paddingChar + padding;
+        }
+        return resultString;
+    }
+    decode(input, _options) {
+        // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
+        // 패딩 정보 추출
+        let paddingBits = 0;
+        const padCharIndex = input.indexOf(this.paddingChar);
+        if (padCharIndex >= 0) {
+            const paddingStr = input.substring(padCharIndex + this.paddingChar.length);
+            paddingBits = parseInt(paddingStr) || 0;
+            input = input.substring(0, padCharIndex);
+        }
+        let dduBinary = "";
+        // 생성자에서 설정된 값 사용
+        const dduLength = this.dduChar.length;
+        const effectiveBitLength = this.usePowerOfTwo
+            ? this.bitLength
+            : this.getBitLength(dduLength);
+        if (this.charLength === 1 && !this.usePowerOfTwo) {
+            // 가변 길이 조합 디코딩 (2개씩 읽음)
+            for (let i = 0; i < input.length; i += 2) {
+                const firstChar = input[i];
+                const secondChar = input[i + 1];
+                const firstIndex = this.dduBinaryLookup.get(firstChar);
+                const secondIndex = this.dduBinaryLookup.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(effectiveBitLength, "0");
+            }
+        }
+        else {
+            // 고정 길이 직접 매핑 (charLength만큼씩 읽음)
+            for (let i = 0; i < input.length; i += this.charLength) {
+                const charChunk = input.slice(i, i + this.charLength);
+                const charIndex = this.dduBinaryLookup.get(charChunk);
+                if (charIndex === undefined)
+                    throw new Error(`Invalid character: ${charChunk}`);
+                dduBinary += charIndex.toString(2).padStart(effectiveBitLength, "0");
+            }
+        }
+        const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);
+        return decoded.toString(this.encoding);
+    }
+}
+exports.Ddu64 = Ddu64;

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

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

package/dist/cjs/encoders/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ddu64 = void 0;
+// Unified encoder (supports both fixed and variable length via usePowerOfTwo option)
+var Ddu64_1 = require("./Ddu64");
+Object.defineProperty(exports, "Ddu64", { enumerable: true, get: function () { return Ddu64_1.Ddu64; } });

package/dist/cjs/index.d.ts

@@ -1,5 +1,4 @@
-export { Ddu64 } from "./Ddu64.js";
-export { Custom64 } from "./Custom64.js";
-export { Ddu128 } from "./Ddu128.js";
-export { Ddu512 } from "./Ddu512.js";
-export { Ddu1024 } from "./Ddu1024.js";
+export type { DduOptions, BufferToDduBinaryResult, DduConstructorOptions, } from "./types";
+export { DduSetSymbol } from "./types";
+export { BaseDdu } from "./base";
+export { Ddu64 } from "./encoders";

package/dist/cjs/index.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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; } });
+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";