@ddunigma/node 4.0.1 → 5.0.0

package/README.md

@@ -43,403 +43,195 @@ dduV1.decode(".우땨땨이?땨뜌.이.뜌이?이!.우우땨이?우뜌.우땨뜌
 
 ---
 
-## Binary Data
+## 5.0.0 사용법
+
+### 문자열과 바이너리
 
 ```typescript
+import { Ddu64 } from "@ddunigma/node";
+
 const ddu = new Ddu64();
-const input = new Uint8Array([0, 1, 127, 128, 255]);
 
-const encoded = ddu.encode(input);
-const bytes = ddu.decodeToUint8Array(encoded);
-const buffer = ddu.decodeToBuffer(encoded); // Node.js entry only
+const encodedText = ddu.encode("안녕하세요");
+const decodedText = ddu.decode(encodedText);
+
+const encodedBytes = ddu.encode(new Uint8Array([0, 1, 127, 128, 255]));
+const decodedBytes = ddu.decodeToUint8Array(encodedBytes);
+const decodedBuffer = ddu.decodeToBuffer(encodedBytes); // Node.js 전용
 ```
 
-## Presets
+### 프리셋
 
 ```typescript
 import { Ddu64, DduSetSymbol } from "@ddunigma/node";
 
-// 기본값 - 한글 종성 결합 64문자
-new Ddu64();
-
-// 구버전 호환 8문자 (아래 두 방법 모두 사용가능)
-new Ddu64({ dduSetSymbol: DduSetSymbol.DDU_V1 });
-new Ddu64(undefined, undefined, { dduSetSymbol: DduSetSymbol.DDU_V1 });
-
-// 영문+숫자 64문자 (아래 두 방법 모두 사용가능)
-new Ddu64({ dduSetSymbol: DduSetSymbol.ONECHARSET });
-new Ddu64(undefined, undefined, { dduSetSymbol: DduSetSymbol.ONECHARSET });
+const ddu = new Ddu64();
+const legacy = new Ddu64({ dduSetSymbol: DduSetSymbol.DDU_V1 });
+const oneCharset = new Ddu64({ dduSetSymbol: DduSetSymbol.ONECHARSET });
 ```
 
-| Symbol       | 문자 수 | 설명                               |
-| ------------ | ------: | ---------------------------------- |
-| `DDU`        |      64 | 한글 기본 문자 8개 × 종성 8개 조합 |
-| `DDU_V1`     |       8 | 기존 8문자 쌍 방식 (하위 호환)     |
-| `ONECHARSET` |      64 | 영문, 숫자, 일부 특수문자          |
-
-## Custom Charset
+### 커스텀 charset
 
 ```typescript
-// 문자열로 직접 지정
-const base64Like = new Ddu64(
-  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-  "=",
-);
-
-// 한글 종성 조합으로 커스텀 charset 생성
-const hangulCoda = new Ddu64(["가", "나", "다", "라"], "뭐", {
+import { Ddu64 } from "@ddunigma/node";
+
+const base64 = new Ddu64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=");
+
+const hangul = new Ddu64(["가", "나", "다", "라"], "뭐", {
   codaChar: ["", "ㄱ", "ㄲ", "ㄷ"],
 });
-// → 가, 각, 갂, 갇, 나, 낙, 낚, 낟, 다, 닥, 닦, 닫, 라, 락, 랔, 랗 (16문자)
 ```
 
-커스텀 charset의 각 심볼과 `paddingChar`는 단일 UTF-16 코드 유닛 문자여야 합니다.
-이모지처럼 surrogate pair가 필요한 문자나 여러 문자로 이루어진 심볼은 지원하지 않습니다.
-
-## CharsetBuilder
-
-```typescript
-import { CharsetBuilder, Ddu64 } from "@ddunigma/node";
+charset 문자와 `paddingChar`는 각각 단일 UTF-16 코드 유닛이어야 합니다.
 
-// Base64에서 혼동 문자 제거 후 2의 제곱수로 맞추기
-const { charset, padding } = CharsetBuilder.base64()
-  .excludeConfusing()
-  .limitToPowerOfTwo()
-  .buildWithPadding();
+### 사용 가능한 옵션
 
-const ddu = new Ddu64(charset, padding);
+생성자 옵션은 인스턴스의 기본값으로 적용됩니다. `encode`, `decode`, `getStats` 계열 메서드에
+같은 옵션을 전달하면 해당 호출에서만 기본값을 덮어씁니다.
 
-// 유니코드 범위에서 생성
-const chars = CharsetBuilder.fromUnicodeRange(0x4e00, 0x4e3f)
-  .shuffle(12345)
-  .limitToPowerOfTwo()
-  .build();
-```
+#### 공통 옵션
 
-## Compression
+| 옵션                   | 타입                              | 기본값      | 용도                               |
+| ---------------------- | --------------------------------- | ----------- | ---------------------------------- |
+| `compress`             | `boolean`                         | `false`     | 압축 사용                          |
+| `compressionAlgorithm` | `"deflate" \| "brotli"`           | `"deflate"` | 압축 알고리즘                      |
+| `compressionLevel`     | `number`                          | `6`         | 압축 레벨                          |
+| `checksum`             | `boolean`                         | `false`     | CRC32 체크섬 추가 및 검증          |
+| `checksumScope`        | `"plaintext" \| "output"`         | `"output"`  | CRC32 계산 범위                    |
+| `chunkSize`            | `number`                          | 미사용      | 출력 문자열 분할 크기              |
+| `chunkSeparator`       | `string`                          | `"\n"`      | 청크 구분자                        |
+| `maxDecodedBytes`      | `number`                          | `67108864`  | 최대 디코딩 바이트 수              |
+| `maxDecompressedBytes` | `number`                          | `67108864`  | 최대 압축 해제 바이트 수           |
+| `obfuscate`            | `boolean`                         | `false`     | 암호화된 출력을 한글 음절로 난독화 |
+| `onProgress`           | `(info: DduProgressInfo) => void` | 미사용      | 처리 진행률 콜백                   |
 
-```typescript
-const ddu = new Ddu64({
-  compress: true, // 압축 활성화
-  compressionAlgorithm: "deflate", // "deflate" | "brotli"
-  compressionLevel: 6, // deflate: 0-9, brotli: 0-11
-});
+#### 생성자 전용 옵션
 
-const encoded = ddu.encode("A".repeat(1000)); // 압축되어 짧아짐
-const decoded = ddu.decode(encoded);
-```
+| 옵션               | 타입                   | 기본값      | 용도                                |
+| ------------------ | ---------------------- | ----------- | ----------------------------------- |
+| `dduSetSymbol`     | `DduSetSymbol`         | `DDU`       | 기본 charset 프리셋 선택            |
+| `dduChar`          | `string \| string[]`   | 프리셋 사용 | 커스텀 charset                      |
+| `codaChar`         | `string[]`             | 미사용      | 기본 문자와 조합할 한글 종성        |
+| `paddingChar`      | `string`               | 프리셋 사용 | 커스텀 패딩 문자                    |
+| `requiredLength`   | `number`               | `64`        | 필요한 charset 문자 수              |
+| `usePowerOfTwo`    | `boolean`              | 자동 결정   | 2의 제곱수 charset 직접 인덱스 모드 |
+| `useRepeatPadding` | `boolean`              | 프리셋 설정 | 반복 패딩 방식 사용                 |
+| `throwOnError`     | `boolean`              | `true`      | 잘못된 charset 설정에서 예외 발생   |
+| `urlSafe`          | `boolean`              | `false`     | URL-Safe 출력 변환                  |
+| `encryptionKey`    | `string`               | 미사용      | AES-256-GCM 암호화 키               |
+| `keyDerivation`    | `KeyDerivationOptions` | `pbkdf2`    | 암호화 키 파생 방식                 |
+| `adapter`          | `PlatformAdapter`      | 진입점 설정 | 플랫폼 어댑터 직접 주입             |
+| `wasmThreshold`    | `number`               | `16384`     | WASM 사용을 시작할 입력 크기        |
 
-압축은 원본보다 작아질 때만 적용됩니다. 압축 결과가 더 크면 비압축으로 저장됩니다.
-브라우저 진입점은 `deflate-raw`를 지원하는 CompressionStream/DecompressionStream 런타임에서 압축을 사용합니다.
-브라우저 Brotli는 런타임 지원 여부를 feature detection으로 확인하며, Web API 특성상 `compressionLevel`은 적용되지 않을 수 있습니다.
+`encoding`은 레거시 타입 호환을 위해서만 남아 있으며 런타임 문자열 처리는 항상 UTF-8입니다.
+`encrypt`와 `omitFooter`는 스트림 및 내부 파이프라인 제어용이므로 일반 사용에서는 지정하지 않습니다.
 
-## Encryption
+### 압축, 암호화, 체크섬
 
 ```typescript
-// SHA-256 키 파생 (기본)
+import { Ddu64 } from "@ddunigma/node";
+
 const ddu = new Ddu64({
+  compress: true,
+  compressionAlgorithm: "deflate",
+  compressionLevel: 6,
   encryptionKey: "my-secret-key",
-});
-
-const encoded = ddu.encode("secret message");
-const decoded = ddu.decode(encoded); // 같은 키로만 복호화 가능
-
-// PBKDF2 키 파생
-const dduPbkdf2 = new Ddu64({
-  encryptionKey: "user password",
   keyDerivation: {
     algorithm: "pbkdf2",
-    salt: "app-specific-salt",
+    salt: "my-application-salt",
     iterations: 210_000,
-    hash: "SHA-256",
   },
+  checksum: true,
 });
-```
 
-PBKDF2 `iterations`는 기본값이 `210_000`이며, `10_000` 미만의 양수는 `10_000`으로 보정됩니다.
-0 이하 또는 유한하지 않은 값은 기본값으로 대체됩니다.
+const encoded = ddu.encode("보호할 데이터");
+const decoded = ddu.decode(encoded);
+```
 
-## Checksum
+복호화할 때는 인코딩에 사용한 `encryptionKey`와 키 파생 설정을 동일하게 사용해야 합니다.
+체크섬을 호출별 옵션으로 사용한 경우 디코딩에도 `checksum: true`를 지정합니다.
 
 ```typescript
-const ddu = new Ddu64({ checksum: true });
-
-const encoded = ddu.encode("data"); // CRC32 체크섬 포함
-const decoded = ddu.decode(encoded); // 무결성 검증 후 반환
+const encoded = ddu.encode("data", { checksum: true });
+const decoded = ddu.decode(encoded, { checksum: true });
 ```
 
-## URL-Safe
+### URL-Safe와 청크 분할
 
 ```typescript
 const ddu = new Ddu64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=", {
   urlSafe: true,
-});
-
-// +→- /→_ =→. 로 자동 변환
-const encoded = ddu.encode("URL safe text");
-```
-
-## Chunking
-
-```typescript
-const ddu = new Ddu64({
   chunkSize: 76,
   chunkSeparator: "\n",
 });
 
