@ddunigma/node 1.1.6 → 1.1.9

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

@@ -10,12 +10,30 @@ export declare class Ddu64 extends BaseDdu {
     protected readonly dduBinaryLookup: Map<string, number>;
     private readonly isPredefinedCharSet;
     private readonly effectiveBitLength;
+    private readonly maxBinaryValue;
     private readonly binaryChunkToIntFn;
     private readonly indexToBinaryCache;
     constructor(dduChar?: string[] | string, paddingChar?: string, dduOptions?: DduConstructorOptions);
     private normalizeCharSet;
+    private resolveInitialCharSet;
+    private getFallbackCharSet;
+    private shouldUsePowerOfTwo;
+    private getCharSetOrThrow;
     private getBinaryFromIndex;
     private validateCombinationDuplicates;
     encode(input: Buffer | string, _options?: DduOptions): string;
+    decodeToBuffer(input: string, _options?: DduOptions): Buffer;
     decode(input: string, _options?: DduOptions): string;
+    /**
+     * 테스트 및 디버깅용 getter 메서드
+     * 인코더의 내부 상태 정보를 반환
+     */
+    getCharSetInfo(): {
+        charSet: string[];
+        paddingChar: string;
+        charLength: number;
+        bitLength: number;
+        usePowerOfTwo: boolean;
+        encoding: BufferEncoding;
+    };
 }

package/dist/mjs/encoders/Ddu64.js

@@ -11,156 +11,238 @@ export class Ddu64 extends BaseDdu {
     dduBinaryLookup = new Map();
     isPredefinedCharSet;
     effectiveBitLength;
+    maxBinaryValue;
     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 charSet, padding, requiredLength, bitLength, isPredefined;
-        try {
-            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) {
-            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];
-        }
+        const { charSet, padding, requiredLength, bitLength, isPredefined, } = this.resolveInitialCharSet(dduChar, paddingChar, dduOptions, shouldThrowError);
         // 정규화 및 검증
         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;
+        const recalculatedBitLength = this.getBitLength(dduLength);
         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.bitLength = this.usePowerOfTwo
+            ? this.getLargestPowerOfTwoExponent(dduLength)
+            : recalculatedBitLength;
+        this.effectiveBitLength = this.usePowerOfTwo ? this.bitLength : recalculatedBitLength;
+        this.maxBinaryValue = 2 ** this.effectiveBitLength;
+        // 성능 최적화: 단일 구현 사용 (벤치마크 결과 Method2가 더 빠르고 안정적)
+        // Method2는 32비트 이상에서도 오버플로우 없이 정확한 결과 제공
+        this.binaryChunkToIntFn = (chunk) => {
+            let value = 0;
+            for (let i = 0; i < chunk.length; i++) {
+                value = value * 2 + (chunk.charCodeAt(i) & 1);
+            }
+            return value;
+        };
         this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
-        if (this.charLength >= 2 && !this.isPredefinedCharSet) {
+        if (this.charLength === 1 && !this.isPredefinedCharSet) {
             this.validateCombinationDuplicates(this.dduChar, this.paddingChar, dduLength);
         }
         if (this.effectiveBitLength <= 16) {
-            const size = 1 << this.effectiveBitLength;
-            this.indexToBinaryCache = Array.from({ length: size }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
+            this.indexToBinaryCache = Array.from({ length: this.maxBinaryValue }, (_, i) => i.toString(2).padStart(this.effectiveBitLength, "0"));
         }
         else {
             this.indexToBinaryCache = null;
         }
     }
     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 };
