@ddunigma/node 1.1.2 → 1.1.3

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

@@ -9,7 +9,9 @@ export declare class Ddu64 extends BaseDdu {
     protected readonly encoding: BufferEncoding;
     protected readonly dduBinaryLookup: Map<string, number>;
     private readonly isPredefinedCharSet;
-    private readonly binaryToIntLookup;
+    private readonly effectiveBitLength;
+    private readonly binaryChunkToIntFn;
+    private readonly indexToBinaryCache;
     constructor(dduChar?: string[] | string, paddingChar?: string, dduOptions?: DduConstructorOptions);
     /**
      * charset 초기화 (커스텀 또는 미리 정의된 charset)
@@ -29,12 +31,19 @@ export declare class Ddu64 extends BaseDdu {
     private processDefaultCharSet;
     /**
      * fallback charset 가져오기
+     * 우선순위: dduOptions.dduSetSymbol > dduDefaultConstructorOptions.dduSetSymbol > DduSetSymbol.ONECHARSET
      */
     private getFallbackCharSet;
+    private normalizeCharSet;
+    private getBinaryFromIndex;
     /**
      * string 또는 배열을 문자 배열로 변환
      */
     private convertToCharArray;
+    /**
+     * 숫자가 2의 제곱수인지 확인
+     */
+    private isPowerOfTwo;
     /**
      * usePowerOfTwo 옵션 적용
      */

package/dist/cjs/encoders/Ddu64.js

@@ -9,7 +9,6 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         var _a, _b, _c;
         super();
         this.dduBinaryLookup = new Map();
-        this.binaryToIntLookup = new Map();
         // charset 초기화
         let finalCharSet;
         let finalPadding;
@@ -18,7 +17,7 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         let isPredefined = false;
         try {
             const result = this.initializeCharSet(dduChar, paddingChar, dduOptions);
-            finalCharSet = result.finalCharSet;
+            finalCharSet = [...result.finalCharSet];
             finalPadding = result.finalPadding;
             requiredLength = result.requiredLength;
             bitLength = result.bitLength;
@@ -31,69 +30,70 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
             }
             // fallback 처리
             const fallbackResult = this.getFallbackCharSet(dduOptions);
-            finalCharSet = fallbackResult.finalCharSet;
+            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 shouldThrowError = (_b = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.useBuildErrorReturn) !== null && _b !== void 0 ? _b : false;
+        const normalized = this.normalizeCharSet({
+            charSet: finalCharSet,
+            padding: finalPadding,
+            requiredLength,
+            bitLength,
+            isPredefined,
+            shouldThrowError,
+            dduOptions,
+        });
+        this.dduChar = normalized.charSet;
+        this.paddingChar = normalized.padding;
+        this.charLength = normalized.charLength;
+        this.bitLength = normalized.bitLength;
+        this.isPredefinedCharSet = normalized.isPredefined;
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.usePowerOfTwo
+        this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
+        this.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);
+        const canUseBitwise = this.effectiveBitLength <= 26;
+        if (canUseBitwise) {
+            this.binaryChunkToIntFn = (chunk) => {
+                let value = 0;
+                for (let i = 0; i < chunk.length; i++) {
+                    value = (value << 1) | (chunk.charCodeAt(i) & 1);
+                }
+                return value;
+            };
+        }
+        else {
+            this.binaryChunkToIntFn = (chunk) => {
+                let value = 0;
+                for (let i = 0; i < chunk.length; i++) {
+                    value = value * 2 + (chunk.charCodeAt(i) & 1);
+                }
+                return value;
+            };
+        }
+        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);
+        });
+        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+            this.validateCombinationDuplicates(this.dduChar, this.paddingChar, this.dduChar.length);
+        }
+        if (this.effectiveBitLength <= 16) {
+            const cacheSize = 1 << this.effectiveBitLength;
+            this.indexToBinaryCache = new Array(cacheSize);
+            for (let i = 0; i < cacheSize; i++) {
+                this.indexToBinaryCache[i] = i
+                    .toString(2)
+                    .padStart(this.effectiveBitLength, "0");
             }
         }
