@ddunigma/node 1.1.2 → 1.1.4

package/README.md

@@ -1,92 +1,80 @@
-## ddunigma-node
+# DDU ENIGMA - Node.js
 
-### Overview
+데이터를 특정 문자셋으로 인코딩하는 Node.js 라이브러리입니다.
 
-Node.js implementation of [ddunigma](https://github.com/i3l3/ddunigma) (Python original)
+## 크레딧
 
-### Credits
+- 원본 Python 구현: [@i3ls](https://github.com/i3l3), [@gunu3371](https://github.com/gunu3371)
+- 원본 저장소: [ddunigma](https://github.com/i3l3/ddunigma)
 
-- Original Python Implementation by:
-  - [@i3ls](https://github.com/i3l3)
-  - [@gunu3371](https://github.com/gunu3371)
-- Original Repository: [ddunigma](https://github.com/i3l3/ddunigma)
+## 설치
 
-### Usage
+```bash
+npm install @ddunigma/node
+```
+
+## 기본 사용법
 
-- Use Basic
-```js
+### 간단한 문자열 인코딩/디코딩
+
+```typescript
 import { Ddu64 } from "@ddunigma/node";
 
-const ddu64 = new Ddu64(); //default encode utf-8
+// 커스텀 charset으로 인코더 생성
+const encoder = new Ddu64("우따야", "뭐");
+
+const text = "Hello World!";
+const encoded = encoder.encode(text);
+console.log(encoded); // 우따야뭐우따... (인코딩된 문자열)
+
+const decoded = encoder.decode(encoded);
+console.log(decoded); // "Hello World!"
+```
+
+### 미리 정의된 Charset 사용
 
-const answer = "뜌땨어 고수가 될거야!";
+```typescript
+import { Ddu64, DduSetSymbol } from "@ddunigma/node";
 
-const encoded = ddu64.encode(answer);
-console.log(encoded);
-//뜌.뜌이뜌.뜌땨뜌?뜌이뜌땨뜌야뜌.뜌이뜌.뜌땨뜌이뜌?뜌!뜌뜌뜌.뜌우뜌땨뜌땨뜌우뜌이뜌?뜌야뜌땨뜌뜌뜌땨뜌?뜌!뜌이뜌?뜌우뜌!뜌뜌뜌땨뜌?뜌?뜌이뜌땨뜌뜌뜌야뜌?뜌땨뜌?뜌!뜌이뜌?뜌뜌뜌야뜌뜌뜌뜌뜌이뜌뜌뜌우뜌!뜌우뜌야뜌야뜌땨뜌이뜌뜌뜌우뜌!뜌이뜌!뜌야뜌우뜌우뜌뜌뜌우뜌!뜌야뜌야뜌!뜌우뜌우뜌?뜌뜌뜌야뜌땨
-const decoded = ddu64.decode(encoded);
-console.log(decoded);
-//뜌땨어 고수가 될거야!
+// ONECHARSET (64개 문자)
+const encoder1 = new Ddu64(undefined, undefined, { 
+  dduSetSymbol: DduSetSymbol.ONECHARSET 
+});
 
-//Encoding Shorter
-const encodedShorter = ddu64.encode(answer, { usePowerOfTwo: true });
-console.log(encodedShorter);
-//.이.땨?이땨야.이.땨이?!뜌.우땨땨우이?야땨뜌땨?!이?우!뜌땨??이땨뜌야?땨?!이?뜌야뜌뜌이뜌우!우야야땨이뜌우!이!야우우뜌우!야야!우우?뜌야땨
-const decodedShorter = ddu64.decode(encodedShorter, { usePowerOfTwo: true });
-console.log(decodedShorter);
-//뜌땨어 고수가 될거야!
+// DDU (8개 문자)
+const encoder2 = new Ddu64(undefined, undefined, { 
+  dduSetSymbol: DduSetSymbol.DDU 
+});
+
+// TWOCHARSET (1024개 문자)
+const encoder3 = new Ddu64(undefined, undefined, { 
+  dduSetSymbol: DduSetSymbol.TWOCHARSET 
+});
+
+// THREECHARSET (32768개 문자)
+const encoder4 = new Ddu64(undefined, undefined, { 
+  dduSetSymbol: DduSetSymbol.THREECHARSET 
+});
+
+const text = "안녕하세요";
+const encoded = encoder1.encode(text);
+const decoded = encoder1.decode(encoded);
 ```
 
-- Use Custom Encoding CharSet
-```js
+### 커스텀 Charset 사용
+
+```typescript
 import { Ddu64 } from "@ddunigma/node";
+
 const koreanChars = [
-  // 뜌 계열
-  "뜌", "뜍", "뜎", "뜏", "뜐", "뜑", "뜒", "뜓", "뜔", "뜕", "뜖", "뜗", "뜘", "뜙", "뜚",
-  "뜛", "뜜", "뜝", "뜞", "뜟", "뜠", "뜡", "뜢", "뜣", "뜤", "뜥", "뜦", "뜧", "뜨", "뜩",
-  "뜪", "뜫", "뜬", "뜭", "뜮", "뜯", "뜰", "뜱", "뜲", "뜳", "뜴", "뜵", "뜶", "뜷", "뜸",
-  "뜹", "뜺", "뜻", "뜼", "뜽", "뜾", "뜿",
-  // 땨 계열
-  "땨", "땩", "땪", "땫", "땬", "땭", "땮", "땯", "땰", "땱", "땲", "땳", "땴", "땵", "땶",
-  "땷", "땸", "땹", "땺", "땻", "땼", "땽", "땾", "땿", "떀", "떁", "떂", "떃", "떄", "떅",
-  "떆", "떇", "떈", "떉", "떊", "떋", "떌", "떍", "떎", "떏", "떐", "떑", "떒", "떓", "떔",
-  "떕", "떖", "떗", "떘", "떙", "떚", "떛",
-  // 우 계열
-  "우", "욱", "욲", "욳", "운", "울", "욶", "욷", "움", "웁", "웂", "웃", "웄", "웅", "웆",
-  "웇", "워", "웍", "웎", "웏", "원", "월", "웒", "웓", "월", "웕", "웖", "웗", "웘", "웙",
-  "웚", "웛", "위", "윅", "윆", "윇", "윈", "윉", "윊", "윋", "윌", "윍", "윎", "윏", "윐",
-  "윑", "윒", "윓", "윔", "윕", "윖", 
-  // 따 계열
-  "따", "딱", "딲", "딳", "딴", "딵", "딶", "딷", "딸", "딹", "딺", "딻", "딼", "딽", "딾",
-  "딿", "땀", "땁", "땂", "땃", "땄", "땅", "땆", "땇", "땈", "땉", "땊", "땋", "때", "땍",
-  "땎", "땏", "때", "땑", "땒", "땓", "땔", "땕", "땖", "땗", "땘", "땙", "땚", "땛", "땜",
-  "땝", "땞", "땟", "땠", "땡", "땢",
-  // 야 계열
-  "야", "약", "얂", "얃", "얄", "얅", "얆", "얇", "얈", "얉", "얊", "얋", "얌", "얍", "얎",
-  "얏", "양", "양", "얒", "얓", "얔", "얕", "얖", "얗", "얘", "얙", "얚", "얛", "얜", "얝",
-  "얞", "얟", "얠", "얡", "얢", "얣", "얤", "얥", "얦", "얧", "얨", "얩", "얪", "얫", "얬",
-  "얭", "얮", "얯", "얰", "얱"
+  "뜌", "뜍", "뜎", "뜏", "뜐", "뜑", "뜒", "뜓", "뜔", "뜕", "뜖", "뜗", "뜘", "뜙", "뜚", "뜛",
+  "뜜", "뜝", "뜞", "뜟", "뜠", "뜡", "뜢", "뜣", "뜤", "뜥", "뜦", "뜧", "뜨", "뜩", "뜪", "뜫",
+  // ... 256개 문자
 ];
 
-const ddu64 = new Ddu64(koreanChars,'뭐');
-
-const answer = "안녕하세요";
-const encoded = ddu64.encode(answer);
-console.log(encoded);
-//뜌얞뜌윑뜌위뜌얝뜌웙뜌윑뜌얟뜌윑뜌윔뜌얞뜌웘뜌땍뜌얞뜌윖뜌윐
-const decoded = ddu64.decode(encoded);
-console.log(decoded);
-//안녕하세요
-
-//Encoding Shorter
-const encodedShorter = ddu64.encode(answer, { usePowerOfTwo: true });
-console.log(encodedShorter);
-//얞윑위얝웙윑얟윑윔얞웘땍얞윖윐
-const decodedShorter = ddu64.decode(encodedShorter, { usePowerOfTwo: true });
-console.log(decodedShorter);
-//안녕하세요
-```
-
-Add Ddu128, Ddu512, Ddu1024
-It's UrlSafeEncoding
+const encoder = new Ddu64(koreanChars, "뭐");
 
+const text = "안녕하세요12";
+const encoded = encoder.encode(text);
+const decoded = encoder.decode(encoded);
+```

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

@@ -9,40 +9,12 @@ 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)
-     */
-    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 normalizeCharSet;
+    private getBinaryFromIndex;
     private validateCombinationDuplicates;
     encode(input: Buffer | string, _options?: DduOptions): string;
     decode(input: string, _options?: DduOptions): string;

package/dist/cjs/encoders/Ddu64.js

@@ -6,267 +6,187 @@ const types_1 = require("../types");
 const charSets_1 = require("../charSets");
 class Ddu64 extends BaseDdu_1.BaseDdu {
     constructor(dduChar, paddingChar, dduOptions) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f, _g;
         super();
         this.dduBinaryLookup = new Map();
-        this.binaryToIntLookup = new Map();
+        const shouldThrowError = (_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.useBuildErrorReturn) !== null && _a !== void 0 ? _a : false;
+        const getCharSetFromSymbol = (symbol) => {
+            const cs = (0, charSets_1.getCharSet)(symbol);
+            if (!cs)
+                throw new Error(`CharSet with symbol ${symbol} not found`);
+            return cs;
+        };
         // charset 초기화
-        let finalCharSet;
-        let finalPadding;
-        let requiredLength;
-        let bitLength;
-        let isPredefined = false;
+        let charSet, padding, requiredLength, bitLength, isPredefined;
         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;
+            const finalDduChar = dduChar !== null && dduChar !== void 0 ? dduChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduChar;
+            const finalPadding = paddingChar !== null && paddingChar !== void 0 ? paddingChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.paddingChar;
+            if (finalDduChar) {
+                // 커스텀 charset
+                if (!finalPadding)
+                    throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
+                const arr = typeof finalDduChar === "string" ? [...new Set(finalDduChar.trim())] : finalDduChar;
+                const len = (_b = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.requiredLength) !== null && _b !== void 0 ? _b : arr.length;
+                if (arr.length < len)
+                    throw new Error(`dduChar must be at least ${len} characters long. Provided: ${arr.length}`);
+                const usePow2 = (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === true || ((dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === undefined && len > 0 && (len & (len - 1)) === 0);
+                if (usePow2) {
+                    const exp = this.getLargestPowerOfTwoExponent(len);
+                    const pow2Len = 1 << exp;
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [arr.slice(0, pow2Len), finalPadding, pow2Len, exp, false];
+                }
+                else {
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [arr.slice(0, len), finalPadding, len, this.getBitLength(len), false];
+                }
             }
-            // 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}`);
+            else if (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduSetSymbol) {
+                // 미리 정의된 charset
+                const cs = getCharSetFromSymbol(dduOptions.dduSetSymbol);
+                const usePow2 = (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === true || ((dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.usePowerOfTwo) === undefined && cs.maxRequiredLength > 0 && (cs.maxRequiredLength & (cs.maxRequiredLength - 1)) === 0);
+                if (usePow2) {
+                    const exp = this.getLargestPowerOfTwoExponent(cs.maxRequiredLength);
+                    const pow2Len = 1 << exp;
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet.slice(0, pow2Len), cs.paddingChar, pow2Len, exp, true];
+                }
+                else {
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true];
+                }
+            }
+            else {
+                // 기본 charset
+                const cs = getCharSetFromSymbol((_c = types_1.dduDefaultConstructorOptions.dduSetSymbol) !== null && _c !== void 0 ? _c : types_1.DduSetSymbol.DDU);
+                [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true];
             }
         }
-        // 패딩 문자 길이 검사
-        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);
+        catch (error) {
+            if (shouldThrowError)
+                throw error;
+            // fallback
+            const fallbackSymbol = (_e = (_d = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduSetSymbol) !== null && _d !== void 0 ? _d : types_1.dduDefaultConstructorOptions.dduSetSymbol) !== null && _e !== void 0 ? _e : types_1.DduSetSymbol.ONECHARSET;
+            const cs = (_f = (0, charSets_1.getCharSet)(fallbackSymbol)) !== null && _f !== void 0 ? _f : (0, charSets_1.getCharSet)(types_1.DduSetSymbol.ONECHARSET);
+            if (!cs)
+                throw new Error(`Critical: No fallback CharSet available`);
+            [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true];
         }
-        // 앞에서부터 정확히 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 normalized = this.normalizeCharSet(charSet, padding, 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;
+        this.encoding = (_g = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.encoding) !== null && _g !== void 0 ? _g : this.defaultEncoding;
         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);
-            }
+        this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
+        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : this.getBitLength(dduLength);
+        this.binaryChunkToIntFn = this.effectiveBitLength <= 26
+            ? (chunk) => chunk.split('').reduce((v, c) => (v << 1) | (c.charCodeAt(0) & 1), 0)
+            : (chunk) => chunk.split('').reduce((v, c) => v * 2 + (c.charCodeAt(0) & 1), 0);
+        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
+        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+            this.validateCombinationDuplicates(this.dduChar, this.paddingChar, dduLength);
         }