-        };
-        const validate = (condition, message) => {
-            if (condition) {
+        const applyFallback = () => this.getFallbackCharSet(dduOptions);
+        while (true) {
+            const ensure = (condition, message) => {
+                if (!condition)
+                    return false;
                 if (shouldThrowError)
                     throw new Error(message);
-                const fb = applyFallback();
-                [charSet, padding, requiredLength, bitLength, isPredefined] = [fb.charSet, fb.padding, fb.requiredLength, fb.bitLength, fb.isPredefined];
+                ({
+                    charSet,
+                    padding,
+                    requiredLength,
+                    bitLength,
+                    isPredefined,
+                } = applyFallback());
                 return true;
-            }
-            return false;
-        };
-        // 중복 제거 (커스텀 charset만)
-        if (!isPredefined) {
+            };
             const uniqueChars = new Set(charSet);
             if (uniqueChars.size !== charSet.length) {
+                const duplicates = charSet.filter((char, index) => charSet.indexOf(char) !== index);
+                const errorMsg = `[Ddu64 normalizeCharSet] Character set contains duplicate characters. Total: ${charSet.length}, Unique: ${uniqueChars.size}, Duplicates: [${[
+                    ...new Set(duplicates),
+                ].join(", ")}]`;
                 if (shouldThrowError)
-                    throw new Error(`Character set contains duplicate characters. Unique: ${uniqueChars.size}, Total: ${charSet.length}`);
+                    throw new Error(errorMsg);
                 charSet = Array.from(uniqueChars);
-                requiredLength = charSet.length;
+                if (!isPredefined) {
+                    requiredLength = charSet.length;
+                }
+            }
+            if (ensure(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters. Required: ${requiredLength}, Provided: ${charSet.length}`)) {
+                continue;
+            }
+            if (ensure(requiredLength < 2, `[Ddu64 normalizeCharSet] At least 2 unique characters are required. Provided: ${requiredLength}`)) {
+                continue;
+            }
+            if (ensure(bitLength <= 0, `[Ddu64 normalizeCharSet] Invalid bit length (${bitLength}) for charset size ${requiredLength}`)) {
+                continue;
+            }
+            if (ensure(!charSet.length, `[Ddu64 normalizeCharSet] Empty charset. Required: ${requiredLength} characters`)) {
+                continue;
+            }
+            let charLength = charSet[0].length;
+            const invalidIndex = charSet.findIndex((char) => char.length !== charLength);
+            if (invalidIndex !== -1) {
+                if (shouldThrowError) {
+                    throw new Error(`[Ddu64 normalizeCharSet] Inconsistent character length. Expected: ${charLength}, but character at index ${invalidIndex} ("${charSet[invalidIndex]}") has length ${charSet[invalidIndex].length}`);
+                }
+                charSet = charSet.filter((char) => char.length === charLength);
+                if (ensure(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters after filtering. Required: ${requiredLength}, Remaining: ${charSet.length}`)) {
+                    continue;
+                }
+                if (ensure(!charSet.length, `[Ddu64 normalizeCharSet] Empty charset after filtering`)) {
+                    continue;
+                }
+                charLength = charSet[0].length;
+            }
+            if (ensure(padding.length !== charLength, `[Ddu64 normalizeCharSet] Padding character length mismatch. Expected: ${charLength}, Got: ${padding.length} (padding: "${padding}")`)) {
+                continue;
             }
+            if (charSet.includes(padding)) {
+                if (shouldThrowError) {
+                    throw new Error(`[Ddu64 normalizeCharSet] Padding character "${padding}" conflicts with charset. Padding must not be in the character set.`);
+                }
+                charSet = charSet.filter((char) => char !== padding);
+                if (ensure(charSet.length < requiredLength, `[Ddu64 normalizeCharSet] Insufficient characters after removing padding conflict. Required: ${requiredLength}, Remaining: ${charSet.length}`)) {
+                    continue;
+                }
+                if (ensure(!charSet.length, `[Ddu64 normalizeCharSet] Empty charset after removing padding conflict`)) {
+                    continue;
+                }
+                charLength = charSet[0].length;
+            }
+            return {
+                charSet: charSet.slice(0, requiredLength),
+                padding,
+                requiredLength,
+                bitLength,
+                isPredefined,
+                charLength,
+            };
         }