-        // effectiveBitLength > 12인 경우 룩업 테이블을 생성하지 않음 (parseInt 사용)
+        else {
+            this.indexToBinaryCache = null;
+        }
     }
     /**
      * charset 초기화 (커스텀 또는 미리 정의된 charset)
@@ -116,7 +116,7 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
      * 커스텀 charset 처리
      */
     processCustomCharSet(dduChar, paddingChar, dduOptions) {
-        var _a, _b;
+        var _a;
         if (!paddingChar) {
             throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
         }
@@ -127,7 +127,10 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
             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);
+        // charArray의 길이가 2의 제곱수이거나 option에 usePowerOfTwo가 명시적으로 true일 때만 적용
+        const shouldUsePowerOfTwo = (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === true ||
+            ((dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === undefined && this.isPowerOfTwo(dduCharLength));
+        const result = this.applyPowerOfTwoOption(dduCharArray, paddingChar, dduCharLength, shouldUsePowerOfTwo);
         return Object.assign(Object.assign({}, result), { isPredefined: false // 커스텀 charset은 검증 필요
          });
     }
@@ -135,14 +138,16 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
      * 미리 정의된 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) {
+        // charArray의 길이가 2의 제곱수이거나 option에 usePowerOfTwo가 명시적으로 true일 때만 적용
+        const shouldUsePowerOfTwo = (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === true ||
+            ((dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === undefined && this.isPowerOfTwo(maxRequiredLength));
+        if (shouldUsePowerOfTwo) {
             const result = this.applyPowerOfTwoOption(charSet, paddingChar, maxRequiredLength, true);
             return Object.assign(Object.assign({}, result), { isPredefined: true // 미리 정의된 charset은 검증 패스
              });
@@ -175,13 +180,25 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
     }
     /**
      * fallback charset 가져오기
+     * 우선순위: dduOptions.dduSetSymbol > dduDefaultConstructorOptions.dduSetSymbol > DduSetSymbol.ONECHARSET
      */
     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;
+        // 우선순위에 따라 fallback symbol 결정
+        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.ONECHARSET; // DDU 대신 ONECHARSET 사용
         const fixedCharSet = (0, charSets_1.getCharSet)(fallbackSymbol);
         if (!fixedCharSet) {
-            throw new Error(`Fallback CharSet with symbol ${fallbackSymbol} not found`);
+            // 최후의 fallback: ONECHARSET
+            const lastResort = (0, charSets_1.getCharSet)(types_1.DduSetSymbol.ONECHARSET);
+            if (!lastResort) {
+                throw new Error(`Critical: No fallback CharSet available`);
+            }
+            return {
+                finalCharSet: lastResort.charSet,
+                finalPadding: lastResort.paddingChar,
+                requiredLength: lastResort.maxRequiredLength,
+                bitLength: lastResort.bitLength,
+            };
         }
         return {
             finalCharSet: fixedCharSet.charSet,
@@ -190,6 +207,110 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
             bitLength: fixedCharSet.bitLength,
         };
     }
+    normalizeCharSet(params) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        let currentCharSet = [...params.charSet];
+        let currentPadding = params.padding;
+        let currentRequiredLength = params.requiredLength;
+        let currentBitLength = params.bitLength;
+        let currentIsPredefined = params.isPredefined;
+        const { shouldThrowError, dduOptions } = params;
+        let fallbackCache = null;
+        const getFallback = () => {
+            if (!fallbackCache) {
+                const fallback = this.getFallbackCharSet(dduOptions);
+                fallbackCache = {
+                    finalCharSet: [...fallback.finalCharSet],
+                    finalPadding: fallback.finalPadding,
+                    requiredLength: fallback.requiredLength,
+                    bitLength: fallback.bitLength,
+                };
+            }
+            return fallbackCache;
+        };
+        const applyFallback = () => {
+            const fallback = getFallback();
+            currentCharSet = [...fallback.finalCharSet];
+            currentPadding = fallback.finalPadding;
+            currentRequiredLength = fallback.requiredLength;
+            currentBitLength = fallback.bitLength;
+            currentIsPredefined = true;
+        };
+        const ensureMinLength = () => {
+            if (currentCharSet.length < currentRequiredLength) {
+                if (shouldThrowError) {
+                    throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: ${currentCharSet.length}`);
+                }
+                applyFallback();
+            }
+        };
+        if (!currentIsPredefined) {
+            const uniqueChars = new Set(currentCharSet);
+            if (uniqueChars.size !== currentCharSet.length) {
+                if (shouldThrowError) {
+                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${currentCharSet.length}`);
+                }
+                currentCharSet = Array.from(uniqueChars);
+            }
+        }
+        ensureMinLength();
+        let charLength = (_b = (_a = currentCharSet[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        if (charLength === 0) {
+            if (shouldThrowError) {
+                throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: ${currentCharSet.length}`);
+            }
+            applyFallback();
+            charLength = (_d = (_c = currentCharSet[0]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+        }
+        const invalidIndex = currentCharSet.findIndex((char) => char.length !== charLength);
+        if (invalidIndex !== -1) {
+            if (shouldThrowError) {
+                throw new Error(`All characters must have the same length. Expected: ${charLength}, but character at index ${invalidIndex} ("${currentCharSet[invalidIndex]}") has length ${currentCharSet[invalidIndex].length}`);
+            }
+            currentCharSet = currentCharSet.filter((char) => char.length === charLength);
+            ensureMinLength();
+            charLength = (_f = (_e = currentCharSet[0]) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
+        }
+        if (!currentCharSet.length) {
+            if (shouldThrowError) {
+                throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: 0`);
+            }
+            applyFallback();
+            charLength = (_h = (_g = currentCharSet[0]) === null || _g === void 0 ? void 0 : _g.length) !== null && _h !== void 0 ? _h : 0;
+        }
+        if (currentPadding.length !== charLength) {
+            if (shouldThrowError) {
+                throw new Error(`Padding character must have the same length as the characters. Expected: ${charLength}, but padding character has length ${currentPadding.length}`);
+            }
+            applyFallback();
+            charLength = (_k = (_j = currentCharSet[0]) === null || _j === void 0 ? void 0 : _j.length) !== null && _k !== void 0 ? _k : 0;
+        }
+        const charSetLookup = new Set(currentCharSet);
+        if (charSetLookup.has(currentPadding)) {
+            if (shouldThrowError) {
+                throw new Error(`Padding character "${currentPadding}" cannot be in the character set`);
+            }
+            currentCharSet = currentCharSet.filter((char) => char !== currentPadding);
+            ensureMinLength();
+            charLength = (_m = (_l = currentCharSet[0]) === null || _l === void 0 ? void 0 : _l.length) !== null && _m !== void 0 ? _m : 0;
+        }
+        currentCharSet = currentCharSet.slice(0, currentRequiredLength);
+        return {
+            charSet: currentCharSet,
+            padding: currentPadding,
+            requiredLength: currentRequiredLength,
+            bitLength: currentBitLength,
+            isPredefined: currentIsPredefined,
+            charLength,
+        };
+    }
+    getBinaryFromIndex(index) {
+        const cache = this.indexToBinaryCache;
+        if (cache && index < cache.length) {
+            return cache[index];
+        }
+        return index.toString(2).padStart(this.effectiveBitLength, "0");
+    }
     /**
      * string 또는 배열을 문자 배열로 변환
      */
@@ -199,6 +320,12 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         }
         return input;
     }
