@ddunigma/node 2.1.1 → 3.0.0

package/README.md

@@ -1,23 +1,16 @@
-## ddunigma Node
+# ddunigma Node
 
 [![npm version](https://badge.fury.io/js/@ddunigma%2Fnode.svg)](https://www.npmjs.com/package/@ddunigma/node)
 
-## Overview
-
-Node.js implementation of [ddunigma](https://github.com/i3l3/ddunigma) (Python original)
-
 커스텀 charset을 사용하는 Base64 스타일 인코더/디코더 라이브러리입니다.
 
-### Credits
+V2 추가사항
 
-- Original Python Implementation by:
-  - [@i3ls](https://github.com/i3l3)
-  - [@gunu3371](https://github.com/gunu3371)
-- Original Repository: [ddunigma](https://github.com/i3l3/ddunigma)
+- 이제 한글 종성 결합 시스템을 활용하여 8개 기본 문자 × 8개 종성으로 64가지 조합을 만들어, 6비트를 한 글자로 표현합니다.
 
 ## Requirements
 
-- **Node.js >= 14.0.0**
+- **Node.js >= 18.0.0**
 
 ## Install
 
@@ -25,136 +18,143 @@ Node.js implementation of [ddunigma](https://github.com/i3l3/ddunigma) (Python o
 npm install @ddunigma/node
 ```
 
-## Usage
+## Quick Start
+
+```typescript
+import { Ddu64, DduSetSymbol } from "@ddunigma/node";
+
+// V2 (기본, 한글 종성 결합 64개)
+const ddu = new Ddu64();
+ddu.encode("안녕하세요"); // "뎯땩잇땨뎪뎨잇잉뎯욱잇우뎯땨읶뎨뎯땩듂잊"
+ddu.decode("뎯땩잇땨뎪뎨잇잉뎯욱잇우뎯땨읶뎨뎯땩듂잊"); // "안녕하세요"
+
+// V1 (구버전 호환, 8개 문자 쌍 방식)
+const dduV1 = new Ddu64(undefined, undefined, { dduSetSymbol: DduSetSymbol.DDU_V1 });
+dduV1.encode("안녕하세요"); // ".우땨땨이?땨뜌.이.뜌이?이!.우우땨이?우뜌.우땨뜌이이.뜌.우땨땨!이이야"
+dduV1.decode(".우땨땨이?땨뜌.이.뜌이?이!.우우땨이?우뜌.우땨뜌이이.뜌.우땨땨!이이야"); // "안녕하세요"
+```
+
+---
+
+## 기본 사용법
 
-### 기본 인코딩/디코딩
+### 인코딩/디코딩
 
 ```typescript
 import { Ddu64 } from "@ddunigma/node";
 
-// 커스텀 charset으로 인코더 생성
-const encoder = new Ddu64("우따야", "뭐");
-
-const text = "Hello World!";
-const encoded = encoder.encode(text);
-console.log(encoded); // 우따야뭐우따... (인코딩된 문자열)
+const encoder = new Ddu64();
 
+const encoded = encoder.encode("Hello World!");
 const decoded = encoder.decode(encoded);
-console.log(decoded); // "Hello World!"
 ```
 
-### 미리 정의된 Charset 사용
+### 커스텀 charset
 
 ```typescript
-import { Ddu64, DduSetSymbol } from "@ddunigma/node";
+// 문자열 또는 배열로 charset 지정
+const encoder = new Ddu64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=");
 
-// ONECHARSET (64개 문자)
-const encoder1 = new Ddu64(undefined, undefined, {
-  dduSetSymbol: DduSetSymbol.ONECHARSET,
+// 종성 결합 커스텀 charset (dduChar × codaChar 동적 생성)
+const encoder2 = new Ddu64(["가", "나", "다", "라"], "뭐", {
+  codaChar: ["", "ㄱ", "ㄲ", "ㄷ"], // 4×4 = 16개 조합
 });
+```
 
-// DDU (8개 문자)
-const encoder2 = new Ddu64(undefined, undefined, {
-  dduSetSymbol: DduSetSymbol.DDU,
-});
+### 프리셋
 
-// TWOCHARSET (1024개 문자)
-const encoder3 = new Ddu64(undefined, undefined, {
-  dduSetSymbol: DduSetSymbol.TWOCHARSET,
-});
+| Symbol       | 문자 수 | 비트 | 설명                                 |
+| ------------ | ------- | ---- | ------------------------------------ |
+| `DDU`        | 64      | 6    | 한글 종성 결합 (8 기본문자 × 8 종성) |
+| `DDU_V1`     | 8       | 3    | 구버전 호환 (뜌땨이우야!?.)          |
+| `ONECHARSET` | 64      | 6    | 영문 + 숫자 + 특수문자               |
 
-// THREECHARSET (32768개 문자)
-const encoder4 = new Ddu64(undefined, undefined, {
-  dduSetSymbol: DduSetSymbol.THREECHARSET,
-});
+```typescript
+import { Ddu64, DduSetSymbol } from "@ddunigma/node";
 
-const text = "안녕하세요";
-const encoded = encoder1.encode(text);
-const decoded = encoder1.decode(encoded);
+const encoder = new Ddu64(undefined, undefined, {
+  dduSetSymbol: DduSetSymbol.ONECHARSET,
+});
 ```
 
-### 압축 인코딩
+---
+
+## 고급 기능
+
+### 압축
+
+deflate(기본) 또는 brotli 압축을 지원합니다. 디코딩 시 자동으로 압축 여부를 감지합니다.
 
 ```typescript
-import { Ddu64 } from "@ddunigma/node";
+const encoder = new Ddu64();
 
-// 생성자에서 기본 압축 활성화
-const encoder = new Ddu64(undefined, undefined, {
+// 호출 시 옵션으로 지정
+const encoded = encoder.encode(longText, { compress: true });
+const decoded = encoder.decode(encoded);
+
+// 생성자에서 기본 활성화
+const compressEncoder = new Ddu64(undefined, undefined, {
   compress: true,
+  compressionAlgorithm: "brotli",
+  compressionLevel: 6,
 });
-
-// 또는 encode 호출 시 압축 옵션 지정
-const text = "반복되는 긴 텍스트...".repeat(100);
-const encoded = encoder.encode(text, { compress: true });
-const decoded = encoder.decode(encoded); // 자동으로 압축 해제
 ```
 
-### URL-Safe 인코딩
+### 암호화
 
-```typescript
-import { Ddu64 } from "@ddunigma/node";
+AES-256-GCM 암호화를 내장합니다. 동일한 키로 생성된 인코더만 복호화할 수 있습니다.
 
+```typescript
 const encoder = new Ddu64(undefined, undefined, {
-  dduSetSymbol: DduSetSymbol.ONECHARSET,
-  urlSafe: true, // +, /, = 를 URL 안전 문자로 변환
+  encryptionKey: "my-secret-key",
 });
 
-const encoded = encoder.encode("Hello World!");
-// URL에서 안전하게 사용 가능한 문자열 반환
+const encoded = encoder.encode("비밀 메시지");
+const decoded = encoder.decode(encoded);
 ```
 
-### 체크섬 (무결성 검증)
+### 체크섬
 
-```typescript
-import { Ddu64 } from "@ddunigma/node";
+CRC32 체크섬으로 데이터 무결성을 검증합니다.
 
-const encoder = new Ddu64(undefined, undefined, {
-  checksum: true, // CRC32 체크섬 활성화
-});
+```typescript
+const encoder = new Ddu64();
 
-const encoded = encoder.encode("Important data", { checksum: true });
-const decoded = encoder.decode(encoded); // 자동으로 체크섬 검증
-// 체크섬 불일치 시 에러 발생
+const encoded = encoder.encode(data, { checksum: true });
+const decoded = encoder.decode(encoded, { checksum: true });
+// 데이터 변조 시 에러 발생
 ```
 
-### 암호화
+### URL-Safe
 
-```typescript
-import { Ddu64 } from "@ddunigma/node";
+`+`, `/`, `=` 를 URL 안전 문자(`-`, `_`, `.`)로 변환합니다.
 
-const encoder = new Ddu64(undefined, undefined, {
-  encryptionKey: "my-secret-key-123", // AES-256-GCM 암호화
+```typescript
+const encoder = new Ddu64("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=", {
+  urlSafe: true,
 });
-
-const encoded = encoder.encode("Secret message!");
-const decoded = encoder.decode(encoded); // 자동으로 복호화
 ```
 
+> charset/padding에 `-`, `_`, `.` 가 포함되면 urlSafe를 활성화할 수 없습니다.
+
 ### 청크 분할
 
 ```typescript
-import { Ddu64 } from "@ddunigma/node";
-
 const encoder = new Ddu64();
 
-const encoded = encoder.encode(longData, {
-  chunkSize: 76, // 76자마다 분할
-  chunkSeparator: "\n", // 줄바꿈으로 구분
+const encoded = encoder.encode(data, {
+  chunkSize: 76,
+  chunkSeparator: "\n",
 });
-// 결과: "ABCDxyz...\nEFGHijk...\n..."
-
-const decoded = encoder.decode(encoded); // 자동으로 줄바꿈 제거
+// 디코딩 시 구분자 자동 제거
 ```
 
-### 비동기 인코딩/디코딩
-
-```typescript
-import { Ddu64 } from "@ddunigma/node";
+### 비동기 처리
 
-const encoder = new Ddu64();
+대용량 데이터에서 이벤트 루프 블로킹을 방지합니다.
 
-// 비동기 인코딩 (이벤트 루프 블로킹 방지)
-const encoded = await encoder.encodeAsync(largeData);
+```typescript
+const encoded = await encoder.encodeAsync(largeBuffer);
 const decoded = await encoder.decodeAsync(encoded);
 const buffer = await encoder.decodeToBufferAsync(encoded);
 ```
@@ -162,81 +162,51 @@ const buffer = await encoder.decodeToBufferAsync(encoded);
 ### 진행률 콜백
 
 ```typescript
-import { Ddu64 } from "@ddunigma/node";
-
-const encoder = new Ddu64();
-
-encoder.encode(largeData, {
-  onProgress: (info) => {
-    console.log(`진행률: ${info.percent}%`);
-    console.log(`처리됨: ${info.processedBytes}/${info.totalBytes}`);
+encoder.encode(data, {
+  onProgress: ({ percent, stage }) => {
+    console.log(`${percent}% (${stage})`);
   },
 });
 ```
 
-### 통계/분석
+### 통계
 
 ```typescript
-import { Ddu64 } from "@ddunigma/node";
-
-const encoder = new Ddu64();
-
-const stats = encoder.getStats("Test data", { compress: true });
-console.log(stats);
-// {
-//   originalSize: 9,
-//   encodedSize: 12,
-//   compressedSize: 17,
-//   compressionRatio: 1.89,
-//   expansionRatio: 1.33,
-//   charsetSize: 64,
-//   bitLength: 6
-// }
+const stats = encoder.getStats(data, { compress: true });
+// { originalSize, encodedSize, compressedSize, compressionRatio, expansionRatio, charsetSize, bitLength }
 ```
 
 ### Zip Bomb 방어
 
 ```typescript
-import { Ddu64 } from "@ddunigma/node";
-
 const encoder = new Ddu64(undefined, undefined, {
   maxDecodedBytes: 10 * 1024 * 1024, // 10MB
   maxDecompressedBytes: 50 * 1024 * 1024, // 50MB
 });
-
-// 제한 초과 시 에러 발생
 ```
 
 ---
 
 ## CharsetBuilder
 
-커스텀 charset을 쉽게 생성할 수 있는 빌더 유틸리티입니다.
+커스텀 charset을 빌더 패턴으로 생성합니다.
 
 ```typescript
 import { CharsetBuilder } from "@ddunigma/node";
 
-// 유니코드 범위에서 생성
-const chars1 = CharsetBuilder.fromUnicodeRange(0x4e00, 0x4e3f).build();
-
-// Base64 문자셋
-const chars2 = CharsetBuilder.base64().build();
+// 유니코드 범위
+CharsetBuilder.fromUnicodeRange(0x4e00, 0x4e3f).build();
 
-// 혼동 문자 제외 (0, O, 1, l, I 등)
-const chars3 = CharsetBuilder.base64().excludeConfusing().build();
+// Base64에서 혼동 문자 제외
+CharsetBuilder.base64().excludeConfusing().build();
 
-// 2의 제곱수로 제한
-const chars4 = CharsetBuilder.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
+// 2의 제곱수로 제한 + 시드 셔플
+CharsetBuilder.fromString("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
   .limitToPowerOfTwo()
-  .build(); // 32자
+  .shuffle(12345)
+  .build();
 
-// URL 안전 문자만
-const chars5 = CharsetBuilder.base64().excludeUrlUnsafe().build();
-
-// 시드 기반 셔플
-const chars6 = CharsetBuilder.base64().shuffle(12345).build();
-
-// 패딩 문자와 함께 빌드
+// 패딩 문자 자동 선택
 const { charset, padding } = CharsetBuilder.base64().buildWithPadding();
 ```
 
@@ -244,44 +214,37 @@ const { charset, padding } = CharsetBuilder.base64().buildWithPadding();
 
 ## DduPipeline
 
-다단계 인코딩/암호화/압축을 조합할 수 있는 파이프라인 빌더입니다.
+압축 → 암호화 → 인코딩을 체이닝하고, `reverse()`로 역순 복원합니다.
 
 ```typescript
 import { DduPipeline, Ddu64 } from "@ddunigma/node";
 
-const encoder = new Ddu64();
-
-// 압축 → 암호화 → 인코딩 파이프라인
-const pipeline = new DduPipeline()
-  .compress()
-  .encrypt("my-secret-key")
-  .encode(encoder);
-
-const encoded = pipeline.processToString("Hello World!");
+const pipeline = new DduPipeline().compress(6, "brotli").encrypt("secret-key").encode(new Ddu64());
 
-// 역순 파이프라인으로 복원
+const encoded = pipeline.processToString("Hello");
 const decoded = pipeline.reverse().processToString(encoded);
 ```
 
 ---
 
-## 스트림 지원
+## 스트림
 
-대용량 파일 처리를 위한 스트림 인코딩/디코딩을 지원합니다.
+대용량 파일을 메모리 효율적으로 처리합니다. 스트림 헤더로 압축/암호화를 자동 감지합니다.
 
 ```typescript
 import { Ddu64, createEncodeStream, createDecodeStream } from "@ddunigma/node";
 import fs from "fs";
 
-const encoder = new Ddu64();
+const encoder = new Ddu64(undefined, undefined, {
+  compress: true,
+  encryptionKey: "stream-key",
+});
 
-// 인코딩 스트림
 fs.createReadStream("input.bin")
   .pipe(createEncodeStream(encoder))
-  .pipe(fs.createWriteStream("output.txt"));
+  .pipe(fs.createWriteStream("output.ddu"));
 
-// 디코딩 스트림
-fs.createReadStream("output.txt")
+fs.createReadStream("output.ddu")
   .pipe(createDecodeStream(encoder))
   .pipe(fs.createWriteStream("restored.bin"));
 ```
@@ -292,99 +255,85 @@ fs.createReadStream("output.txt")
 
 ### `new Ddu64(dduChar?, paddingChar?, options?)`
 
-인코더 인스턴스를 생성합니다.
-
-**Parameters:**
-
 | Parameter     | Type                    | Description              |
 | ------------- | ----------------------- | ------------------------ |
 | `dduChar`     | `string \| string[]`    | charset 문자열 또는 배열 |
 | `paddingChar` | `string`                | 패딩 문자                |
 | `options`     | `DduConstructorOptions` | 옵션 객체                |
 
-**DduConstructorOptions:**
-
-| Option                 | Type             | Default     | Description                 |
-| ---------------------- | ---------------- | ----------- | --------------------------- |
-| `dduSetSymbol`         | `DduSetSymbol`   | `DDU`       | 미리 정의된 charset 심볼    |
-| `encoding`             | `BufferEncoding` | `'utf-8'`   | 문자열 인코딩               |
-| `usePowerOfTwo`        | `boolean`        | `true`      | 2의 제곱수 강제 여부        |
-| `useBuildErrorReturn`  | `boolean`        | `false`     | 에러 발생 시 throw 여부     |
-| `compress`             | `boolean`        | `false`     | 기본 압축 활성화            |
-| `maxDecodedBytes`      | `number`         | `67108864`  | 최대 디코딩 바이트 (64MB)   |
-| `maxDecompressedBytes` | `number`         | `67108864`  | 최대 압축해제 바이트 (64MB) |
-| `urlSafe`              | `boolean`        | `false`     | URL-Safe 모드               |
-| `encryptionKey`        | `string`         | `undefined` | AES-256-GCM 암호화 키       |
-| `checksum`             | `boolean`        | `false`     | CRC32 체크섬 활성화         |
-| `chunkSize`            | `number`         | `undefined` | 청크 분할 크기              |
-| `chunkSeparator`       | `string`         | `'\n'`      | 청크 구분자                 |
-
-### `encode(data, options?): string`
-
-데이터를 인코딩합니다.
-
-**DduOptions:**
-
-| Option           | Type       | Description      |
-| ---------------- | ---------- | ---------------- |
-| `compress`       | `boolean`  | 압축 사용 여부   |
-| `checksum`       | `boolean`  | 체크섬 추가 여부 |
-| `chunkSize`      | `number`   | 청크 분할 크기   |
-| `chunkSeparator` | `string`   | 청크 구분자      |
-| `onProgress`     | `function` | 진행률 콜백      |
-
-### `decode(encoded, options?): string`
-
-인코딩된 문자열을 디코딩합니다.
-
-### `decodeToBuffer(encoded, options?): Buffer`
-
-인코딩된 문자열을 Buffer로 직접 디코딩합니다.
+**생성자 옵션:**
+
+| Option                 | Type                    | Default     | Description                   |
+| ---------------------- | ----------------------- | ----------- | ----------------------------- |
+| `dduSetSymbol`         | `DduSetSymbol`          | `DDU`       | 프리셋 심볼                   |
+| `codaChar`             | `string[]`              | —           | 종성 배열 (동적 charset 생성) |
+| `encoding`             | `BufferEncoding`        | `'utf-8'`   | 문자열 인코딩                 |
+| `compress`             | `boolean`               | `false`     | 기본 압축 활성화              |
+| `compressionAlgorithm` | `"deflate" \| "brotli"` | `'deflate'` | 압축 알고리즘                 |
+| `compressionLevel`     | `number`                | `6`         | 압축 레벨                     |
+| `urlSafe`              | `boolean`               | `false`     | URL-Safe 모드                 |
+| `encryptionKey`        | `string`                | —           | AES-256-GCM 암호화 키         |
+| `checksum`             | `boolean`               | `false`     | CRC32 체크섬                  |
+| `chunkSize`            | `number`                | —           | 청크 분할 크기                |
+| `chunkSeparator`       | `string`                | `'\n'`      | 청크 구분자                   |
+| `maxDecodedBytes`      | `number`                | `67108864`  | 최대 디코딩 바이트 (64MB)     |
+| `maxDecompressedBytes` | `number`                | `67108864`  | 최대 압축해제 바이트 (64MB)   |
+| `throwOnError`         | `boolean`               | `false`     | 초기화 오류 시 throw          |
+| `useRepeatPadding`     | `boolean`               | `false`     | 패딩 문자 반복 방식           |
+| `usePowerOfTwo`        | `boolean`               | `true`      | 2의 제곱수 charset 강제       |
+
+**메서드:**
+
+| Method                                   | Return            | Description          |
+| ---------------------------------------- | ----------------- | -------------------- |
+| `encode(data, options?)`                 | `string`          | 인코딩               |
+| `decode(encoded, options?)`              | `string`          | 디코딩               |
+| `decodeToBuffer(encoded, options?)`      | `Buffer`          | Buffer로 디코딩      |
+| `encodeAsync(data, options?)`            | `Promise<string>` | 비동기 인코딩        |
+| `decodeAsync(encoded, options?)`         | `Promise<string>` | 비동기 디코딩        |
+| `decodeToBufferAsync(encoded, options?)` | `Promise<Buffer>` | 비동기 Buffer 디코딩 |
+| `getStats(data, options?)`               | `DduEncodeStats`  | 인코딩 통계          |
+| `getCharSetInfo()`                       | `CharSetInfo`     | charset 정보         |
+
+**encode/decode 옵션 (DduOptions):**
+
+| Option                 | Type                    | Description          |
+| ---------------------- | ----------------------- | -------------------- |
+| `compress`             | `boolean`               | 압축 사용            |
+| `compressionAlgorithm` | `"deflate" \| "brotli"` | 압축 알고리즘        |
+| `compressionLevel`     | `number`                | 압축 레벨            |
+| `checksum`             | `boolean`               | 체크섬 추가/검증     |
+| `chunkSize`            | `number`                | 청크 분할 크기       |
+| `chunkSeparator`       | `string`                | 청크 구분자          |
+| `maxDecodedBytes`      | `number`                | 최대 디코딩 바이트   |
+| `maxDecompressedBytes` | `number`                | 최대 압축해제 바이트 |
+| `onProgress`           | `function`              | 진행률 콜백          |
 
-### `encodeAsync(data, options?): Promise<string>`
-
-비동기로 데이터를 인코딩합니다.
-
-### `decodeAsync(encoded, options?): Promise<string>`
-
-비동기로 데이터를 디코딩합니다.
-
-### `decodeToBufferAsync(encoded, options?): Promise<Buffer>`
-
-비동기로 Buffer로 디코딩합니다.
-
-### `getStats(data, options?): DduEncodeStats`
+---
 
-인코딩 통계 정보를 반환합니다.
+## Testing
 
-```typescript
-{
-  originalSize: number;      // 원본 데이터 크기
-  encodedSize: number;       // 인코딩된 문자열 길이
-  compressedSize?: number;   // 압축된 크기
-  compressionRatio?: number; // 압축률 (0-1)
-  expansionRatio: number;    // 인코딩 확장 비율
-  charsetSize: number;       // charset 크기
-  bitLength: number;         // 비트 길이
-}
+```bash
+pnpm test            # 전체 테스트
+pnpm test:watch      # 워치 모드
+pnpm test:coverage   # 커버리지
 ```
 
-### `getCharSetInfo(): CharSetInfo`
+## Build & Verify
 
-현재 인코더의 charset 정보를 반환합니다.
+```bash
+pnpm build
+pnpm lint
+pnpm bench
+pnpm pack:check
+```
 
 ---
 
-## DduSetSymbol
-
-| Symbol         | 문자 수 | 비트 길이 | 설명                      |
-| -------------- | ------- | --------- | ------------------------- |
-| `DDU`          | 8       | 3         | 한글 + 특수문자 기본 세트 |
-| `ONECHARSET`   | 64      | 6         | 영문 + 숫자 + 특수문자    |
-| `TWOCHARSET`   | 1024    | 10        | 2글자 조합 세트           |
-| `THREECHARSET` | 32768   | 15        | 3글자 조합 세트           |
+## Credits
 
----
+- Original: [@i3ls](https://github.com/i3l3), [@gunu3371](https://github.com/gunu3371)
+- Repository: [ddunigma](https://github.com/i3l3/ddunigma)
 
 ## License
 

package/dist/DduStream-NP3CMCKK.js

@@ -0,0 +1,2 @@
+export{o as DduDecodeStream,n as DduEncodeStream,q as createDecodeStream,p as createEncodeStream}from'./chunk-FVBZKVPE.js';//# sourceMappingURL=DduStream-NP3CMCKK.js.map
+//# sourceMappingURL=DduStream-NP3CMCKK.js.map

package/dist/chunk-FVBZKVPE.js

@@ -0,0 +1,4 @@
+import {Transform,PassThrough}from'stream';import {createBrotliCompress,constants,createDeflate,createBrotliDecompress,createInflate}from'zlib';var N=["-","_","."],E={"":0,\u3131:1,\u3132:2,\u3133:3,\u3134:4,\u3135:5,\u3136:6,\u3137:7,\u3139:8,\u313A:9,\u313B:10,\u313C:11,\u313D:12,\u313E:13,\u313F:14,\u3140:15,\u3141:16,\u3142:17,\u3144:18,\u3145:19,\u3146:20,\u3147:21,\u3148:22,\u314A:23,\u314B:24,\u314C:25,\u314D:26,\u314E:27};function x(n,e){let r=n.charCodeAt(0);if(r<44032||r>55203)return n;let t=r-(r-44032)%28,i=E[e]??0;return String.fromCharCode(t+i)}function P(n,e){let r=new Array(n.length*e.length),t=0;for(let i of n)for(let o of e)r[t++]=x(i,o);return r}var z=(()=>{let n=new Uint32Array(256);for(let e=0;e<256;e++){let r=e;for(let t=0;t<8;t++)r=r>>>1^(r&1?3988292384:0);n[e]=r;}return n})(),H="ELYSIA",K="GRISEO",b="CHK",W="ENC";function F(n){return n.length===0?n:n.replaceAll("+","-").replaceAll("/","_").replaceAll("=",".")}function j(n){return n.length===0?n:n.replaceAll("-","+").replaceAll("_","/").replaceAll(".","=")}function U(n,e,r){if(e<=0||n.length<=e)return n;let t=Math.ceil(n.length/e),i=new Array(t*2-1),o=0;for(let s=0;s<n.length;s+=e)i[o++]=n.slice(s,s+e),s+e<n.length&&(i[o++]=r);return i.join("")}function h(n,e){if(n.length===0)return n;let r=n.replace(/[\r\n]/g,""),t=e&&e!==`
+`&&e!==`\r
+`&&e!=="\r"?e:"";return t.length>0&&r.includes(t)&&(r=r.replaceAll(t,"")),r}function J(n){let e=4294967295;for(let r=0;r<n.length;r++)e=e>>>8^z[(e^n[r])&255];return ((e^4294967295)>>>0).toString(16).padStart(8,"0")}function $(n){let e=n.lastIndexOf(b);if(e===-1)return {data:n,checksum:null};let r=n.slice(e+b.length);return r.length!==8||!/^[0-9a-f]+$/i.test(r)?{data:n,checksum:null}:{data:n.slice(0,e),checksum:r.toLowerCase()}}function C(n,e){let t=n===void 0||!Number.isFinite(n)?6:Math.floor(n);return Math.min(e==="brotli"?11:9,Math.max(0,t))}var c="DDS1";function v(n){return n.length*2+c.length+2}function k(n,e){let r=e.compressionAlgorithm==="brotli"?"B":e.compressionAlgorithm==="deflate"?"D":"N",t=e.encrypted?"1":"0";return `${n}${c}${r}${t}${n}`}function R(n,e){let r=v(e);if(n.length<r||!n.startsWith(e))return null;let t=e.length;if(n.slice(t,t+c.length)!==c)throw new Error("[DduStream decode] Invalid stream header magic");let o=n[t+c.length],s=n[t+c.length+1];if(n.slice(r-e.length,r)!==e)throw new Error("[DduStream decode] Invalid stream header terminator");let a=o==="B"?"brotli":o==="D"?"deflate":o==="N"?void 0:null;if(a===null)throw new Error("[DduStream decode] Invalid stream header compression flag");if(s!=="0"&&s!=="1")throw new Error("[DduStream decode] Invalid stream header encryption flag");return {compressionAlgorithm:a,encrypted:s==="1"}}var m=class extends Transform{prefix;emittedPrefix=false;constructor(e){super(),this.prefix=e;}_transform(e,r,t){try{this.emittedPrefix||(this.push(this.prefix),this.emittedPrefix=!0),this.push(e),t();}catch(i){t(i);}}};function _(n,e){let r=new PassThrough,t=r.write.bind(r);return r.write=function(i,o,s){return typeof o=="function"?n.write(i,o):n.write(i,o,s)},r.end=function(i,o,s){return typeof i=="function"?n.end(i):typeof o=="function"?n.end(i,o):n.end(i,o,s)},e.on("data",i=>t(i)),e.on("end",()=>r.push(null)),e.on("error",i=>r.destroy(i)),n.on("error",i=>r.destroy(i)),r}function A(n){if(n.length===0)return new PassThrough;for(let r=0;r<n.length-1;r++)n[r].pipe(n[r+1]);let e=_(n[0],n[n.length-1]);for(let r of n)r.on("error",t=>{e.destroy(t);});return e}var p=class extends Transform{encoder;buffers;bufferOffset;totalLength;chunkSize;footerCompressionAlgorithm;footerEncrypted;constructor(e,r){super({...r,readableObjectMode:false,writableObjectMode:false}),this.encoder=e;let t=e.getCharSetInfo();this.buffers=[],this.bufferOffset=0,this.totalLength=0,this.footerCompressionAlgorithm=r?.compress??t.defaultCompress?r?.compressionAlgorithm??t.defaultCompressionAlgorithm:void 0,this.footerEncrypted=(r?.encrypt??true)&&t.hasEncryptionKey,this.chunkSize=this.calculateChunkSize(t.bitLength);}calculateChunkSize(e){let r=(o,s)=>s===0?o:r(s,o%s),t=8*e/r(8,e),i=Math.max(1,Math.floor(4096/t));return t*i}_transform(e,r,t){try{for(this.buffers.push(e),this.totalLength+=e.length;this.totalLength>=this.chunkSize;){let i=this.readBytes(this.chunkSize),o=this.encodeChunk(i,!1);this.push(o);}t();}catch(i){t(i);}}_flush(e){try{if(this.totalLength>0){let r=this.readBytes(this.totalLength),t=this.encodeChunk(r,!0);this.push(t);}e();}catch(r){e(r);}}encodeChunk(e,r){return this.encoder.encodeRawBuffer(e,{compressionAlgorithm:r?this.footerCompressionAlgorithm:void 0,encrypted:r?this.footerEncrypted:false,omitFooter:!r})}readBytes(e){if(e<=0||this.totalLength<e)return Buffer.alloc(0);let r=this.buffers[0];if(this.buffers.length===1&&r&&this.bufferOffset===0&&r.length===e)return this.buffers=[],this.totalLength=0,r;let t=Buffer.allocUnsafe(e),i=0;for(;i<e&&this.buffers.length>0;){let o=this.buffers[0],s=o.length-this.bufferOffset,f=Math.min(e-i,s);o.copy(t,i,this.bufferOffset,this.bufferOffset+f),i+=f,this.bufferOffset+=f,this.bufferOffset>=o.length&&(this.buffers.shift(),this.bufferOffset=0);}return this.totalLength-=e,t}},g=class extends Transform{encoder;options;normalizedBuffer;chunkSize;chunkSeparator;separatorTail;constructor(e,r){super({...r,readableObjectMode:false,writableObjectMode:false}),this.encoder=e,this.options={...r,compress:false,checksum:false,encrypt:false},this.normalizedBuffer="";let t=e.getCharSetInfo();this.chunkSeparator=r?.chunkSeparator??t.defaultChunkSeparator,this.separatorTail="",this.chunkSize=1024;}_transform(e,r,t){try{this.appendNormalizedChunk(e.toString("utf-8"));let i=100;for(;this.normalizedBuffer.length>=this.chunkSize+i;){let o=this.normalizedBuffer.slice(0,this.chunkSize);this.normalizedBuffer=this.normalizedBuffer.slice(this.chunkSize);let s=this.encoder.decodeToBuffer(o,this.options);this.push(s);}t();}catch(i){t(i);}}_flush(e){try{if(this.separatorTail.length>0&&(this.normalizedBuffer+=h(this.separatorTail,this.chunkSeparator),this.separatorTail=""),this.normalizedBuffer.length>0){let r=this.encoder.decodeStreamToBuffer(this.normalizedBuffer,this.options);this.push(r),this.normalizedBuffer="";}e();}catch(r){e(r);}}appendNormalizedChunk(e){if(e.length===0)return;let r=Math.max(0,this.chunkSeparator.length-1);if(r===0){this.normalizedBuffer+=h(e,this.chunkSeparator);return}let t=this.separatorTail+e;if(t.length<=r){this.separatorTail=t;return}let i=t.length-r,o=t.slice(0,i);this.separatorTail=t.slice(i),this.normalizedBuffer+=h(o,this.chunkSeparator);}},y=class extends Transform{encoder;options;normalizedBuffer;chunkSeparator;separatorTail;paddingChar;headerLength;mode;innerStream;constructor(e,r){super({...r,readableObjectMode:false,writableObjectMode:false}),this.encoder=e,this.options={...r},this.normalizedBuffer="";let t=e.getCharSetInfo();this.paddingChar=t.paddingChar,this.headerLength=v(t.paddingChar),this.chunkSeparator=r?.chunkSeparator??t.defaultChunkSeparator,this.separatorTail="",this.mode="pending",this.innerStream=null;}_transform(e,r,t){try{if(this.appendNormalizedChunk(e.toString("utf-8")),this.maybeInitializeMode(!1),this.mode==="pipeline"){this.flushBufferedToInner(t);return}t();}catch(i){t(i);}}_flush(e){try{if(this.separatorTail.length>0&&(this.normalizedBuffer+=h(this.separatorTail,this.chunkSeparator),this.separatorTail=""),this.maybeInitializeMode(!0),this.mode==="pipeline"){this.finishInnerPipeline(e);return}if(this.normalizedBuffer.length>0){let r=this.encoder.decodeStreamToBuffer(this.normalizedBuffer,this.options);this.push(r),this.normalizedBuffer="";}e();}catch(r){e(r);}}appendNormalizedChunk(e){if(e.length===0)return;let r=Math.max(0,this.chunkSeparator.length-1);if(r===0){this.normalizedBuffer+=h(e,this.chunkSeparator);return}let t=this.separatorTail+e;if(t.length<=r){this.separatorTail=t;return}let i=t.length-r,o=t.slice(0,i);this.separatorTail=t.slice(i),this.normalizedBuffer+=h(o,this.chunkSeparator);}maybeInitializeMode(e){if(this.mode!=="pending")return;let r=this.paddingChar.length;if(this.normalizedBuffer.length<r){e&&this.normalizedBuffer.length>0&&(this.mode="legacy");return}if(!this.normalizedBuffer.startsWith(this.paddingChar)){this.mode="legacy";return}if(this.normalizedBuffer.length<this.headerLength){if(e)throw new Error("[DduStream decode] Incomplete stream header");return}let t=this.normalizedBuffer.slice(0,this.headerLength),i=R(t,this.paddingChar);if(!i){this.mode="legacy";return}this.mode="pipeline",this.normalizedBuffer=this.normalizedBuffer.slice(this.headerLength),this.initializeInnerPipeline(i);}initializeInnerPipeline(e){if(e.encrypted&&!this.encoder.getCharSetInfo().hasEncryptionKey)throw new Error("[DduStream decode] Encrypted stream requires an encryptionKey");let r=L(this.encoder,{...this.options,streamAutoDetect:false,compress:!!e.compressionAlgorithm,compressionAlgorithm:e.compressionAlgorithm,encrypt:e.encrypted});r.on("data",t=>{this.push(t);}),r.on("error",t=>{this.destroy(t);}),this.innerStream=r;}flushBufferedToInner(e){if(!this.innerStream||this.normalizedBuffer.length===0){e();return}let r=this.normalizedBuffer;if(this.normalizedBuffer="",!this.innerStream.write(Buffer.from(r,"utf-8"))){this.innerStream.once("drain",()=>e());return}e();}finishInnerPipeline(e){if(!this.innerStream){e();return}let r=this.innerStream,t=()=>{r.once("end",()=>e()),r.end();};if(this.normalizedBuffer.length>0){let i=this.normalizedBuffer;if(this.normalizedBuffer="",!r.write(Buffer.from(i,"utf-8"))){r.once("drain",t);return}}t();}};function Z(n,e){let r=n.getCharSetInfo(),t=e?.compress??r.defaultCompress,i=(e?.encrypt??true)&&r.hasEncryptionKey,o=e?.streamAutoDetect!==false,s=t?e?.compressionAlgorithm??r.defaultCompressionAlgorithm:void 0,f=new p(n,e),a=[];if(t){let l=s??r.defaultCompressionAlgorithm,u=l==="brotli",S=C(e?.compressionLevel??r.defaultCompressionLevel,l),T=u?createBrotliCompress({params:{[constants.BROTLI_PARAM_QUALITY]:Math.min(11,Math.max(0,S))}}):createDeflate({level:Math.min(9,Math.max(0,S))});a.push(T);}if(i){let l=n.createEncryptionStream();l&&a.push(l);}return a.push(f),o&&a.push(new m(k(r.paddingChar,{compressionAlgorithm:s,encrypted:i}))),a.length===1?f:A(a)}function L(n,e){if(e?.streamAutoDetect??true)return new y(n,e);let t=n.getCharSetInfo(),i=e?.compress??t.defaultCompress,o=(e?.encrypt??true)&&t.hasEncryptionKey,s=new g(n,e),f=[s];if(o){let a=n.createDecryptionStream();a&&f.push(a);}if(i){let u=(e?.compressionAlgorithm??t.defaultCompressionAlgorithm)==="brotli"?createBrotliDecompress():createInflate();f.push(u);}return f.length===1?s:A(f)}export{N as a,P as b,H as c,K as d,b as e,W as f,F as g,j as h,U as i,h as j,J as k,$ as l,C as m,p as n,g as o,Z as p,L as q};//# sourceMappingURL=chunk-FVBZKVPE.js.map
+//# sourceMappingURL=chunk-FVBZKVPE.js.map