@ddunigma/node 1.1.6 → 1.1.9

package/README.md

@@ -64,6 +64,7 @@ const encoder4 = new Ddu64(undefined, undefined, {
 const text = "안녕하세요";
 const encoded = encoder1.encode(text);
 const decoded = encoder1.decode(encoded);
+const decodedBuffer = encoder1.decodeToBuffer(encoded);
 ```
 
 ### 커스텀 Charset 사용
@@ -82,4 +83,47 @@ const encoder = new Ddu64(koreanChars, "뭐");
 const text = "안녕하세요12";
 const encoded = encoder.encode(text);
 const decoded = encoder.decode(encoded);
+const decodedBuffer = encoder.decodeToBuffer(encoded);
+```
+
+## API
+
+### `new Ddu64(dduChar?, paddingChar?, options?)`
+
+인코더 인스턴스를 생성합니다.
+
+**Parameters:**
+- `dduChar` (string | string[]): charset 문자열 또는 배열
+- `paddingChar` (string): 패딩 문자
+- `options` (DduOptions): 옵션 객체
+  - `dduSetSymbol`: 미리 정의된 charset 사용
+  - `encoding`: Buffer encoding (기본값: 'utf-8')
+  - `usePowerOfTwo`: 2의 제곱수 강제 여부
+  - `useBuildErrorReturn`: 에러 발생 시 throw 여부
+
+### `encode(data: string | Buffer): string`
+
+데이터를 인코딩
+
+### `decode(encoded: string): string`
+
+인코딩된 문자열을 디코딩
+
+### `decodeToBuffer(encoded: string): Buffer`
+
+인코딩된 문자열을 Buffer로 직접 디코딩
+
+### `getCharSetInfo()`
+
+현재 charset 정보를 반환
+
+```typescript
+{
+  charSet: string[];
+  paddingChar: string;
+  charLength: number;
+  bitLength: number;
+  usePowerOfTwo: boolean;
+  encoding: BufferEncoding;
+}
 ```

package/dist/cjs/base/BaseDdu.d.ts

@@ -1,38 +1,27 @@
 import { DduOptions, BufferToDduBinaryResult } from "../types";
 export declare abstract class BaseDdu {
     protected readonly defaultEncoding: BufferEncoding;
-    /**
-     * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
-     */
     protected readonly binaryLookup: string[];
-    /**
-     * 정규표현식 특수문자 이스케이프
-     */
     protected escapeRegExp(str: string): string;
-    /**
-     * 문자열을 지정된 길이로 분할하는 제너레이터
-     */
     protected splitString(s: string, length: number): Generator<string>;
-    /**
-     * 2의 거듭제곱 길이 계산
-     */
     protected getLargestPowerOfTwo(n: number): number;
-    /**
-     * 2의 거듭제곱 지수 계산
-     */
     protected getLargestPowerOfTwoExponent(n: number): number;
-    /**
-     * 비트 길이 계산
-     */
     protected getBitLength(setLength: number): number;
-    /**
-     * Buffer를 DDU Binary 배열로 변환
-     */
     protected bufferToDduBinary(input: Buffer, bitLength: number): BufferToDduBinaryResult;
-    /**
-     * DDU Binary를 Buffer로 변환
-     */
     protected dduBinaryToBuffer(decodedBin: string, paddingBits: number): Buffer;
     abstract encode(input: Buffer | string, options?: DduOptions): string;
+    abstract decodeToBuffer(input: string, options?: DduOptions): Buffer;
     abstract decode(input: string, options?: DduOptions): string;
+    /**
+     * 테스트 및 디버깅용 추상 메서드
+     * 구현 클래스의 내부 상태 정보를 반환
+     */
+    abstract getCharSetInfo(): {
+        charSet: string[];
+        paddingChar: string;
+        charLength: number;
+        bitLength: number;
+        usePowerOfTwo: boolean;
+        encoding: BufferEncoding;
+    };
 }

package/dist/cjs/base/BaseDdu.js

@@ -4,46 +4,25 @@ exports.BaseDdu = void 0;
 class BaseDdu {
     constructor() {
         this.defaultEncoding = "utf-8";
-        /**
-         * 이진수 변환 룩업 테이블 (0-255 -> 8비트 이진 문자열)
-         */
         this.binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
     }
-    /**
-     * 정규표현식 특수문자 이스케이프
-     */
     escapeRegExp(str) {
         return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
-    /**
-     * 문자열을 지정된 길이로 분할하는 제너레이터
-     */
     *splitString(s, length) {
         for (let i = 0; i < s.length; i += length) {
             yield s.slice(i, Math.min(i + length, s.length));
         }
     }
-    /**
-     * 2의 거듭제곱 길이 계산
-     */
     getLargestPowerOfTwo(n) {
         return Math.pow(2, Math.floor(Math.log2(n)));
     }
-    /**
-     * 2의 거듭제곱 지수 계산
-     */
     getLargestPowerOfTwoExponent(n) {
         return Math.floor(Math.log2(n));
     }
-    /**
-     * 비트 길이 계산
-     */
     getBitLength(setLength) {
         return Math.ceil(Math.log2(setLength));
     }
-    /**
-     * Buffer를 DDU Binary 배열로 변환
-     */
     bufferToDduBinary(input, bitLength) {
         // 성능 최적화: reduce 대신 for loop + join 사용
         if (input.length === 0) {
@@ -61,9 +40,6 @@ class BaseDdu {
         }
         return { dduBinary, padding };
     }
-    /**
-     * DDU Binary를 Buffer로 변환
-     */
     dduBinaryToBuffer(decodedBin, paddingBits) {
         if (paddingBits > 0) {
             decodedBin = decodedBin.slice(0, -paddingBits);

package/dist/cjs/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;
+    };
 }