+    /**
+     * 숫자가 2의 제곱수인지 확인
+     */
+    isPowerOfTwo(n) {
+        return n > 0 && (n & (n - 1)) === 0;
+    }
     /**
      * usePowerOfTwo 옵션 적용
      */
@@ -275,22 +402,18 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         }
     }
     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 effectiveBitLength = this.effectiveBitLength;
         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);
+            const charInt = this.binaryChunkToIntFn(binaryChunk);
             if (this.charLength === 1 && !this.usePowerOfTwo) {
                 // 가변 길이 조합 인코딩
                 const quotient = Math.floor(charInt / dduLength);
@@ -322,9 +445,7 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
         let dduBinary = "";
         // 생성자에서 설정된 값 사용
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.usePowerOfTwo
-            ? this.bitLength
-            : this.getBitLength(dduLength);
+        const effectiveBitLength = this.effectiveBitLength;
         if (this.charLength === 1 && !this.usePowerOfTwo) {
             // 가변 길이 조합 디코딩 (2개씩 읽음)
             for (let i = 0; i < input.length; i += 2) {
@@ -335,7 +456,7 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
                 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");
+                dduBinary += this.getBinaryFromIndex(value);
             }
         }
         else {
@@ -345,7 +466,7 @@ class Ddu64 extends BaseDdu_1.BaseDdu {
                 const charIndex = this.dduBinaryLookup.get(charChunk);
                 if (charIndex === undefined)
                     throw new Error(`Invalid character: ${charChunk}`);
-                dduBinary += charIndex.toString(2).padStart(effectiveBitLength, "0");
+                dduBinary += this.getBinaryFromIndex(charIndex);
             }
         }
         const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);

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

