@ddunigma/node 2.0.0 → 2.0.2

package/dist/cjs/encoders/index.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ddu64 = void 0;
-// Unified encoder (supports both fixed and variable length via usePowerOfTwo option)
 var Ddu64_1 = require("./Ddu64");
 Object.defineProperty(exports, "Ddu64", { enumerable: true, get: function () { return Ddu64_1.Ddu64; } });

package/dist/cjs/index.d.ts

@@ -1,4 +1,4 @@
-export type { DduOptions, BufferToDduBinaryResult, DduConstructorOptions, } from "./types";
+export type { DduOptions, DduConstructorOptions, } from "./types";
 export { DduSetSymbol } from "./types";
 export { BaseDdu } from "./base";
 export { Ddu64 } from "./encoders";

package/dist/cjs/index.js

@@ -1,12 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ddu64 = exports.BaseDdu = exports.DduSetSymbol = void 0;
-// Export enums
 var types_1 = require("./types");
 Object.defineProperty(exports, "DduSetSymbol", { enumerable: true, get: function () { return types_1.DduSetSymbol; } });
-// Export base classes
 var base_1 = require("./base");
 Object.defineProperty(exports, "BaseDdu", { enumerable: true, get: function () { return base_1.BaseDdu; } });
-// Export encoders
 var encoders_1 = require("./encoders");
 Object.defineProperty(exports, "Ddu64", { enumerable: true, get: function () { return encoders_1.Ddu64; } });

package/dist/cjs/types/DduDefaultTypes.js

@@ -3,10 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dduDefaultConstructorOptions = void 0;
 const DduEnums_1 = require("./DduEnums");
 const dduDefaultConstructorOptions = {
+    /** 기본 charset: DDU (한글 + 특수문자) */
     dduSetSymbol: DduEnums_1.DduSetSymbol.DDU,
+    /** 2의 제곱수 강제 */
     usePowerOfTwo: true,
+    /** 필요 문자 수: 8개 */
     requiredLength: 8,
+    /** 비트 길이: 3 (2^3 = 8) */
     bitLength: 3,
+    /** 빌드 에러 시 throw하지 않음 */
     useBuildErrorReturn: false,
 };
 exports.dduDefaultConstructorOptions = dduDefaultConstructorOptions;

package/dist/cjs/types/DduInterface.d.ts

@@ -1,24 +1,39 @@
 import { DduSetSymbol } from "./DduEnums";
 export interface CharSetConfig {
+    /** charset 식별 심볼 */
     symbol: DduSetSymbol;
+    /** 인코딩에 사용할 문자 배열 */
     charSet: string[];
+    /** 최대 필요 문자 수 */
     maxRequiredLength: number;
+    /** 비트 길이 (log2) */
     bitLength: number;
+    /** 패딩 문자 */
     paddingChar: string;
 }
 export interface DduOptions {
+    /** 압축 사용 여부 (zlib deflate) */
+    compress?: boolean;
+    /** 최대 디코딩 바이트 수 (Zip Bomb 방어) */
+    maxDecodedBytes?: number;
+    /** 최대 압축해제 바이트 수 (Zip Bomb 방어) */
+    maxDecompressedBytes?: number;
 }