-const encoded = ddu.encode("long data ".repeat(100));
-// 76자마다 줄바꿈 삽입
+const encoded = ddu.encode("long data");
+const decoded = ddu.decode(encoded);
 ```
 
-## Obfuscation (한글 난독화)
+### 한글 난독화
 
 ```typescript
 const ddu = new Ddu64({
-  encryptionKey: "secret",
-  obfuscate: true, // 암호화 필수
+  encryptionKey: "my-secret-key",
+  obfuscate: true,
 });
 
-const encoded = ddu.encode("hello");
-// 출력이 한글 음절 블록(U+AC00–U+D7A3)으로 변환됨
-```
-
-## Async (브라우저 호환)
-
-```typescript
-// 브라우저에서는 async 메서드 사용
-import { Ddu64 } from "@ddunigma/node/browser";
-
-const ddu = new Ddu64();
-const encoded = await ddu.encodeAsync("browser text");
-const decoded = await ddu.decodeAsync(encoded);
+const encoded = ddu.encode("secret");
+const decoded = ddu.decode(encoded);
 ```
 
-Node.js에서도 async 메서드를 사용할 수 있습니다. v4부터 루트 진입점(`@ddunigma/node`)은 런타임 조건형 export를 사용하므로 브라우저 번들러와 Workers 계열 런타임에서는 BrowserAdapter 경로로 해석됩니다. 명시적인 브라우저 경로가 필요하면 `@ddunigma/node/browser`를 사용하세요.
-코어 진입점(`@ddunigma/node/core`)은 기본 인코딩/디코딩만 포함하며, 압축/암호화가 필요하면 명시적으로 어댑터를 전달하세요.
+난독화에는 암호화 키가 필요하며 `obfuscate: true`와 `encrypt: false`를 함께 사용할 수 없습니다.
 
-## Web Streams
+### 브라우저와 Workers
 
 ```typescript