@@ -9,7 +9,9 @@ export declare class Ddu64 extends BaseDdu {
     protected readonly encoding: BufferEncoding;
     protected readonly dduBinaryLookup: Map<string, number>;
     private readonly isPredefinedCharSet;
-    private readonly binaryToIntLookup;
+    private readonly effectiveBitLength;
+    private readonly binaryChunkToIntFn;
+    private readonly indexToBinaryCache;
     constructor(dduChar?: string[] | string, paddingChar?: string, dduOptions?: DduConstructorOptions);
     /**
      * charset 초기화 (커스텀 또는 미리 정의된 charset)
@@ -29,12 +31,19 @@ export declare class Ddu64 extends BaseDdu {
     private processDefaultCharSet;
     /**
      * fallback charset 가져오기
+     * 우선순위: dduOptions.dduSetSymbol > dduDefaultConstructorOptions.dduSetSymbol > DduSetSymbol.ONECHARSET
      */
     private getFallbackCharSet;
+    private normalizeCharSet;
+    private getBinaryFromIndex;
     /**
      * string 또는 배열을 문자 배열로 변환
      */
     private convertToCharArray;
+    /**
+     * 숫자가 2의 제곱수인지 확인
+     */
+    private isPowerOfTwo;
     /**
      * usePowerOfTwo 옵션 적용
      */

package/dist/mjs/encoders/Ddu64.js

@@ -10,7 +10,9 @@ export class Ddu64 extends BaseDdu {
     encoding;
     dduBinaryLookup = new Map();
     isPredefinedCharSet;
-    binaryToIntLookup = new Map();
+    effectiveBitLength;
+    binaryChunkToIntFn;
+    indexToBinaryCache;
     constructor(dduChar, paddingChar, dduOptions) {
         super();
         // charset 초기화
@@ -21,7 +23,7 @@ export class Ddu64 extends BaseDdu {
         let isPredefined = false;
         try {
             const result = this.initializeCharSet(dduChar, paddingChar, dduOptions);
-            finalCharSet = result.finalCharSet;
+            finalCharSet = [...result.finalCharSet];
             finalPadding = result.finalPadding;
             requiredLength = result.requiredLength;
             bitLength = result.bitLength;
@@ -34,69 +36,70 @@ export class Ddu64 extends BaseDdu {
             }
             // fallback 처리
             const fallbackResult = this.getFallbackCharSet(dduOptions);
-            finalCharSet = fallbackResult.finalCharSet;
+            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 || (dduOptions?.usePowerOfTwo ?? true);
-        // encoding 설정
-        this.encoding = dduOptions?.encoding ?? this.defaultEncoding;
-        // 룩업 테이블 생성
-        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
-        // parseInt 최적화: 이진수 문자열 → 정수 룩업 테이블 생성
-        // 가능한 모든 비트 패턴을 미리 계산
-        // 성능 최적화: bitLength가 12 이하일 때만 룩업 테이블 사용 (4096 엔트리 이하)
-        // 그 이상은 parseInt가 더 효율적 (캐시 미스 감소)
+        const shouldThrowError = dduOptions?.useBuildErrorReturn ?? false;
+        const normalized = this.normalizeCharSet({
+            charSet: finalCharSet,
+            padding: finalPadding,
+            requiredLength,
+            bitLength,
+            isPredefined,
+            shouldThrowError,
+            dduOptions,
+        });
+        this.dduChar = normalized.charSet;
+        this.paddingChar = normalized.padding;
+        this.charLength = normalized.charLength;
+        this.bitLength = normalized.bitLength;
+        this.isPredefinedCharSet = normalized.isPredefined;
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.usePowerOfTwo
+        this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
+        this.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);
+        const canUseBitwise = this.effectiveBitLength <= 26;
+        if (canUseBitwise) {
+            this.binaryChunkToIntFn = (chunk) => {
+                let value = 0;
+                for (let i = 0; i < chunk.length; i++) {
+                    value = (value << 1) | (chunk.charCodeAt(i) & 1);
+                }
+                return value;
+            };
+        }
+        else {
+            this.binaryChunkToIntFn = (chunk) => {
+                let value = 0;
+                for (let i = 0; i < chunk.length; i++) {
+                    value = value * 2 + (chunk.charCodeAt(i) & 1);
+                }
+                return value;
+            };
+        }
+        this.encoding = dduOptions?.encoding ?? this.defaultEncoding;
+        this.dduChar.forEach((char, index) => {
+            this.dduBinaryLookup.set(char, index);
+        });
+        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+            this.validateCombinationDuplicates(this.dduChar, this.paddingChar, this.dduChar.length);
+        }
+        if (this.effectiveBitLength <= 16) {
+            const cacheSize = 1 << this.effectiveBitLength;
+            this.indexToBinaryCache = new Array(cacheSize);
+            for (let i = 0; i < cacheSize; i++) {
+                this.indexToBinaryCache[i] = i
+                    .toString(2)
+                    .padStart(this.effectiveBitLength, "0");
             }
         }
-        // effectiveBitLength > 12인 경우 룩업 테이블을 생성하지 않음 (parseInt 사용)
+        else {
+            this.indexToBinaryCache = null;
+        }
     }
     /**
      * charset 초기화 (커스텀 또는 미리 정의된 charset)
@@ -129,7 +132,10 @@ export class Ddu64 extends BaseDdu {
             throw new Error(`dduChar must be at least ${dduCharLength} characters long. Provided: ${dduCharArray.length}`);
         }
         // usePowerOfTwo 처리
-        const result = this.applyPowerOfTwoOption(dduCharArray, paddingChar, dduCharLength, dduOptions?.usePowerOfTwo ?? true);
+        // charArray의 길이가 2의 제곱수이거나 option에 usePowerOfTwo가 명시적으로 true일 때만 적용
+        const shouldUsePowerOfTwo = dduOptions?.usePowerOfTwo === true ||
+            (dduOptions?.usePowerOfTwo === undefined && this.isPowerOfTwo(dduCharLength));
+        const result = this.applyPowerOfTwoOption(dduCharArray, paddingChar, dduCharLength, shouldUsePowerOfTwo);
         return {
             ...result,
             isPredefined: false // 커스텀 charset은 검증 필요
@@ -145,7 +151,10 @@ export class Ddu64 extends BaseDdu {
         }
         const { charSet, paddingChar, maxRequiredLength, bitLength } = fixedCharSet;
         // usePowerOfTwo 처리
-        if (dduOptions?.usePowerOfTwo ?? true) {
+        // charArray의 길이가 2의 제곱수이거나 option에 usePowerOfTwo가 명시적으로 true일 때만 적용
+        const shouldUsePowerOfTwo = dduOptions?.usePowerOfTwo === true ||
+            (dduOptions?.usePowerOfTwo === undefined && this.isPowerOfTwo(maxRequiredLength));
+        if (shouldUsePowerOfTwo) {
             const result = this.applyPowerOfTwoOption(charSet, paddingChar, maxRequiredLength, true);
             return {
                 ...result,
@@ -179,14 +188,26 @@ export class Ddu64 extends BaseDdu {
     }
     /**
      * fallback charset 가져오기
+     * 우선순위: dduOptions.dduSetSymbol > dduDefaultConstructorOptions.dduSetSymbol > DduSetSymbol.ONECHARSET
      */
     getFallbackCharSet(dduOptions) {
+        // 우선순위에 따라 fallback symbol 결정
         const fallbackSymbol = dduOptions?.dduSetSymbol ??
             dduDefaultConstructorOptions.dduSetSymbol ??
-            DduSetSymbol.DDU;
+            DduSetSymbol.ONECHARSET; // DDU 대신 ONECHARSET 사용
         const fixedCharSet = getCharSet(fallbackSymbol);
         if (!fixedCharSet) {
-            throw new Error(`Fallback CharSet with symbol ${fallbackSymbol} not found`);
+            // 최후의 fallback: ONECHARSET
+            const lastResort = getCharSet(DduSetSymbol.ONECHARSET);
+            if (!lastResort) {
+                throw new Error(`Critical: No fallback CharSet available`);
+            }
+            return {
+                finalCharSet: lastResort.charSet,
+                finalPadding: lastResort.paddingChar,
+                requiredLength: lastResort.maxRequiredLength,
+                bitLength: lastResort.bitLength,
+            };
         }
         return {
             finalCharSet: fixedCharSet.charSet,
@@ -195,6 +216,109 @@ export class Ddu64 extends BaseDdu {
             bitLength: fixedCharSet.bitLength,
         };
     }
+    normalizeCharSet(params) {
+        let currentCharSet = [...params.charSet];
+        let currentPadding = params.padding;
+        let currentRequiredLength = params.requiredLength;
+        let currentBitLength = params.bitLength;
+        let currentIsPredefined = params.isPredefined;
+        const { shouldThrowError, dduOptions } = params;
+        let fallbackCache = null;
+        const getFallback = () => {
+            if (!fallbackCache) {
+                const fallback = this.getFallbackCharSet(dduOptions);
+                fallbackCache = {
+                    finalCharSet: [...fallback.finalCharSet],
+                    finalPadding: fallback.finalPadding,
+                    requiredLength: fallback.requiredLength,
+                    bitLength: fallback.bitLength,
+                };
+            }
+            return fallbackCache;
+        };
+        const applyFallback = () => {
+            const fallback = getFallback();
+            currentCharSet = [...fallback.finalCharSet];
+            currentPadding = fallback.finalPadding;
+            currentRequiredLength = fallback.requiredLength;
+            currentBitLength = fallback.bitLength;
+            currentIsPredefined = true;
+        };
+        const ensureMinLength = () => {
+            if (currentCharSet.length < currentRequiredLength) {
+                if (shouldThrowError) {
+                    throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: ${currentCharSet.length}`);
+                }
+                applyFallback();
+            }
+        };
+        if (!currentIsPredefined) {
+            const uniqueChars = new Set(currentCharSet);
+            if (uniqueChars.size !== currentCharSet.length) {
+                if (shouldThrowError) {
+                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${currentCharSet.length}`);
+                }
+                currentCharSet = Array.from(uniqueChars);
+            }
+        }
+        ensureMinLength();
+        let charLength = currentCharSet[0]?.length ?? 0;
+        if (charLength === 0) {
+            if (shouldThrowError) {
+                throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: ${currentCharSet.length}`);
+            }
+            applyFallback();
+            charLength = currentCharSet[0]?.length ?? 0;
+        }
+        const invalidIndex = currentCharSet.findIndex((char) => char.length !== charLength);
+        if (invalidIndex !== -1) {
+            if (shouldThrowError) {
+                throw new Error(`All characters must have the same length. Expected: ${charLength}, but character at index ${invalidIndex} ("${currentCharSet[invalidIndex]}") has length ${currentCharSet[invalidIndex].length}`);
+            }
+            currentCharSet = currentCharSet.filter((char) => char.length === charLength);
+            ensureMinLength();
+            charLength = currentCharSet[0]?.length ?? 0;
+        }
+        if (!currentCharSet.length) {
+            if (shouldThrowError) {
+                throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: 0`);
+            }
+            applyFallback();
+            charLength = currentCharSet[0]?.length ?? 0;
+        }
+        if (currentPadding.length !== charLength) {
+            if (shouldThrowError) {
+                throw new Error(`Padding character must have the same length as the characters. Expected: ${charLength}, but padding character has length ${currentPadding.length}`);
+            }
+            applyFallback();
+            charLength = currentCharSet[0]?.length ?? 0;
+        }
+        const charSetLookup = new Set(currentCharSet);
+        if (charSetLookup.has(currentPadding)) {
+            if (shouldThrowError) {
+                throw new Error(`Padding character "${currentPadding}" cannot be in the character set`);
+            }
+            currentCharSet = currentCharSet.filter((char) => char !== currentPadding);
+            ensureMinLength();
+            charLength = currentCharSet[0]?.length ?? 0;
+        }
+        currentCharSet = currentCharSet.slice(0, currentRequiredLength);
+        return {
+            charSet: currentCharSet,
+            padding: currentPadding,
+            requiredLength: currentRequiredLength,
+            bitLength: currentBitLength,
+            isPredefined: currentIsPredefined,
+            charLength,
+        };
+    }
+    getBinaryFromIndex(index) {
+        const cache = this.indexToBinaryCache;
+        if (cache && index < cache.length) {
+            return cache[index];
+        }
+        return index.toString(2).padStart(this.effectiveBitLength, "0");
+    }
     /**
      * string 또는 배열을 문자 배열로 변환
      */
@@ -204,6 +328,12 @@ export class Ddu64 extends BaseDdu {
         }
         return input;
     }