-        // 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);
+        if (this.effectiveBitLength <= 16) {
+            const size = 1 << this.effectiveBitLength;
+            this.indexToBinaryCache = Array.from({ length: size }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
         }
-        // 2. 미리 정의된 charset 사용
-        if (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduSetSymbol) {
-            return this.processPredefinedCharSet(dduOptions.dduSetSymbol, dduOptions);
+        else {
+            this.indexToBinaryCache = null;
         }
-        // 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}`);
+    normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions) {
+        var _a, _b, _c, _d, _e, _f;
+        const applyFallback = () => {
+            var _a, _b, _c;
+            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;
+            const cs = (_c = (0, charSets_1.getCharSet)(fallbackSymbol)) !== null && _c !== void 0 ? _c : (0, charSets_1.getCharSet)(types_1.DduSetSymbol.ONECHARSET);
+            if (!cs)
+                throw new Error(`Critical: No fallback CharSet available`);
+            return { charSet: cs.charSet, padding: cs.paddingChar, requiredLength: cs.maxRequiredLength, bitLength: cs.bitLength, isPredefined: true };
+        };
+        const validate = (condition, message) => {
+            if (condition) {
+                if (shouldThrowError)
+                    throw new Error(message);
+                const fb = applyFallback();
+                [charSet, padding, requiredLength, bitLength, isPredefined] = [fb.charSet, fb.padding, fb.requiredLength, fb.bitLength, fb.isPredefined];
+                return true;
+            }
+            return false;
+        };
+        // 중복 제거 (커스텀 charset만)
+        if (!isPredefined) {
+            const uniqueChars = new Set(charSet);
+            if (uniqueChars.size !== charSet.length) {
+                if (shouldThrowError)
+                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${charSet.length}`);
+                charSet = Array.from(uniqueChars);
+                requiredLength = charSet.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`);
+        // 검증
+        if (validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`)) {
+            return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
         }
-        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은 검증 패스
-             });
+        let charLength = (_b = (_a = charSet[0]) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        validate(charLength === 0, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+        const invalidIndex = charSet.findIndex(char => char.length !== charLength);
+        if (invalidIndex !== -1) {
+            if (shouldThrowError)
+                throw new Error(`All characters must have the same length. Expected: ${charLength}, but index ${invalidIndex} has length ${charSet[invalidIndex].length}`);
+            charSet = charSet.filter(char => char.length === charLength);
+            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            charLength = (_d = (_c = charSet[0]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
         }
-        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`);
+        validate(!charSet.length, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: 0`);
+        validate(padding.length !== charLength, `Padding character must have length ${charLength}, got ${padding.length}`);
+        if (new Set(charSet).has(padding)) {
+            if (shouldThrowError)
+                throw new Error(`Padding character "${padding}" cannot be in the character set`);
+            charSet = charSet.filter(char => char !== padding);
+            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            charLength = (_f = (_e = charSet[0]) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
         }
-        return {
-            finalCharSet: fixedCharSet.charSet,
-            finalPadding: fixedCharSet.paddingChar,
-            requiredLength: fixedCharSet.maxRequiredLength,
-            bitLength: fixedCharSet.bitLength,
-            isPredefined: true // 기본 charset도 미리 정의된 것이므로 검증 패스
-        };
+        return { charSet: charSet.slice(0, requiredLength), padding, requiredLength, bitLength, isPredefined, charLength };
     }
-    /**
-     * fallback charset 가져오기
-     */
-    getFallbackCharSet(dduOptions) {
+    getBinaryFromIndex(index) {
         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;
+        return (_b = (_a = this.indexToBinaryCache) === null || _a === void 0 ? void 0 : _a[index]) !== null && _b !== void 0 ? _b : index.toString(2).padStart(this.effectiveBitLength, "0");
     }
-    /**
-     * 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 allStrings = new Set([...charSet.slice(0, requiredLength), paddingChar]);
+        const limit = Math.min(charSet.length, requiredLength);
+        // 2개 조합 검사
+        for (let i = 0; i < limit; i++) {
+            for (let j = 0; j < limit; j++) {
+                const combo = charSet[i] + charSet[j];
+                if (allStrings.has(combo)) {
+                    throw new Error(`Combination conflict: "${charSet[i]}" + "${charSet[j]}" = "${combo}" already exists`);
                 }
             }
-            // 문자 + 패딩 조합 검사
-            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`);
-            }
+            const charPad = charSet[i] + paddingChar;
+            const padChar = paddingChar + charSet[i];
+            if (allStrings.has(charPad))
+                throw new Error(`Combination conflict: "${charSet[i]}" + padding "${paddingChar}" = "${charPad}"`);
+            if (allStrings.has(padChar))
+                throw new Error(`Combination conflict: padding "${paddingChar}" + "${charSet[i]}" = "${padChar}"`);
         }
-        // 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`);
+        // 패딩 + 패딩 조합 검사
+        const doublePad = paddingChar + paddingChar;
+        if (allStrings.has(doublePad)) {
+            throw new Error(`Combination conflict: double padding "${doublePad}" already exists`);
         }
-        // 4. 3개 이상 조합 검사 (선택적, 성능을 위해 샘플링)
-        // 모든 조합을 검사하면 O(n^3)이므로 일부만 샘플링
+        // 3개 조합 검사 (100개 이하만)
         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`);
+            for (let i = 0; i < limit; i++) {
+                for (let j = 0; j < limit; j++) {
+                    for (let k = 0; k < limit; k++) {
+                        const combo = charSet[i] + charSet[j] + charSet[k];
+                        for (let start = 0; start <= combo.length - charLength; start++) {
+                            const sub = combo.substring(start, start + charLength);
+                            if (allStrings.has(sub) && sub !== charSet[i] && sub !== charSet[j] && sub !== charSet[k]) {
+                                throw new Error(`Combination conflict: substring "${sub}" from "${charSet[i]}" + "${charSet[j]}" + "${charSet[k]}"`);
                             }
                         }
                     }
@@ -275,22 +195,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 +238,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 +249,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 +259,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,40 +9,12 @@ 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)
-     */
-    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 normalizeCharSet;
+    private getBinaryFromIndex;
     private validateCombinationDuplicates;
     encode(input: Buffer | string, _options?: DduOptions): string;
     decode(input: string, _options?: DduOptions): string;

package/dist/mjs/encoders/Ddu64.js

@@ -10,268 +10,186 @@ export class Ddu64 extends BaseDdu {
     encoding;
     dduBinaryLookup = new Map();
     isPredefinedCharSet;
-    binaryToIntLookup = new Map();
+    effectiveBitLength;
+    binaryChunkToIntFn;
+    indexToBinaryCache;
     constructor(dduChar, paddingChar, dduOptions) {
         super();
+        const shouldThrowError = dduOptions?.useBuildErrorReturn ?? false;
+        const getCharSetFromSymbol = (symbol) => {
+            const cs = getCharSet(symbol);
+            if (!cs)
+                throw new Error(`CharSet with symbol ${symbol} not found`);
+            return cs;
+        };
         // charset 초기화
-        let finalCharSet;
-        let finalPadding;
-        let requiredLength;
-        let bitLength;
-        let isPredefined = false;
+        let charSet, padding, requiredLength, bitLength, isPredefined;
         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 (dduOptions?.useBuildErrorReturn ?? false) {
-                throw error;
+            const finalDduChar = dduChar ?? dduOptions?.dduChar;
+            const finalPadding = paddingChar ?? dduOptions?.paddingChar;
+            if (finalDduChar) {
+                // 커스텀 charset
+                if (!finalPadding)
+                    throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
+                const arr = typeof finalDduChar === "string" ? [...new Set(finalDduChar.trim())] : finalDduChar;
+                const len = dduOptions?.requiredLength ?? arr.length;
+                if (arr.length < len)
+                    throw new Error(`dduChar must be at least ${len} characters long. Provided: ${arr.length}`);
+                const usePow2 = dduOptions?.usePowerOfTwo === true || (dduOptions?.usePowerOfTwo === undefined && len > 0 && (len & (len - 1)) === 0);
+                if (usePow2) {
+                    const exp = this.getLargestPowerOfTwoExponent(len);
+                    const pow2Len = 1 << exp;
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [arr.slice(0, pow2Len), finalPadding, pow2Len, exp, false];
+                }
+                else {
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [arr.slice(0, len), finalPadding, len, this.getBitLength(len), false];
+                }
             }
-            // 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}`);
+            else if (dduOptions?.dduSetSymbol) {
+                // 미리 정의된 charset
+                const cs = getCharSetFromSymbol(dduOptions.dduSetSymbol);
+                const usePow2 = dduOptions?.usePowerOfTwo === true || (dduOptions?.usePowerOfTwo === undefined && cs.maxRequiredLength > 0 && (cs.maxRequiredLength & (cs.maxRequiredLength - 1)) === 0);
+                if (usePow2) {
+                    const exp = this.getLargestPowerOfTwoExponent(cs.maxRequiredLength);
+                    const pow2Len = 1 << exp;
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet.slice(0, pow2Len), cs.paddingChar, pow2Len, exp, true];
+                }
+                else {
+                    [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true];
+                }
+            }
+            else {
+                // 기본 charset
+                const cs = getCharSetFromSymbol(dduDefaultConstructorOptions.dduSetSymbol ?? DduSetSymbol.DDU);
+                [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true];
             }
         }
