@ddunigma/node 1.1.3 → 1.1.4

package/dist/mjs/encoders/Ddu64.js

@@ -15,393 +15,181 @@ export class Ddu64 extends BaseDdu {
     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;
+            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];
+                }
+            }
+            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];
+            }
         }
         catch (error) {
-            // useBuildErrorReturn이 true일 경우 에러를 그대로 throw
-            if (dduOptions?.useBuildErrorReturn ?? 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 = 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];
         }
-        const shouldThrowError = dduOptions?.useBuildErrorReturn ?? 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 = dduOptions?.encoding ?? 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 = dduOptions?.encoding ?? 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 ?? dduOptions?.dduChar;
-        const finalPaddingChar = paddingChar ?? dduOptions?.paddingChar;
-        // 1. 커스텀 charset 사용
-        if (finalDduChar) {
-            return this.processCustomCharSet(finalDduChar, finalPaddingChar, dduOptions);
-        }
-        // 2. 미리 정의된 charset 사용
-        if (dduOptions?.dduSetSymbol) {
-            return this.processPredefinedCharSet(dduOptions.dduSetSymbol, dduOptions);
-        }
-        // 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 처리
-        // charArray의 길이가 2의 제곱수이거나 option에 usePowerOfTwo가 명시적으로 true일 때만 적용
-        const shouldUsePowerOfTwo = dduOptions?.usePowerOfTwo === true ||
-            (dduOptions?.usePowerOfTwo === undefined && this.isPowerOfTwo(dduCharLength));
-        const result = this.applyPowerOfTwoOption(dduCharArray, paddingChar, dduCharLength, shouldUsePowerOfTwo);
-        return {
-            ...result,
-            isPredefined: false // 커스텀 charset은 검증 필요
-        };
-    }
-    /**
-     * 미리 정의된 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 처리
-        // charArray의 길이가 2의 제곱수이거나 option에 usePowerOfTwo가 명시적으로 true일 때만 적용
-        const shouldUsePowerOfTwo = dduOptions?.usePowerOfTwo === true ||
-            (dduOptions?.usePowerOfTwo === undefined && this.isPowerOfTwo(maxRequiredLength));
-        if (shouldUsePowerOfTwo) {
-            const result = this.applyPowerOfTwoOption(charSet, paddingChar, maxRequiredLength, true);
-            return {
-                ...result,
-                isPredefined: true // 미리 정의된 charset은 검증 패스
-            };
-        }
-        return {
-            finalCharSet: charSet,
-            finalPadding: paddingChar,
-            requiredLength: maxRequiredLength,
-            bitLength,
-            isPredefined: true // 미리 정의된 charset은 검증 패스
-        };
-    }
-    /**
-     * 기본 charset 처리
-     */
-    processDefaultCharSet() {
-        const defaultSymbol = dduDefaultConstructorOptions.dduSetSymbol ?? DduSetSymbol.DDU;
-        const fixedCharSet = 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) {
-        // 우선순위에 따라 fallback symbol 결정
-        const fallbackSymbol = dduOptions?.dduSetSymbol ??
-            dduDefaultConstructorOptions.dduSetSymbol ??
-            DduSetSymbol.ONECHARSET; // DDU 대신 ONECHARSET 사용
-        const fixedCharSet = getCharSet(fallbackSymbol);
-        if (!fixedCharSet) {
-            // 최후의 fallback: ONECHARSET
-            const lastResort = getCharSet(DduSetSymbol.ONECHARSET);
-            if (!lastResort) {
-                throw new Error(`Critical: No fallback CharSet available`);
-            }
-            return {
-                finalCharSet: lastResort.charSet,
-                finalPadding: lastResort.paddingChar,
-                requiredLength: lastResort.maxRequiredLength,
-                bitLength: lastResort.bitLength,
-            };
-        }
-        return {
-            finalCharSet: fixedCharSet.charSet,
-            finalPadding: fixedCharSet.paddingChar,
-            requiredLength: fixedCharSet.maxRequiredLength,
-            bitLength: fixedCharSet.bitLength,
-        };
-    }
-    normalizeCharSet(params) {
-        let currentCharSet = [...params.charSet];
-        let currentPadding = params.padding;
-        let currentRequiredLength = params.requiredLength;
-        let currentBitLength = params.bitLength;
-        let currentIsPredefined = params.isPredefined;
-        const { shouldThrowError, dduOptions } = params;
-        let fallbackCache = null;
-        const getFallback = () => {
-            if (!fallbackCache) {
-                const fallback = this.getFallbackCharSet(dduOptions);
-                fallbackCache = {
-                    finalCharSet: [...fallback.finalCharSet],
-                    finalPadding: fallback.finalPadding,
-                    requiredLength: fallback.requiredLength,
-                    bitLength: fallback.bitLength,
-                };
-            }
-            return fallbackCache;
-        };
+    normalizeCharSet(charSet, padding, requiredLength, bitLength, isPredefined, shouldThrowError, dduOptions) {
         const applyFallback = () => {
-            const fallback = getFallback();
-            currentCharSet = [...fallback.finalCharSet];
-            currentPadding = fallback.finalPadding;
-            currentRequiredLength = fallback.requiredLength;
-            currentBitLength = fallback.bitLength;
-            currentIsPredefined = true;
+            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 };
         };
-        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 = currentCharSet[0]?.length ?? 0;
-        if (charLength === 0) {
-            if (shouldThrowError) {
-                throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: ${currentCharSet.length}`);
-            }
-            applyFallback();
-            charLength = currentCharSet[0]?.length ?? 0;
+        // 검증
+        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 = 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 character at index ${invalidIndex} ("${currentCharSet[invalidIndex]}") has length ${currentCharSet[invalidIndex].length}`);
-            }
-            currentCharSet = currentCharSet.filter((char) => char.length === charLength);
-            ensureMinLength();
-            charLength = currentCharSet[0]?.length ?? 0;
-        }
-        if (!currentCharSet.length) {
-            if (shouldThrowError) {
-                throw new Error(`${this.constructor.name} requires at least ${currentRequiredLength} characters in the character set. Provided: 0`);
-            }
-            applyFallback();
-            charLength = currentCharSet[0]?.length ?? 0;
-        }
-        if (currentPadding.length !== charLength) {
-            if (shouldThrowError) {
-                throw new Error(`Padding character must have the same length as the characters. Expected: ${charLength}, but padding character has length ${currentPadding.length}`);
-            }
-            applyFallback();
-            charLength = currentCharSet[0]?.length ?? 0;
-        }
-        const charSetLookup = new Set(currentCharSet);
-        if (charSetLookup.has(currentPadding)) {
-            if (shouldThrowError) {
-                throw new Error(`Padding character "${currentPadding}" cannot be in the character set`);
-            }
-            currentCharSet = currentCharSet.filter((char) => char !== currentPadding);
-            ensureMinLength();
-            charLength = currentCharSet[0]?.length ?? 0;
-        }
-        currentCharSet = currentCharSet.slice(0, currentRequiredLength);
-        return {
-            charSet: currentCharSet,
-            padding: currentPadding,
-            requiredLength: currentRequiredLength,
-            bitLength: currentBitLength,
-            isPredefined: currentIsPredefined,
-            charLength,
-        };
+            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;
+        }
+        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 { 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;
+        return this.indexToBinaryCache?.[index] ?? index.toString(2).padStart(this.effectiveBitLength, "0");
     }
-    /**
-     * 숫자가 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),
-        };
-    }
-    /**
-     * 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/package.json

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