-export interface DduConstructorOptions {
+export interface DduConstructorOptions extends DduOptions {
+    /** 미리 정의된 charset 심볼 */
     dduSetSymbol?: DduSetSymbol;
+    /** 커스텀 charset 문자 배열 또는 문자열 */
     dduChar?: string[] | string;
+    /** 패딩 문자 */
     paddingChar?: string;
+    /** 필요 문자 수 */
     requiredLength?: number;
+    /** 비트 길이 */
     bitLength?: number;
+    /** 2의 제곱수 강제 여부 */
     usePowerOfTwo?: boolean;
+    /** 빌드 에러 시 throw 여부 */
     useBuildErrorReturn?: boolean;
+    /** Buffer 인코딩 방식 */
     encoding?: BufferEncoding;
 }
-export interface BufferToDduBinaryResult {
-    dduBinary: string[];
-    padding: number;
-}

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

@@ -1,20 +1,46 @@
-import { DduOptions, BufferToDduBinaryResult } from "../types";
+import { DduOptions } from "../types";
 export declare abstract class BaseDdu {
     protected readonly defaultEncoding: BufferEncoding;
-    protected readonly binaryLookup: string[];
-    protected escapeRegExp(str: string): string;
-    protected splitString(s: string, length: number): Generator<string>;
-    protected getLargestPowerOfTwo(n: number): number;
+    /**
+     * 주어진 숫자보다 작거나 같은 가장 큰 2의 제곱수의 지수를 반환합니다.
+     * @param n - 대상 숫자
+     * @returns 2의 제곱수 지수 (예: n=8 → 3, n=64 → 6)
+     * @example getLargestPowerOfTwoExponent(8) // 3
+     * @example getLargestPowerOfTwoExponent(100) // 6
+     */
     protected getLargestPowerOfTwoExponent(n: number): number;
+    /**
+     * charset 크기에 필요한 비트 길이를 계산합니다.
+     * @param setLength - charset 문자 수
+     * @returns 필요한 비트 수
+     * @example getBitLength(64) // 6
+     * @example getBitLength(100) // 7
+     */
     protected getBitLength(setLength: number): number;
-    protected bufferToDduBinary(input: Buffer, bitLength: number): BufferToDduBinaryResult;
-    protected dduBinaryToBuffer(decodedBin: string, paddingBits: number): Buffer;
+    /**
+     * 입력 데이터를 인코딩합니다.
+     * @param input - 인코딩할 문자열 또는 Buffer
+     * @param options - 인코딩 옵션
+     * @returns 인코딩된 문자열
+     */
     abstract encode(input: Buffer | string, options?: DduOptions): string;
+    /**
+     * 인코딩된 문자열을 Buffer로 디코딩합니다.
+     * @param input - 인코딩된 문자열
+     * @param options - 디코딩 옵션
+     * @returns 디코딩된 Buffer
+     */
     abstract decodeToBuffer(input: string, options?: DduOptions): Buffer;
+    /**
+     * 인코딩된 문자열을 원본 문자열로 디코딩합니다.
+     * @param input - 인코딩된 문자열
+     * @param options - 디코딩 옵션
+     * @returns 디코딩된 문자열
+     */
     abstract decode(input: string, options?: DduOptions): string;
     /**
-     * 테스트 및 디버깅용 추상 메서드
-     * 구현 클래스의 내부 상태 정보를 반환
+     * 현재 인코더의 charset 정보를 반환합니다.
+     * @returns charset 설정 정보 객체
      */
     abstract getCharSetInfo(): {
         charSet: string[];

package/dist/mjs/base/BaseDdu.js

@@ -1,48 +1,23 @@
 export class BaseDdu {
     defaultEncoding = "utf-8";
-    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));
-        }
-    }
-    getLargestPowerOfTwo(n) {
-        return 2 ** Math.floor(Math.log2(n));
-    }
+    /**
+     * 주어진 숫자보다 작거나 같은 가장 큰 2의 제곱수의 지수를 반환합니다.
+     * @param n - 대상 숫자
+     * @returns 2의 제곱수 지수 (예: n=8 → 3, n=64 → 6)
+     * @example getLargestPowerOfTwoExponent(8) // 3
+     * @example getLargestPowerOfTwoExponent(100) // 6
+     */
     getLargestPowerOfTwoExponent(n) {
         return Math.floor(Math.log2(n));
     }
+    /**
+     * charset 크기에 필요한 비트 길이를 계산합니다.
+     * @param setLength - charset 문자 수
+     * @returns 필요한 비트 수
+     * @example getBitLength(64) // 6
+     * @example getBitLength(100) // 7
+     */
     getBitLength(setLength) {
         return Math.ceil(Math.log2(setLength));
     }
-    bufferToDduBinary(input, bitLength) {
-        // 성능 최적화: reduce 대신 for loop + join 사용
-        if (input.length === 0) {
-            return { dduBinary: [], padding: 0 };
-        }
-        const binaryParts = new Array(input.length);
-        for (let i = 0; i < input.length; i++) {
-            binaryParts[i] = this.binaryLookup[input[i]];
-        }
-        const encodedBin = binaryParts.join("");
-        const dduBinary = Array.from(this.splitString(encodedBin, bitLength));
-        const padding = bitLength - dduBinary[dduBinary.length - 1].length;
-        if (padding > 0) {
-            dduBinary[dduBinary.length - 1] += "0".repeat(padding);
-        }
-        return { dduBinary, padding };
-    }
-    dduBinaryToBuffer(decodedBin, paddingBits) {
-        if (paddingBits > 0) {
-            decodedBin = decodedBin.slice(0, -paddingBits);
-        }
-        const buffer = [];
-        for (let i = 0; i < decodedBin.length; i += 8) {
-            buffer.push(parseInt(decodedBin.slice(i, i + 8), 2));
-        }
-        return Buffer.from(buffer);
-    }
 }

package/dist/mjs/base/index.js

@@ -1 +1 @@
-export { BaseDdu } from "./BaseDdu";
+export { BaseDdu } from "./BaseDdu.js";

package/dist/mjs/charSets/index.d.ts

@@ -1,4 +1,18 @@
 import { CharSetConfig, DduSetSymbol } from "../types";
+/**
+ * 심볼에 해당하는 charset 설정을 반환합니다.
+ * @param symbol - charset 심볼
+ * @returns CharSetConfig 또는 undefined
+ */
 export declare function getCharSet(symbol: DduSetSymbol): CharSetConfig | undefined;
+/**
+ * 모든 사용 가능한 charset 심볼 목록을 반환합니다.
+ * @returns DduSetSymbol 배열
+ */
 export declare function getAllSymbols(): DduSetSymbol[];
+/**
+ * 해당 심볼의 charset이 존재하는지 확인합니다.
+ * @param symbol - 확인할 charset 심볼
+ * @returns 존재 여부
+ */
 export declare function hasCharSet(symbol: DduSetSymbol): boolean;