+    /**
+     * 숫자가 2의 제곱수인지 확인
+     */
+    isPowerOfTwo(n) {
+        return n > 0 && (n & (n - 1)) === 0;
+    }
     /**
      * usePowerOfTwo 옵션 적용
      */
@@ -284,17 +414,14 @@ export class Ddu64 extends BaseDdu {
         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 effectiveBitLength = this.effectiveBitLength;
         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 = this.binaryToIntLookup.get(binaryChunk) ?? parseInt(binaryChunk, 2);
+            const charInt = this.binaryChunkToIntFn(binaryChunk);
             if (this.charLength === 1 && !this.usePowerOfTwo) {
                 // 가변 길이 조합 인코딩
                 const quotient = Math.floor(charInt / dduLength);
@@ -326,9 +453,7 @@ export class Ddu64 extends BaseDdu {
         let dduBinary = "";
         // 생성자에서 설정된 값 사용
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.usePowerOfTwo
-            ? this.bitLength
-            : this.getBitLength(dduLength);
+        const effectiveBitLength = this.effectiveBitLength;
         if (this.charLength === 1 && !this.usePowerOfTwo) {
             // 가변 길이 조합 디코딩 (2개씩 읽음)
             for (let i = 0; i < input.length; i += 2) {
@@ -339,7 +464,7 @@ export class Ddu64 extends BaseDdu {
                 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");
+                dduBinary += this.getBinaryFromIndex(value);
             }
         }
         else {
@@ -349,7 +474,7 @@ export class Ddu64 extends BaseDdu {
                 const charIndex = this.dduBinaryLookup.get(charChunk);
                 if (charIndex === undefined)
                     throw new Error(`Invalid character: ${charChunk}`);
-                dduBinary += charIndex.toString(2).padStart(effectiveBitLength, "0");
+                dduBinary += this.getBinaryFromIndex(charIndex);
             }
         }
         const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddunigma/node",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/index.d.ts",