-        // 패딩 문자 길이 검사
-        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);
+        catch (error) {
+            if (shouldThrowError)
+                throw error;
+            // fallback
+            const fallbackSymbol = dduOptions?.dduSetSymbol ?? dduDefaultConstructorOptions.dduSetSymbol ?? DduSetSymbol.ONECHARSET;
+            const cs = getCharSet(fallbackSymbol) ?? getCharSet(DduSetSymbol.ONECHARSET);
+            if (!cs)
+                throw new Error(`Critical: No fallback CharSet available`);
+            [charSet, padding, requiredLength, bitLength, isPredefined] = [cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true];
         }
-        // 앞에서부터 정확히 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 설정
+        // 정규화 및 검증
+        const normalized = this.normalizeCharSet(charSet, padding, 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;
         this.encoding = dduOptions?.encoding ?? 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);
-            }
+        this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
+        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : this.getBitLength(dduLength);
+        this.binaryChunkToIntFn = this.effectiveBitLength <= 26
+            ? (chunk) => chunk.split('').reduce((v, c) => (v << 1) | (c.charCodeAt(0) & 1), 0)
+            : (chunk) => chunk.split('').reduce((v, c) => v * 2 + (c.charCodeAt(0) & 1), 0);
+        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
+        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+            this.validateCombinationDuplicates(this.dduChar, this.paddingChar, dduLength);
         }