-import { Ddu64, createReadableEncodeStream, createReadableDecodeStream } from "@ddunigma/node";
+import { Ddu64 } from "@ddunigma/node/browser";
 
 const ddu = new Ddu64({
   compress: true,
-  encryptionKey: "stream-key",
+  checksum: true,
 });
 
-const encodedStream = readableByteStream.pipeThrough(
-  createReadableEncodeStream(ddu, { compress: true }),
-);
-
-const decodedStream = encodedStream.pipeThrough(createReadableDecodeStream(ddu));
+const encoded = await ddu.encodeAsync("browser data");
+const decoded = await ddu.decodeAsync(encoded);
+const bytes = await ddu.decodeToUint8ArrayAsync(encoded);
 ```
 
-인코딩 스트림은 압축/암호화/체크섬이 꺼져 있고 2의 제곱수 charset일 때 청크 단위로 즉시 출력합니다.
-디코딩 스트림은 footer의 압축/암호화 메타데이터를 최종 신뢰하므로 payload를 모아 `flush`에서 처리합니다.
+브라우저 압축은 실행 환경의 `CompressionStream`과 `DecompressionStream` 지원 여부에 따라 사용할 수
+있습니다.
 
-## WASM Acceleration
+### 인코딩 통계
 
 ```typescript
-import { Ddu64, preloadWasm } from "@ddunigma/node";
-
-await preloadWasm(); // 동기 encode/decode hot path에서 WASM을 쓰려면 먼저 완료되어야 함
-
-const ddu = new Ddu64({
-  wasmThreshold: 4096, // 이 크기 이상일 때 WASM 사용
-  // wasmThreshold: Infinity, // WASM hot path 비활성화
-});
-
-const encoded = ddu.encode(new Uint8Array(1024 * 1024));
+const stats = ddu.getStats("payload");
+const asyncStats = await ddu.getStatsAsync("payload", { compress: true });
 ```
 
-`encode()`/`decode()`의 동기 hot path는 이미 로드된 WASM만 사용합니다.
-`preloadWasm()`이 완료되지 않았거나 WASM을 사용할 수 없으면 JavaScript로 폴백됩니다.
-
-## Progress Callback
-
-```typescript
-const ddu = new Ddu64({ compress: true });
-
-ddu.encode("data", {
-  onProgress: ({ percent, stage }) => {
-    console.log(`${stage}: ${percent}%`);
-    // stage: start → compress → encrypt → encode → done
-  },
-});
-```
+브라우저에서 압축 통계를 계산할 때는 `getStatsAsync`를 사용합니다.
 
-## Stats
+### WASM 가속
 
 ```typescript