-        // 검증
-        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);
+    }
+    resolveInitialCharSet(dduChar, paddingChar, dduOptions, shouldThrowError) {
+        const finalize = (set, padding, length, baseBitLength, predefined = false) => {
+            const usePow2 = this.shouldUsePowerOfTwo(length, dduOptions?.usePowerOfTwo);
+            if (usePow2 && length > 0) {
+                const exponent = this.getLargestPowerOfTwoExponent(length);
+                const pow2Length = 1 << exponent;
+                return {
+                    charSet: set.slice(0, pow2Length),
+                    padding,
+                    requiredLength: pow2Length,
+                    bitLength: exponent,
+                    isPredefined: predefined,
+                };
+            }
+            const computedBitLength = baseBitLength ?? (length > 0 ? this.getBitLength(length) : 0);
+            return {
+                charSet: set.slice(0, length),
+                padding,
+                requiredLength: length,
+                bitLength: computedBitLength,
+                isPredefined: predefined,
+            };
+        };
+        const fallback = () => this.getFallbackCharSet(dduOptions);
+        try {
+            const finalDduChar = dduChar ?? dduOptions?.dduChar;
+            const finalPadding = paddingChar ?? dduOptions?.paddingChar;
+            if (finalDduChar) {
+                if (!finalPadding) {
+                    throw new Error(`[Ddu64 Constructor] paddingChar is required when dduChar is provided. Received: dduChar=${typeof finalDduChar}, paddingChar=${finalPadding}`);
+                }
+                const arr = typeof finalDduChar === "string"
+                    ? [...finalDduChar.trim()]
+                    : [...finalDduChar];
+                if (shouldThrowError) {
+                    const uniqueChars = new Set(arr);
+                    if (uniqueChars.size !== arr.length) {
+                        const duplicates = arr.filter((char, index) => arr.indexOf(char) !== index);
+                        throw new Error(`[Ddu64 Constructor] Character set contains duplicate characters. Total: ${arr.length}, Unique: ${uniqueChars.size}, Duplicates: [${[
+                            ...new Set(duplicates),
+                        ].join(", ")}]`);
+                    }
+                }
+                const len = dduOptions?.requiredLength ?? arr.length;
+                if (arr.length < len) {
+                    throw new Error(`[Ddu64 Constructor] Insufficient characters in charset. Required: ${len}, Provided: ${arr.length}`);
+                }
+                return finalize(arr, finalPadding, len, undefined, false);
+            }
+            if (dduOptions?.dduSetSymbol) {
+                const cs = this.getCharSetOrThrow(dduOptions.dduSetSymbol);
+                return finalize(cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true);
+            }
+            const defaultSymbol = dduDefaultConstructorOptions.dduSetSymbol ?? DduSetSymbol.DDU;
+            const cs = this.getCharSetOrThrow(defaultSymbol);
+            return finalize(cs.charSet, cs.paddingChar, cs.maxRequiredLength, cs.bitLength, true);
         }
-        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) {
+        catch (error) {
             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;
+                throw error;
+            return fallback();
         }
-        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;
+    }
+    getFallbackCharSet(dduOptions) {
+        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,
+        };
+    }
+    shouldUsePowerOfTwo(length, preference) {
+        if (preference === true) {
+            return length > 0;
+        }
+        if (preference === false) {
+            return false;
         }
-        return { charSet: charSet.slice(0, requiredLength), padding, requiredLength, bitLength, isPredefined, charLength };
+        return length > 0 && (length & (length - 1)) === 0;
+    }
+    getCharSetOrThrow(symbol) {
+        const cs = getCharSet(symbol);
+        if (!cs)
+            throw new Error(`CharSet with symbol ${symbol} not found`);
+        return cs;
     }
     getBinaryFromIndex(index) {
+        if (index < 0 || index >= this.maxBinaryValue) {
+            throw new Error(`[Ddu64] Binary index overflow. Received: ${index}, Allowed range: 0-${this.maxBinaryValue - 1}`);
+        }
         return this.indexToBinaryCache?.[index] ?? index.toString(2).padStart(this.effectiveBitLength, "0");
     }
     validateCombinationDuplicates(charSet, paddingChar, requiredLength) {
         const charLength = charSet[0].length;
+        // 조합 충돌 검사는 단일 문자 집합이면서 비교적 작은 경우(<=256)에만 적용한다.
+        if (charLength !== 1 || requiredLength > 256) {
+            return;
+        }
         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];
