@ddunigma/node 1.1.3 → 1.1.4

package/dist/cjs/encoders/Ddu64.js

@@ -6,394 +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();
+        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;
+            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];
+                }
+            }
+            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];
+            }
         }
         catch (error) {
-            // useBuildErrorReturn이 true일 경우 에러를 그대로 throw
-            if ((_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.useBuildErrorReturn) !== null && _a !== void 0 ? _a : false) {
+            if (shouldThrowError)
                 throw error;
-            }
-            // fallback 처리
-            const fallbackResult = this.getFallbackCharSet(dduOptions);
-            finalCharSet = [...fallbackResult.finalCharSet];
-            finalPadding = fallbackResult.finalPadding;
-            requiredLength = fallbackResult.requiredLength;
-            bitLength = fallbackResult.bitLength;
-            isPredefined = true; // fallback도 predefined charset 사용
+            // 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];
         }
-        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,
-        });
+        // 정규화 및 검증
+        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;
         this.usePowerOfTwo = dduLength > 0 && (dduLength & (dduLength - 1)) === 0;
-        this.effectiveBitLength = this.usePowerOfTwo
-            ? this.bitLength
-            : this.getBitLength(dduLength);
-        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);
-        });
+        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, this.dduChar.length);
+            this.validateCombinationDuplicates(this.dduChar, this.paddingChar, dduLength);
         }
         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");
-            }
+            const size = 1 << this.effectiveBitLength;
+            this.indexToBinaryCache = Array.from({ length: size }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
         }
         else {
             this.indexToBinaryCache = null;
         }
     }
-    /**
-     * charset 초기화 (커스텀 또는 미리 정의된 charset)
-     */
-    initializeCharSet(dduChar, paddingChar, dduOptions) {
-        const finalDduChar = dduChar !== null && dduChar !== void 0 ? dduChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduChar;
-        const finalPaddingChar = paddingChar !== null && paddingChar !== void 0 ? paddingChar : dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.paddingChar;
-        // 1. 커스텀 charset 사용
-        if (finalDduChar) {
-            return this.processCustomCharSet(finalDduChar, finalPaddingChar, dduOptions);
-        }
-        // 2. 미리 정의된 charset 사용
-        if (dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.dduSetSymbol) {
-            return this.processPredefinedCharSet(dduOptions.dduSetSymbol, dduOptions);
-        }
-        // 3. 기본 charset 사용
-        return this.processDefaultCharSet();
-    }
-    /**
-     * 커스텀 charset 처리
-     */
-    processCustomCharSet(dduChar, paddingChar, dduOptions) {
-        var _a;
-        if (!paddingChar) {
-            throw new Error("paddingChar is required when dduChar or dduOptions.dduChar is provided");
-        }
-        // string 타입을 배열로 변환
-        const dduCharArray = this.convertToCharArray(dduChar);
-        const dduCharLength = (_a = dduOptions === null || dduOptions === void 0 ? void 0 : dduOptions.requiredLength) !== null && _a !== void 0 ? _a : dduCharArray.length;
-        if (dduCharArray.length < dduCharLength) {
-            throw new Error(`dduChar must be at least ${dduCharLength} characters long. Provided: ${dduCharArray.length}`);
-        }
-        // usePowerOfTwo 처리
-        // 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은 검증 필요
-         });
-    }
-    /**
-     * 미리 정의된 charset 처리
-     */
-    processPredefinedCharSet(symbol, dduOptions) {
-        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 처리
-        // 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은 검증 패스
-             });
-        }
-        return {
-            finalCharSet: charSet,
-            finalPadding: paddingChar,
-            requiredLength: maxRequiredLength,
-            bitLength,
-            isPredefined: true // 미리 정의된 charset은 검증 패스
-        };
-    }
-    /**
-     * 기본 charset 처리
-     */
-    processDefaultCharSet() {
-        var _a;
-        const defaultSymbol = (_a = types_1.dduDefaultConstructorOptions.dduSetSymbol) !== null && _a !== void 0 ? _a : types_1.DduSetSymbol.DDU;
-        const fixedCharSet = (0, charSets_1.getCharSet)(defaultSymbol);
-        if (!fixedCharSet) {
-            throw new Error(`Default CharSet with symbol ${defaultSymbol} not found`);
-        }
-        return {
-            finalCharSet: fixedCharSet.charSet,
-            finalPadding: fixedCharSet.paddingChar,
-            requiredLength: fixedCharSet.maxRequiredLength,
-            bitLength: fixedCharSet.bitLength,
-            isPredefined: true // 기본 charset도 미리 정의된 것이므로 검증 패스
-        };
-    }
-    /**
-     * fallback charset 가져오기
-     * 우선순위: dduOptions.dduSetSymbol > dduDefaultConstructorOptions.dduSetSymbol > DduSetSymbol.ONECHARSET
-     */
-    getFallbackCharSet(dduOptions) {
-        var _a, _b;
-        // 우선순위에 따라 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) {
-            // 최후의 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,
-            finalPadding: fixedCharSet.paddingChar,
-            requiredLength: fixedCharSet.maxRequiredLength,
-            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;
-        };
+    normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions) {
+        var _a, _b, _c, _d, _e, _f;
         const applyFallback = () => {
-            const fallback = getFallback();
-            currentCharSet = [...fallback.finalCharSet];
-            currentPadding = fallback.finalPadding;
-            currentRequiredLength = fallback.requiredLength;
-            currentBitLength = fallback.bitLength;
-            currentIsPredefined = true;
+            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 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();
+        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;
         };
-        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);
+        // 중복 제거 (커스텀 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;
             }
         }