-const ddu = new Ddu64({ compress: true });
-const stats = ddu.getStats("A".repeat(1000));
-
-// { originalSize, encodedSize, compressedSize, compressionRatio, expansionRatio, charsetSize, bitLength }
-```
+import { Ddu64, preloadWasm } from "@ddunigma/node";
 
-## Size Limits
+await preloadWasm();
 
-```typescript
 const ddu = new Ddu64({
-  maxDecodedBytes: 10 * 1024 * 1024, // 디코딩 최대 크기 (기본 64MB)
-  maxDecompressedBytes: 50 * 1024 * 1024, // 압축해제 최대 크기 (기본 64MB)
+  wasmThreshold: 16 * 1024,
 });
 ```
 
-## Custom Errors
+`wasmThreshold: Infinity`를 지정하면 WASM 사용을 비활성화할 수 있습니다.
 
-```typescript
-import { Ddu64, Ddu64ErrorCode, isDdu64Error } from "@ddunigma/node";
-
-const ddu = new Ddu64({ checksum: true });
-
-try {
-  ddu.decode(tamperedInput);
-} catch (err) {
-  if (isDdu64Error(err) && err.code === Ddu64ErrorCode.ChecksumMismatch) {
-    // 체크섬 불일치 처리
-  }
-}
-```
-
-인코딩, 디코딩, 압축, 암호화, 체크섬, charset, 크기 제한, adapter, stream 실패는
-`Ddu64Error` 계열로 래핑됩니다. 모든 공개 진입점(`@ddunigma/node`,
-`@ddunigma/node/browser`, `@ddunigma/node/core`)에서 같은 에러 타입과
-`Ddu64ErrorCode`를 export합니다.
-
----
-
-## API
-
-### Node Entry
-
-```typescript
-class Ddu64 {
-  encode(data: string | Uint8Array, options?: DduOptions): string;
-  decode(encoded: string, options?: DduOptions): string;
-  decodeToUint8Array(encoded: string, options?: DduOptions): Uint8Array;
-  decodeToBuffer(encoded: string, options?: DduOptions): Buffer;
-
-  encodeAsync(data: string | Uint8Array, options?: DduOptions): Promise<string>;
-  decodeAsync(encoded: string, options?: DduOptions): Promise<string>;
-  decodeToUint8ArrayAsync(encoded: string, options?: DduOptions): Promise<Uint8Array>;
-  decodeToBufferAsync(encoded: string, options?: DduOptions): Promise<Buffer>;
-
-  getStats(data: string | Uint8Array, options?: DduOptions): DduEncodeStats;
-  getCharSetInfo(): CharSetInfo;
-}
-```
-
-### Browser Entry
+### 진입점
 
 ```typescript