@@ -170,57 +252,38 @@ export class Ddu64 extends BaseDdu {
             }
             const charPad = charSet[i] + paddingChar;
             const padChar = paddingChar + charSet[i];
-            if (allStrings.has(charPad))
+            if (allStrings.has(charPad)) {
                 throw new Error(`Combination conflict: "${charSet[i]}" + padding "${paddingChar}" = "${charPad}"`);
-            if (allStrings.has(padChar))
+            }
+            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) {
-            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]}"`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
     }
     encode(input, _options) {
         // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
         const bufferInput = typeof input === "string" ? Buffer.from(input, this.encoding) : input;
-        // 생성자에서 설정된 값 사용
-        const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.effectiveBitLength;
-        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, effectiveBitLength);
-        // 문자열 연결 최적화: Array + join 사용
+        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, this.effectiveBitLength);
         const resultParts = new Array(dduBinary.length);
-        // 각 비트 청크를 변환
-        for (let i = 0; i < dduBinary.length; i++) {
-            const binaryChunk = dduBinary[i];
-            const charInt = this.binaryChunkToIntFn(binaryChunk);
-            if (this.charLength === 1 && !this.usePowerOfTwo) {
-                // 가변 길이 조합 인코딩
-                const quotient = Math.floor(charInt / dduLength);
-                const remainder = charInt % dduLength;
-                resultParts[i] = this.dduChar[quotient] + this.dduChar[remainder];
-            }
-            else {
-                // 고정 길이 직접 매핑
+        if (this.usePowerOfTwo) {
+            for (let i = 0; i < dduBinary.length; i++) {
+                const charInt = this.binaryChunkToIntFn(dduBinary[i]);
                 resultParts[i] = this.dduChar[charInt];
             }
         }
+        else {
+            const dduLength = this.dduChar.length;
+            for (let i = 0; i < dduBinary.length; i++) {
+                const value = this.binaryChunkToIntFn(dduBinary[i]);
+                const quotient = Math.floor(value / dduLength);
+                const remainder = value % dduLength;
+                resultParts[i] = this.dduChar[quotient] + this.dduChar[remainder];
+            }
+        }
         let resultString = resultParts.join("");
         // 패딩 비트 정보를 padChar + 패딩비트수 형태로 추가
         if (padding > 0) {
@@ -228,44 +291,78 @@ export class Ddu64 extends BaseDdu {
         }
         return resultString;
     }
-    decode(input, _options) {
-        // options는 구버전 호환성을 위해 유지하지만 사용하지 않음
-        // 패딩 정보 추출
+    decodeToBuffer(input, _options) {
         let paddingBits = 0;
-        const padCharIndex = input.indexOf(this.paddingChar);
-        if (padCharIndex >= 0) {
-            const paddingStr = input.substring(padCharIndex + this.paddingChar.length);
-            paddingBits = parseInt(paddingStr) || 0;
-            input = input.substring(0, padCharIndex);
+        if (input.length >= this.paddingChar.length) {
+            const padCharIndex = input.lastIndexOf(this.paddingChar);
+            if (padCharIndex >= 0 &&
+                padCharIndex % this.charLength === 0 &&
+                padCharIndex + this.paddingChar.length <= input.length) {
+                const paddingSection = input.slice(padCharIndex + this.paddingChar.length);
+                if (paddingSection.length === 0) {
+                    throw new Error(`[Ddu64 decode] Invalid padding format. Missing padding length after "${this.paddingChar}"`);
+                }
+                paddingBits = parseInt(paddingSection, 10);
+                if (isNaN(paddingBits) ||
+                    paddingSection !== paddingBits.toString() ||
+                    paddingBits < 0 ||
+                    paddingBits >= this.effectiveBitLength) {
+                    throw new Error(`[Ddu64 decode] Invalid padding format. Expected integer between 0 and ${this.effectiveBitLength - 1}, Got: "${paddingSection}"`);
+                }
+                input = input.substring(0, padCharIndex);
+            }
         }
-        let dduBinary = "";
-        // 생성자에서 설정된 값 사용
+        const binaryParts = [];
+        const charLength = this.charLength;
         const dduLength = this.dduChar.length;
-        const effectiveBitLength = this.effectiveBitLength;
-        if (this.charLength === 1 && !this.usePowerOfTwo) {
-            // 가변 길이 조합 디코딩 (2개씩 읽음)
-            for (let i = 0; i < input.length; i += 2) {
-                const firstChar = input[i];
-                const secondChar = input[i + 1];
+        if (!this.usePowerOfTwo) {
+            const chunkSize = charLength * 2;
+            for (let i = 0; i < input.length; i += chunkSize) {
+                const firstChar = input.slice(i, i + charLength);
+                const secondChar = input.slice(i + charLength, i + chunkSize);
                 const firstIndex = this.dduBinaryLookup.get(firstChar);
                 const secondIndex = this.dduBinaryLookup.get(secondChar);
-                if (firstIndex === undefined || secondIndex === undefined)
-                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
+                if (firstIndex === undefined || secondIndex === undefined) {
+                    const invalidChar = firstIndex === undefined ? firstChar : secondChar;
+                    throw new Error(`[Ddu64 decode] Invalid character in encoded string. Character: "${invalidChar}", Position: ${i}, Expected charset size: ${dduLength}`);
+                }
                 const value = firstIndex * dduLength + secondIndex;
-                dduBinary += this.getBinaryFromIndex(value);
+                if (value >= this.maxBinaryValue) {
+                    throw new Error(`[Ddu64 decode] Invalid character combination detected. Calculated value ${value} exceeds binary range ${this.maxBinaryValue - 1}.`);
+                }
+                binaryParts.push(this.getBinaryFromIndex(value));
             }
         }
         else {
-            // 고정 길이 직접 매핑 (charLength만큼씩 읽음)
-            for (let i = 0; i < input.length; i += this.charLength) {
-                const charChunk = input.slice(i, i + this.charLength);
+            for (let i = 0; i < input.length; i += charLength) {
+                const charChunk = input.slice(i, i + charLength);
                 const charIndex = this.dduBinaryLookup.get(charChunk);
-                if (charIndex === undefined)
-                    throw new Error(`Invalid character: ${charChunk}`);
-                dduBinary += this.getBinaryFromIndex(charIndex);
+                if (charIndex === undefined) {
+                    throw new Error(`[Ddu64 decode] Invalid character in encoded string. Character: "${charChunk}", Position: ${i}, Charset size: ${dduLength}, Character length: ${charLength}`);
+                }
+                if (charIndex >= this.maxBinaryValue) {
+                    throw new Error(`[Ddu64 decode] Invalid binary index ${charIndex}. Allowed range: 0-${this.maxBinaryValue - 1}`);
+                }
+                binaryParts.push(this.getBinaryFromIndex(charIndex));
             }
         }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingBits);
-        return decoded.toString(this.encoding);
+        return this.dduBinaryToBuffer(binaryParts.join(""), paddingBits);
+    }
+    decode(input, _options) {
+        return this.decodeToBuffer(input, _options).toString(this.encoding);
+    }
+    /**
+     * 테스트 및 디버깅용 getter 메서드
+     * 인코더의 내부 상태 정보를 반환
+     */
+    getCharSetInfo() {
+        return {
+            charSet: [...this.dduChar],
+            paddingChar: this.paddingChar,
+            charLength: this.charLength,
+            bitLength: this.bitLength,
+            usePowerOfTwo: this.usePowerOfTwo,
+            encoding: this.encoding,
+        };
     }
 }

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@ddunigma/node",
-  "version": "1.1.6",
+  "version": "1.1.9",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && sh postProcess.sh",
-    "test": "NODE_OPTIONS='--expose-gc' tsx ./src/test/test-comprehensive.ts",
-    "test:no-gc": "tsx ./src/test/test-comprehensive.ts",
+    "test": "tsx ./src/test/test-quick.ts",
+    "test:comprehensive": "tsx ./src/test/test-comprehensive.ts",
+    "test:all": "tsx ./src/test/test-all-integrated.ts",
     "dev": "tsx ./src/test/test.ts"
   },
   "exports": {