-        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;
+        // 검증
+        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 invalidIndex = currentCharSet.findIndex((char) => char.length !== charLength);
+        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 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,
-        };
+            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;
+        }
+        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 { charSet: charSet.slice(0, requiredLength), padding, requiredLength, bitLength, isPredefined, charLength };
     }
     getBinaryFromIndex(index) {
-        const cache = this.indexToBinaryCache;
-        if (cache && index < cache.length) {
-            return cache[index];
-        }
-        return index.toString(2).padStart(this.effectiveBitLength, "0");
-    }
-    /**
-     * string 또는 배열을 문자 배열로 변환
-     */
-    convertToCharArray(input) {
-        if (typeof input === "string") {
-            return [...new Set(input.trim())].map((c) => c);
-        }
-        return input;
-    }
-    /**
-     * 숫자가 2의 제곱수인지 확인
-     */
-    isPowerOfTwo(n) {
-        return n > 0 && (n & (n - 1)) === 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),
-        };
+        var _a, _b;
+        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");
     }
-    /**
-     * 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`);
-            }
-        }
-        // 3. 패딩 + 패딩 조합 검사
-        const doublePadding = paddingChar + paddingChar;
-        if (allStrings.has(doublePadding)) {
-            throw new Error(`Combination conflict detected: padding "${paddingChar}" + padding "${paddingChar}" = "${doublePadding}" already exists in the character set`);
-        }
-        // 4. 3개 이상 조합 검사 (선택적, 성능을 위해 샘플링)
-        // 모든 조합을 검사하면 O(n^3)이므로 일부만 샘플링
+            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}"`);
+        }
+        // 패딩 + 패딩 조합 검사
+        const doublePad = paddingChar + paddingChar;
+        if (allStrings.has(doublePad)) {
+            throw new Error(`Combination conflict: double padding "${doublePad}" already exists`);
+        }
+        // 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]}"`);
                             }
                         }
                     }

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

@@ -13,45 +13,8 @@ export declare class Ddu64 extends BaseDdu {
     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 가져오기
-     * 우선순위: dduOptions.dduSetSymbol > dduDefaultConstructorOptions.dduSetSymbol > DduSetSymbol.ONECHARSET
-     */
-    private getFallbackCharSet;
     private normalizeCharSet;
     private getBinaryFromIndex;
-    /**
-     * string 또는 배열을 문자 배열로 변환
-     */
-    private convertToCharArray;
-    /**
-     * 숫자가 2의 제곱수인지 확인
-     */
-    private isPowerOfTwo;
-    /**
-     * usePowerOfTwo 옵션 적용
-     */
-    private applyPowerOfTwoOption;
-    /**
-     * 2글자 이상의 문자셋에서 조합으로 인한 중복을 검증
-     * 예: ["AB", "CD"] + padding "AB" 또는 "A" + "B" = "AB" 같은 경우 감지
-     */
     private validateCombinationDuplicates;
     encode(input: Buffer | string, _options?: DduOptions): string;
     decode(input: string, _options?: DduOptions): string;