-        // effectiveBitLength > 12인 경우 룩업 테이블을 생성하지 않음 (parseInt 사용)
-    }
-    /**
-     * charset 초기화 (커스텀 또는 미리 정의된 charset)
-     */
-    initializeCharSet(dduChar, paddingChar, dduOptions) {
-        const finalDduChar = dduChar ?? dduOptions?.dduChar;
-        const finalPaddingChar = paddingChar ?? dduOptions?.paddingChar;
-        // 1. 커스텀 charset 사용
-        if (finalDduChar) {
-            return this.processCustomCharSet(finalDduChar, finalPaddingChar, dduOptions);
+        if (this.effectiveBitLength <= 16) {
+            const size = 1 << this.effectiveBitLength;
+            this.indexToBinaryCache = Array.from({ length: size }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
         }
-        // 2. 미리 정의된 charset 사용
-        if (dduOptions?.dduSetSymbol) {
-            return this.processPredefinedCharSet(dduOptions.dduSetSymbol, dduOptions);
+        else {
+            this.indexToBinaryCache = null;
         }
-        // 3. 기본 charset 사용
-        return this.processDefaultCharSet();
     }
-    /**
-     * 커스텀 charset 처리
-     */
-    processCustomCharSet(dduChar, paddingChar, dduOptions) {
-        if (!paddingChar) {
-            throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
-        }
-        // string 타입을 배열로 변환
-        const dduCharArray = this.convertToCharArray(dduChar);
-        const dduCharLength = dduOptions?.requiredLength ?? 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, dduOptions?.usePowerOfTwo ?? true);
-        return {
-            ...result,
-            isPredefined: false // 커스텀 charset은 검증 필요
+    normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions) {
+        const applyFallback = () => {
+            const fallbackSymbol = dduOptions?.dduSetSymbol ?? dduDefaultConstructorOptions.dduSetSymbol ?? DduSetSymbol.ONECHARSET;
+            const cs = getCharSet(fallbackSymbol) ?? getCharSet(DduSetSymbol.ONECHARSET);
+            if (!cs)
+                throw new Error(`Critical: No fallback CharSet available`);
+            return { charSet: cs.charSet, padding: cs.paddingChar, requiredLength: cs.maxRequiredLength, bitLength: cs.bitLength, isPredefined: true };
         };
-    }
-    /**
-     * 미리 정의된 charset 처리
-     */
-    processPredefinedCharSet(symbol, dduOptions) {
-        const fixedCharSet = getCharSet(symbol);
-        if (!fixedCharSet) {
-            throw new Error(`CharSet with symbol ${symbol} not found`);
-        }
-        const { charSet, paddingChar, maxRequiredLength, bitLength } = fixedCharSet;
-        // usePowerOfTwo 처리
-        if (dduOptions?.usePowerOfTwo ?? true) {
-            const result = this.applyPowerOfTwoOption(charSet, paddingChar, maxRequiredLength, true);
-            return {
-                ...result,
-                isPredefined: true // 미리 정의된 charset은 검증 패스
-            };
-        }
-        return {
-            finalCharSet: charSet,
-            finalPadding: paddingChar,
-            requiredLength: maxRequiredLength,
-            bitLength,
-            isPredefined: true // 미리 정의된 charset은 검증 패스
+        const validate = (condition, message) => {
+            if (condition) {
+                if (shouldThrowError)
+                    throw new Error(message);
+                const fb = applyFallback();
+                [charSet, padding, requiredLength, bitLength, isPredefined] = [fb.charSet, fb.padding, fb.requiredLength, fb.bitLength, fb.isPredefined];
+                return true;
+            }
+            return false;
         };
-    }
-    /**
-     * 기본 charset 처리
-     */
-    processDefaultCharSet() {
-        const defaultSymbol = dduDefaultConstructorOptions.dduSetSymbol ?? DduSetSymbol.DDU;
-        const fixedCharSet = getCharSet(defaultSymbol);
-        if (!fixedCharSet) {
-            throw new Error(`Default CharSet with symbol ${defaultSymbol} not found`);
+        // 중복 제거 (커스텀 charset만)
+        if (!isPredefined) {
+            const uniqueChars = new Set(charSet);
+            if (uniqueChars.size !== charSet.length) {
+                if (shouldThrowError)
+                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${charSet.length}`);
+                charSet = Array.from(uniqueChars);
+                requiredLength = charSet.length;
+            }
         }
-        return {
-            finalCharSet: fixedCharSet.charSet,
-            finalPadding: fixedCharSet.paddingChar,
-            requiredLength: fixedCharSet.maxRequiredLength,
-            bitLength: fixedCharSet.bitLength,
-            isPredefined: true // 기본 charset도 미리 정의된 것이므로 검증 패스
-        };
-    }
-    /**
-     * fallback charset 가져오기
-     */
-    getFallbackCharSet(dduOptions) {
-        const fallbackSymbol = dduOptions?.dduSetSymbol ??
-            dduDefaultConstructorOptions.dduSetSymbol ??
-            DduSetSymbol.DDU;
-        const fixedCharSet = getCharSet(fallbackSymbol);
-        if (!fixedCharSet) {
-            throw new Error(`Fallback CharSet with symbol ${fallbackSymbol} not found`);
+        // 검증
+        if (validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`)) {
+            return this.normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions);
         }
-        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);
+        let charLength = charSet[0]?.length ?? 0;
+        validate(charLength === 0, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+        const invalidIndex = charSet.findIndex(char => char.length !== charLength);
+        if (invalidIndex !== -1) {
+            if (shouldThrowError)
+                throw new Error(`All characters must have the same length. Expected: ${charLength}, but index ${invalidIndex} has length ${charSet[invalidIndex].length}`);
+            charSet = charSet.filter(char => char.length === charLength);
+            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            charLength = charSet[0]?.length ?? 0;
         }
-        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,
-            };
+        validate(!charSet.length, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: 0`);
+        validate(padding.length !== charLength, `Padding character must have length ${charLength}, got ${padding.length}`);
+        if (new Set(charSet).has(padding)) {
+            if (shouldThrowError)
+                throw new Error(`Padding character "${padding}" cannot be in the character set`);
+            charSet = charSet.filter(char => char !== padding);
+            validate(charSet.length < requiredLength, `${this.constructor.name} requires at least ${requiredLength} characters. Provided: ${charSet.length}`);
+            charLength = charSet[0]?.length ?? 0;
         }
-        return {
-            finalCharSet: charArray.slice(0, length),
-            finalPadding: padding,
-            requiredLength: length,
-            bitLength: this.getBitLength(length),
-        };
+        return { charSet: charSet.slice(0, requiredLength), padding, requiredLength, bitLength, isPredefined, charLength };
+    }
+    getBinaryFromIndex(index) {
+        return this.indexToBinaryCache?.[index] ?? index.toString(2).padStart(this.effectiveBitLength, "0");
     }
-    /**
-     * 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 allStrings = new Set([...charSet.slice(0, requiredLength), paddingChar]);
+        const limit = Math.min(charSet.length, requiredLength);
+        // 2개 조합 검사
+        for (let i = 0; i < limit; i++) {
+            for (let j = 0; j < limit; j++) {
+                const combo = charSet[i] + charSet[j];
+                if (allStrings.has(combo)) {
+                    throw new Error(`Combination conflict: "${charSet[i]}" + "${charSet[j]}" = "${combo}" already exists`);
                 }
             }
-            // 문자 + 패딩 조합 검사
-            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`);
-            }
+            const charPad = charSet[i] + paddingChar;
+            const padChar = paddingChar + charSet[i];
+            if (allStrings.has(charPad))
+                throw new Error(`Combination conflict: "${charSet[i]}" + padding "${paddingChar}" = "${charPad}"`);
+            if (allStrings.has(padChar))
+                throw new Error(`Combination conflict: padding "${paddingChar}" + "${charSet[i]}" = "${padChar}"`);
         }
-        // 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`);
+        // 패딩 + 패딩 조합 검사
+        const doublePad = paddingChar + paddingChar;
+        if (allStrings.has(doublePad)) {
+            throw new Error(`Combination conflict: double padding "${doublePad}" already exists`);
         }
-        // 4. 3개 이상 조합 검사 (선택적, 성능을 위해 샘플링)
-        // 모든 조합을 검사하면 O(n^3)이므로 일부만 샘플링
+        // 3개 조합 검사 (100개 이하만)
         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`);
+            for (let i = 0; i < limit; i++) {
+                for (let j = 0; j < limit; j++) {
+                    for (let k = 0; k < limit; k++) {
+                        const combo = charSet[i] + charSet[j] + charSet[k];
+                        for (let start = 0; start <= combo.length - charLength; start++) {
+                            const sub = combo.substring(start, start + charLength);
+                            if (allStrings.has(sub) && sub !== charSet[i] && sub !== charSet[j] && sub !== charSet[k]) {
+                                throw new Error(`Combination conflict: substring "${sub}" from "${charSet[i]}" + "${charSet[j]}" + "${charSet[k]}"`);
                             }
                         }
                     }
@@ -284,17 +202,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 +241,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 +252,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 +262,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.4",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/index.d.ts",