-class Ddu64 {
-  encode(data: string | Uint8Array, options?: DduOptions): string;
-  decode(encoded: string, options?: DduOptions): string;
-  decodeToUint8Array(encoded: string, options?: DduOptions): Uint8Array;
-
-  encodeAsync(data: string | Uint8Array, options?: DduOptions): Promise<string>;
-  decodeAsync(encoded: string, options?: DduOptions): Promise<string>;
-  decodeToUint8ArrayAsync(encoded: string, options?: DduOptions): Promise<Uint8Array>;
-
-  getStats(data: string | Uint8Array, options?: DduOptions): DduEncodeStats;
-  getCharSetInfo(): CharSetInfo;
-}
-```
-
-브라우저 진입점(`@ddunigma/node/browser`)은 `Buffer` API를 노출하지 않습니다.
+import { Ddu64 as NodeDdu64 } from "@ddunigma/node";
+import { Ddu64 as BrowserDdu64 } from "@ddunigma/node/browser";
+import { Ddu64 as CoreDdu64 } from "@ddunigma/node/core";
 
-### Core Entry
-
-```typescript
-class Ddu64 {
-  encode(data: string | Uint8Array, options?: DduOptions): string;
-  decode(encoded: string, options?: DduOptions): string;
-  decodeToUint8Array(encoded: string, options?: DduOptions): Uint8Array;
-
-  encodeAsync(data: string | Uint8Array, options?: DduOptions): Promise<string>;
-  decodeAsync(encoded: string, options?: DduOptions): Promise<string>;
-  decodeToUint8ArrayAsync(encoded: string, options?: DduOptions): Promise<Uint8Array>;
-
-  getStats(data: string | Uint8Array, options?: DduOptions): DduEncodeStats;
-  getCharSetInfo(): CharSetInfo;
-}
+const nodeEncoder = new NodeDdu64();
+const browserEncoder = new BrowserDdu64();
+const coreEncoder = new CoreDdu64();
 ```
-
-코어 진입점(`@ddunigma/node/core`)은 플랫폼 어댑터를 자동 로드하지 않습니다.
-압축 또는 암호화가 필요한 async 호출에는 `adapter`를 명시적으로 전달하세요.
-
-## Constructor Options
-
-```typescript
-// 옵션만 전달 (권장)
-new Ddu64(options?);
-
-// charset 직접 지정
-new Ddu64(dduChar, paddingChar, options?);
-```
-
-| Option                 | Type                    | Default     | 설명                  |
-| ---------------------- | ----------------------- | ----------- | --------------------- |
-| `dduSetSymbol`         | `DduSetSymbol`          | `DDU`       | 프리셋 선택           |
-| `dduChar`              | `string \| string[]`    | -           | 커스텀 charset        |
-| `paddingChar`          | `string`                | -           | 패딩 문자             |
-| `codaChar`             | `string[]`              | -           | 종성 조합 문자        |
-| `compress`             | `boolean`               | `false`     | 압축 활성화           |
-| `compressionAlgorithm` | `"deflate" \| "brotli"` | `"deflate"` | 압축 알고리즘         |
-| `compressionLevel`     | `number`                | `6`         | 압축 레벨             |
-| `encryptionKey`        | `string`                | -           | AES-256-GCM 암호화 키 |
-| `keyDerivation`        | `KeyDerivationOptions`  | `sha256`    | 키 파생 방식          |
-| `checksum`             | `boolean`               | `false`     | CRC32 체크섬          |
-| `urlSafe`              | `boolean`               | `false`     | URL-Safe 변환         |
-| `obfuscate`            | `boolean`               | `false`     | 한글 난독화           |
-| `chunkSize`            | `number`                | -           | 청크 분할 크기        |
-| `chunkSeparator`       | `string`                | `"\n"`      | 청크 구분자           |
-| `maxDecodedBytes`      | `number`                | `67108864`  | 디코딩 크기 제한      |
-| `maxDecompressedBytes` | `number`                | `67108864`  | 압축해제 크기 제한    |
-| `wasmThreshold`        | `number`                | `4096`      | WASM 사용 임계값 (`Infinity`면 비활성화) |
-| `throwOnError`         | `boolean`               | `false`     | 초기화 에러 시 throw  |
-
-## Per-Call Options
-
-`encode`, `decode`, `encodeAsync`, `decodeAsync` 등에서 호출별로 오버라이드 가능:
-
-| Option                 | Type                    | 설명               |
-| ---------------------- | ----------------------- | ------------------ |
-| `compress`             | `boolean`               | 압축 사용 여부     |
-| `compressionAlgorithm` | `"deflate" \| "brotli"` | 압축 알고리즘      |
-| `compressionLevel`     | `number`                | 압축 레벨          |
-| `encrypt`              | `boolean`               | 암호화 사용 여부   |
-| `checksum`             | `boolean`               | 체크섬 사용 여부   |
-| `obfuscate`            | `boolean`               | 난독화 사용 여부   |
-| `chunkSize`            | `number`                | 청크 크기          |
-| `maxDecodedBytes`      | `number`                | 디코딩 크기 제한   |
-| `maxDecompressedBytes` | `number`                | 압축해제 크기 제한 |
-| `onProgress`           | `(info) => void`        | 진행률 콜백        |
-
-## Entry Points
-
-| Runtime / Target                | Import Path                         | 용도                                  |
-| ------------------------------- | ----------------------------------- | ------------------------------------- |
-| Node.js server/CLI              | `@ddunigma/node`                    | Node.js 전체 기능 (동기+비동기)       |
-| Browser / Vite / webpack        | `@ddunigma/node` 또는 `/browser`    | 브라우저 최적화 (BrowserAdapter 기본) |
-| Cloudflare Workers / Deno / Bun | `@ddunigma/node` 또는 `/browser`    | Node.js 내장 모듈 없는 Web API 경로   |
-| Adapter 직접 주입 최소 번들     | `@ddunigma/node/core`               | 최소 코어 (인코딩/디코딩만)           |
-
-루트 진입점은 v4부터 `browser`/`worker`/`workerd`/`deno`/`bun`/`node` 조건을 가진 conditional export입니다. Node.js에서는 기존처럼 `Buffer` API와 NodeAdapter를 노출하고, 브라우저 및 Workers 계열 번들러에서는 Node.js 내장 모듈 없는 BrowserAdapter 경로로 해석됩니다. 런타임 조건을 알 수 없는 ESM 환경의 기본 fallback도 browser 번들을 사용합니다.
-Node.js 런타임에서는 `node` 조건이 `index.js`/`index.cjs`를 선택하므로 기본 import로 NodeAdapter와 `decodeToBuffer()`를 사용할 수 있습니다.
-
-## Build & Test
-
-```bash
-pnpm test
-pnpm typecheck
-pnpm build
-pnpm lint
-pnpm pack:check
-pnpm bench
-```
-
-## License
-
-BSD-2-Clause

package/dist/BrowserAdapter-HORDDCOE.js

@@ -0,0 +1,2 @@
+export{a as BrowserAdapter}from'./chunk-CQATQOBZ.js';import'./chunk-OQXMQIE3.js';//# sourceMappingURL=BrowserAdapter-HORDDCOE.js.map
+//# sourceMappingURL=BrowserAdapter-HORDDCOE.js.map

package/dist/BrowserAdapter-PB4J6FHX.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkAMOZHHMB_cjs=require('./chunk-AMOZHHMB.cjs');require('./chunk-5NSHXTMN.cjs');Object.defineProperty(exports,"BrowserAdapter",{enumerable:true,get:function(){return chunkAMOZHHMB_cjs.a}});//# sourceMappingURL=BrowserAdapter-PB4J6FHX.cjs.map
+//# sourceMappingURL=BrowserAdapter-PB4J6FHX.cjs.map

package/dist/NodeAdapter-5FBNCJSG.js

@@ -0,0 +1,2 @@
+export{a as NodeAdapter}from'./chunk-7RWUNW5S.js';import'./chunk-OQXMQIE3.js';//# sourceMappingURL=NodeAdapter-5FBNCJSG.js.map
+//# sourceMappingURL=NodeAdapter-5FBNCJSG.js.map

package/dist/NodeAdapter-EQ73FGEJ.cjs

@@ -0,0 +1,2 @@
+'use strict';var chunkHZJ7PU7X_cjs=require('./chunk-HZJ7PU7X.cjs');require('./chunk-5NSHXTMN.cjs');Object.defineProperty(exports,"NodeAdapter",{enumerable:true,get:function(){return chunkHZJ7PU7X_cjs.a}});//# sourceMappingURL=NodeAdapter-EQ73FGEJ.cjs.map
+//# sourceMappingURL=NodeAdapter-EQ73FGEJ.cjs.map

package/dist/{ObfuscationLayer-BRiyE5xu.d.cts → ObfuscationLayer-BDr-0s1M.d.ts}

@@ -1,4 +1,4 @@
-import { P as PlatformAdapter, y as KeyDerivationOptions, D as Ddu64Core, u as DduOptions, O as ObfuscationLayer } from './errors-DxOlTuHc.cjs';
+import { P as PlatformAdapter, y as KeyDerivationOptions, D as Ddu64Core, u as DduOptions, O as ObfuscationLayer } from './errors-DNICpo4L.js';
 
 /**
  * 브라우저 플랫폼 어댑터 구현.
@@ -191,13 +191,31 @@ declare class HangulObfuscationLayer implements ObfuscationLayer {
 /**
  * 주어진 charset 설정에 대한 ObfuscationLayer를 생성합니다.
  *
- * charset 문자와 패딩 문자로부터 완전한 알파벳을 구성한 후
- * 한글 난독화 레이어를 생성합니다.
+ * @deprecated 인코더 출력과 호환되지 않습니다(charset/패딩만 포함, footer 마커·숫자 미포함).
+ * 인코더 출력을 deobfuscate하려면 `createEncoderObfuscationLayer`를, 일반 난독화는 `Ddu64`의
+ * `obfuscate` 옵션을 사용하세요. 이 함수는 다음 메이저에서 제거될 수 있습니다.
+ *
+ * charset 문자와 패딩 문자로부터 알파벳을 구성한 후 한글 난독화 레이어를 생성합니다.
  *
  * @param charSet - 인코딩에 사용되는 charset 문자
  * @param paddingChar - 패딩 문자
  * @returns ObfuscationLayer 인스턴스
  */
 declare function createObfuscationLayer(charSet: string[], paddingChar: string): ObfuscationLayer;
+/**
+ * Ddu64 인코더 출력과 호환되는 ObfuscationLayer를 생성합니다.
+ *
+ * `createObfuscationLayer`와 달리 charset/패딩 외에 footer 마커
+ * (ELYSIA/GRISEO/ENC/V3/V4)와 숫자(0-9)까지 알파벳에 포함하므로, 압축/암호화/파이프라인
+ * 마커가 붙은 실제 인코더 출력도 안전하게 deobfuscate할 수 있습니다.
+ *
+ * 일반적으로는 `Ddu64`의 `obfuscate` 옵션을 쓰는 것으로 충분하며, 이 헬퍼는 인코더와
+ * 동일한 난독화 매핑을 외부에서 재현해야 할 때 사용합니다.
+ *
+ * @param charSet - 인코딩에 사용되는 charset 문자
+ * @param paddingChar - 패딩 문자
+ * @returns 인코더 호환 ObfuscationLayer 인스턴스
+ */
+declare function createEncoderObfuscationLayer(charSet: string[], paddingChar: string): ObfuscationLayer;
 
-export { BrowserAdapter as B, HangulObfuscationLayer as H, createReadableDecodeStream as a, createReadableEncodeStream as b, createObfuscationLayer as c, detectRuntime as d };
+export { BrowserAdapter as B, HangulObfuscationLayer as H, createObfuscationLayer as a, createReadableDecodeStream as b, createEncoderObfuscationLayer as c, createReadableEncodeStream as d, detectRuntime as e };

package/dist/{ObfuscationLayer-DZiQGHMw.d.ts → ObfuscationLayer-BgL73E5F.d.cts}

@@ -1,4 +1,4 @@
-import { P as PlatformAdapter, y as KeyDerivationOptions, D as Ddu64Core, u as DduOptions, O as ObfuscationLayer } from './errors-DxOlTuHc.js';
+import { P as PlatformAdapter, y as KeyDerivationOptions, D as Ddu64Core, u as DduOptions, O as ObfuscationLayer } from './errors-DNICpo4L.cjs';
 
 /**
  * 브라우저 플랫폼 어댑터 구현.
@@ -191,13 +191,31 @@ declare class HangulObfuscationLayer implements ObfuscationLayer {
 /**
  * 주어진 charset 설정에 대한 ObfuscationLayer를 생성합니다.
  *
- * charset 문자와 패딩 문자로부터 완전한 알파벳을 구성한 후
- * 한글 난독화 레이어를 생성합니다.
+ * @deprecated 인코더 출력과 호환되지 않습니다(charset/패딩만 포함, footer 마커·숫자 미포함).
+ * 인코더 출력을 deobfuscate하려면 `createEncoderObfuscationLayer`를, 일반 난독화는 `Ddu64`의
+ * `obfuscate` 옵션을 사용하세요. 이 함수는 다음 메이저에서 제거될 수 있습니다.
+ *
+ * charset 문자와 패딩 문자로부터 알파벳을 구성한 후 한글 난독화 레이어를 생성합니다.
  *
  * @param charSet - 인코딩에 사용되는 charset 문자
  * @param paddingChar - 패딩 문자
  * @returns ObfuscationLayer 인스턴스
  */
 declare function createObfuscationLayer(charSet: string[], paddingChar: string): ObfuscationLayer;
+/**
+ * Ddu64 인코더 출력과 호환되는 ObfuscationLayer를 생성합니다.
+ *
+ * `createObfuscationLayer`와 달리 charset/패딩 외에 footer 마커
+ * (ELYSIA/GRISEO/ENC/V3/V4)와 숫자(0-9)까지 알파벳에 포함하므로, 압축/암호화/파이프라인
+ * 마커가 붙은 실제 인코더 출력도 안전하게 deobfuscate할 수 있습니다.
+ *
+ * 일반적으로는 `Ddu64`의 `obfuscate` 옵션을 쓰는 것으로 충분하며, 이 헬퍼는 인코더와
+ * 동일한 난독화 매핑을 외부에서 재현해야 할 때 사용합니다.
+ *
+ * @param charSet - 인코딩에 사용되는 charset 문자
+ * @param paddingChar - 패딩 문자
+ * @returns 인코더 호환 ObfuscationLayer 인스턴스
+ */
+declare function createEncoderObfuscationLayer(charSet: string[], paddingChar: string): ObfuscationLayer;
 
-export { BrowserAdapter as B, HangulObfuscationLayer as H, createReadableDecodeStream as a, createReadableEncodeStream as b, createObfuscationLayer as c, detectRuntime as d };
+export { BrowserAdapter as B, HangulObfuscationLayer as H, createObfuscationLayer as a, createReadableDecodeStream as b, createEncoderObfuscationLayer as c, createReadableEncodeStream as d, detectRuntime as e };

package/dist/browser.cjs

@@ -1,2 +1,2 @@
-'use strict';var chunkWS6GB27C_cjs=require('./chunk-WS6GB27C.cjs'),chunkFACJ5LAG_cjs=require('./chunk-FACJ5LAG.cjs'),chunkRFBXQWSA_cjs=require('./chunk-RFBXQWSA.cjs');require('./chunk-NY4FGVF3.cjs');var e=class extends chunkFACJ5LAG_cjs.B{constructor(s,n,p){let o=chunkFACJ5LAG_cjs.x(s,n,p),u={...o.dduOptions,adapter:o.dduOptions?.adapter??new chunkRFBXQWSA_cjs.a};super(o.dduChar,o.paddingChar,u);}};async function z(){return new chunkRFBXQWSA_cjs.a}Object.defineProperty(exports,"createReadableDecodeStream",{enumerable:true,get:function(){return chunkWS6GB27C_cjs.c}});Object.defineProperty(exports,"createReadableEncodeStream",{enumerable:true,get:function(){return chunkWS6GB27C_cjs.b}});Object.defineProperty(exports,"detectRuntime",{enumerable:true,get:function(){return chunkWS6GB27C_cjs.a}});Object.defineProperty(exports,"CharsetBuilder",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.C}});Object.defineProperty(exports,"Ddu64AdapterError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.s}});Object.defineProperty(exports,"Ddu64CharsetError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.q}});Object.defineProperty(exports,"Ddu64ChecksumError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.p}});Object.defineProperty(exports,"Ddu64CompressionError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.l}});Object.defineProperty(exports,"Ddu64Core",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.B}});Object.defineProperty(exports,"Ddu64DecodeError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.k}});Object.defineProperty(exports,"Ddu64DecompressionError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.m}});Object.defineProperty(exports,"Ddu64DecryptionError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.o}});Object.defineProperty(exports,"Ddu64EncodeError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.j}});Object.defineProperty(exports,"Ddu64EncryptionError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.n}});Object.defineProperty(exports,"Ddu64Error",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.i}});Object.defineProperty(exports,"Ddu64ErrorCode",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.h}});Object.defineProperty(exports,"Ddu64LimitError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.r}});Object.defineProperty(exports,"Ddu64ObfuscationError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.t}});Object.defineProperty(exports,"Ddu64StreamError",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.u}});Object.defineProperty(exports,"DduSetSymbol",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.a}});Object.defineProperty(exports,"HangulObfuscationLayer",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.b}});Object.defineProperty(exports,"createObfuscationLayer",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.c}});Object.defineProperty(exports,"getWasmCodec",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.e}});Object.defineProperty(exports,"getWasmCodecSync",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.f}});Object.defineProperty(exports,"isDdu64Error",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.v}});Object.defineProperty(exports,"preloadWasm",{enumerable:true,get:function(){return chunkFACJ5LAG_cjs.d}});Object.defineProperty(exports,"BrowserAdapter",{enumerable:true,get:function(){return chunkRFBXQWSA_cjs.a}});exports.Ddu64=e;exports.Ddu64Browser=e;exports.getAdapter=z;//# sourceMappingURL=browser.cjs.map
+'use strict';var chunkWCXD5LRF_cjs=require('./chunk-WCXD5LRF.cjs'),chunkUMA4JEN4_cjs=require('./chunk-UMA4JEN4.cjs'),chunkAMOZHHMB_cjs=require('./chunk-AMOZHHMB.cjs');require('./chunk-5NSHXTMN.cjs');var e=class extends chunkUMA4JEN4_cjs.C{constructor(n,s,a){let r=chunkUMA4JEN4_cjs.B(n,s,a),u={...r.dduOptions,...r.dduChar!==void 0?{dduChar:r.dduChar}:{},...r.paddingChar!==void 0?{paddingChar:r.paddingChar}:{},adapter:r.dduOptions?.adapter??new chunkAMOZHHMB_cjs.a};super(u);}};async function F(){return new chunkAMOZHHMB_cjs.a}Object.defineProperty(exports,"createReadableDecodeStream",{enumerable:true,get:function(){return chunkWCXD5LRF_cjs.c}});Object.defineProperty(exports,"createReadableEncodeStream",{enumerable:true,get:function(){return chunkWCXD5LRF_cjs.b}});Object.defineProperty(exports,"detectRuntime",{enumerable:true,get:function(){return chunkWCXD5LRF_cjs.a}});Object.defineProperty(exports,"CharsetBuilder",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.D}});Object.defineProperty(exports,"Ddu64AdapterError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.w}});Object.defineProperty(exports,"Ddu64CharsetError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.u}});Object.defineProperty(exports,"Ddu64ChecksumError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.t}});Object.defineProperty(exports,"Ddu64CompressionError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.p}});Object.defineProperty(exports,"Ddu64Core",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.C}});Object.defineProperty(exports,"Ddu64DecodeError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.o}});Object.defineProperty(exports,"Ddu64DecompressionError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.q}});Object.defineProperty(exports,"Ddu64DecryptionError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.s}});Object.defineProperty(exports,"Ddu64EncodeError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.n}});Object.defineProperty(exports,"Ddu64EncryptionError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.r}});Object.defineProperty(exports,"Ddu64Error",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.m}});Object.defineProperty(exports,"Ddu64ErrorCode",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.l}});Object.defineProperty(exports,"Ddu64LimitError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.v}});Object.defineProperty(exports,"Ddu64ObfuscationError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.x}});Object.defineProperty(exports,"Ddu64StreamError",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.y}});Object.defineProperty(exports,"DduSetSymbol",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.a}});Object.defineProperty(exports,"HangulObfuscationLayer",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.e}});Object.defineProperty(exports,"createEncoderObfuscationLayer",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.g}});Object.defineProperty(exports,"createObfuscationLayer",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.f}});Object.defineProperty(exports,"getWasmCodec",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.i}});Object.defineProperty(exports,"getWasmCodecSync",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.j}});Object.defineProperty(exports,"isDdu64Error",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.z}});Object.defineProperty(exports,"preloadWasm",{enumerable:true,get:function(){return chunkUMA4JEN4_cjs.h}});Object.defineProperty(exports,"BrowserAdapter",{enumerable:true,get:function(){return chunkAMOZHHMB_cjs.a}});exports.Ddu64=e;exports.Ddu64Browser=e;exports.getAdapter=F;//# sourceMappingURL=browser.cjs.map
 //# sourceMappingURL=browser.cjs.map

package/dist/browser.d.cts

@@ -1,7 +1,7 @@
-import { B as BrowserAdapter } from './ObfuscationLayer-BRiyE5xu.cjs';
-export { H as HangulObfuscationLayer, c as createObfuscationLayer, a as createReadableDecodeStream, b as createReadableEncodeStream, d as detectRuntime } from './ObfuscationLayer-BRiyE5xu.cjs';
-import { D as Ddu64Core, a as DduConstructorOptions } from './errors-DxOlTuHc.cjs';
-export { C as CharSetConfig, b as CharSetInfo, c as CharsetBuilder, d as Ddu64AdapterError, e as Ddu64CharsetError, f as Ddu64ChecksumError, g as Ddu64CompressionError, h as Ddu64DecodeError, i as Ddu64DecompressionError, j as Ddu64DecryptionError, k as Ddu64EncodeError, l as Ddu64EncryptionError, m as Ddu64Error, n as Ddu64ErrorCode, o as Ddu64ErrorOptions, p as Ddu64LimitError, q as Ddu64ObfuscationError, r as Ddu64Operation, s as Ddu64StreamError, t as DduEncodeStats, u as DduOptions, v as DduProgressInfo, w as DduSetSymbol, x as DduTextEncoding, E as EncodingProfile, K as KeyDerivationAlgorithm, y as KeyDerivationOptions, O as ObfuscationLayer, P as PlatformAdapter, W as WasmCodec, z as isDdu64Error } from './errors-DxOlTuHc.cjs';
+import { B as BrowserAdapter } from './ObfuscationLayer-BgL73E5F.cjs';
+export { H as HangulObfuscationLayer, c as createEncoderObfuscationLayer, a as createObfuscationLayer, b as createReadableDecodeStream, d as createReadableEncodeStream, e as detectRuntime } from './ObfuscationLayer-BgL73E5F.cjs';
+import { D as Ddu64Core, a as DduConstructorOptions } from './errors-DNICpo4L.cjs';
+export { C as CharSetConfig, b as CharSetInfo, c as CharsetBuilder, d as Ddu64AdapterError, e as Ddu64CharsetError, f as Ddu64ChecksumError, g as Ddu64CompressionError, h as Ddu64DecodeError, i as Ddu64DecompressionError, j as Ddu64DecryptionError, k as Ddu64EncodeError, l as Ddu64EncryptionError, m as Ddu64Error, n as Ddu64ErrorCode, o as Ddu64ErrorOptions, p as Ddu64LimitError, q as Ddu64ObfuscationError, r as Ddu64Operation, s as Ddu64StreamError, t as DduEncodeStats, u as DduOptions, v as DduProgressInfo, w as DduSetSymbol, x as DduTextEncoding, E as EncodingProfile, K as KeyDerivationAlgorithm, y as KeyDerivationOptions, O as ObfuscationLayer, P as PlatformAdapter, W as WasmCodec, z as isDdu64Error } from './errors-DNICpo4L.cjs';
 export { getWasmCodec, getWasmCodecSync, preloadWasm } from './core.cjs';
 
 /**