@ddunigma/node 2.0.2 → 2.1.1

package/dist/mjs/utils/DduPipeline.js

@@ -0,0 +1,223 @@
+import { deflateSync } from "zlib";
+import { Ddu64 } from "../encoders/Ddu64.js";
+import { deriveKey, encryptAes256Gcm, decryptAes256Gcm, inflateWithLimit, } from "./crypto.js";
+/**
+ * 다중 인코딩/암호화/압축을 파이프라인으로 조합할 수 있는 빌더 클래스
+ *
+ * @example
+ * const pipeline = new DduPipeline()
+ *   .compress()
+ *   .encrypt('secret-key')
+ *   .encode(new Ddu64(chars, pad));
+ *
+ * const encoded = pipeline.process('Hello World');
+ * const decoded = pipeline.reverse().process(encoded);
+ */
+export class DduPipeline {
+    steps = [];
+    /**
+     * 압축 단계를 추가합니다.
+     *
+     * @param level - 압축 레벨 (0-9, 기본값: 9)
+     */
+    compress(level = 9) {
+        this.steps.push({ type: "compress", level });
+        return this;
+    }
+    /**
+     * 압축 해제 단계를 추가합니다.
+     *
+     * @param maxDecompressedBytes - 최대 압축해제 바이트 수 (Zip Bomb 방어용)
+     */
+    decompress(maxDecompressedBytes) {
+        this.steps.push({ type: "decompress", maxDecompressedBytes });
+        return this;
+    }
+    /**
+     * AES-256-GCM 암호화 단계를 추가합니다.
+     *
+     * @param key - 암호화 키
+     */
+    encrypt(key) {
+        this.steps.push({ type: "encrypt", key });
+        return this;
+    }
+    /**
+     * AES-256-GCM 복호화 단계를 추가합니다.
+     *
+     * @param key - 복호화 키
+     */
+    decrypt(key) {
+        this.steps.push({ type: "decrypt", key });
+        return this;
+    }
+    /**
+     * Ddu64 인코딩 단계를 추가합니다.
+     *
+     * @param encoder - Ddu64 인코더 인스턴스
+     */
+    encode(encoder) {
+        this.steps.push({ type: "encode", encoder });
+        return this;
+    }
+    /**
+     * Ddu64 디코딩 단계를 추가합니다.
+     *
+     * @param encoder - Ddu64 인코더 인스턴스
+     */
+    decode(encoder) {
+        this.steps.push({ type: "decode", encoder });
+        return this;
+    }
+    /**
+     * 새 인코더를 생성하여 인코딩 단계를 추가합니다.
+     *
+     * @param dduChar - charset 문자열 또는 배열
+     * @param paddingChar - 패딩 문자
+     * @param options - 인코더 옵션
+     */
+    encodeWith(dduChar, paddingChar, options) {
+        const encoder = new Ddu64(dduChar, paddingChar, options);
+        return this.encode(encoder);
+    }
+    /**
+     * 커스텀 Buffer 변환 단계를 추가합니다.
+     *
+     * @param fn - 변환 함수
+     */
+    transform(fn) {
+        this.steps.push({ type: "transform", fn });
+        return this;
+    }
+    /**
+     * 커스텀 문자열 변환 단계를 추가합니다.
+     *
+     * @param fn - 변환 함수
+     */
+    transformString(fn) {
+        this.steps.push({ type: "transformString", fn });
+        return this;
+    }
+    /**
+     * 파이프라인을 역순으로 실행할 새 파이프라인을 생성합니다.
+     */
+    reverse() {
+        const reversed = new DduPipeline();
+        reversed.steps = this.steps
+            .slice()
+            .reverse()
+            .map((step) => {
+            switch (step.type) {
+                case "compress":
+                    return { type: "decompress" };
+                case "decompress":
+                    return { type: "compress", level: 9 };
+                case "encrypt":
+                    return { type: "decrypt", key: step.key };
+                case "decrypt":
+                    return { type: "encrypt", key: step.key };
+                case "encode":
+                    return { type: "decode", encoder: step.encoder };
+                case "decode":
+                    return { type: "encode", encoder: step.encoder };
+                case "transform":
+                case "transformString":
+                    throw new Error(`[DduPipeline reverse] Cannot reverse "${step.type}" step. Custom transform functions are not reversible. Use explicit encode/decode pairs instead.`);
+            }
+        });
+        return reversed;
+    }
+    /**
+     * 파이프라인을 실행합니다.
+     *
+     * @param input - 입력 데이터 (문자열 또는 Buffer)
+     * @returns 처리된 결과 (문자열 또는 Buffer)
+     */
+    process(input) {
+        let data = input;
+        for (const step of this.steps) {
+            data = this.executeStep(step, data);
+        }
+        return data;
+    }
+    /**
+     * 파이프라인을 실행하고 문자열로 반환합니다.
+     */
+    processToString(input, encoding = "utf-8") {
+        const result = this.process(input);
+        if (typeof result === "string")
+            return result;
+        return result.toString(encoding);
+    }
+    /**
+     * 파이프라인을 실행하고 Buffer로 반환합니다.
+     */
+    processToBuffer(input, encoding = "utf-8") {
+        const result = this.process(input);
+        if (Buffer.isBuffer(result))
+            return result;
+        return Buffer.from(result, encoding);
+    }
+    /**
+     * 개별 단계를 실행합니다.
+     */
+    executeStep(step, data) {
+        switch (step.type) {
+            case "compress":
+                return this.compressData(this.toBuffer(data), step.level ?? 9);
+            case "decompress":
+                return this.decompressData(this.toBuffer(data), step.maxDecompressedBytes);
+            case "encrypt":
+                return this.encryptData(this.toBuffer(data), step.key);
+            case "decrypt":
+                return this.decryptData(this.toBuffer(data), step.key);
+            case "encode":
+                return step.encoder.encode(this.toBuffer(data));
+            case "decode":
+                return step.encoder.decodeToBuffer(this.toString(data));
+            case "transform":
+                return step.fn(this.toBuffer(data));
+            case "transformString":
+                return step.fn(this.toString(data));
+        }
+    }
+    toBuffer(data) {
+        return typeof data === "string" ? Buffer.from(data, "utf-8") : data;
+    }
+    toString(data) {
+        return typeof data === "string" ? data : data.toString("utf-8");
+    }
+    compressData(data, level) {
+        return deflateSync(data, { level });
+    }
+    decompressData(data, maxBytes) {
+        return inflateWithLimit(data, maxBytes ?? Number.POSITIVE_INFINITY, "DduPipeline decompress");
+    }
+    encryptData(data, key) {
+        return encryptAes256Gcm(data, deriveKey(key));
+    }
+    decryptData(data, key) {
+        return decryptAes256Gcm(data, deriveKey(key));
+    }
+    /**
+     * 현재 파이프라인의 단계 수를 반환합니다.
+     */
+    get stepCount() {
+        return this.steps.length;
+    }
+    /**
+     * 파이프라인을 복제합니다.
+     */
+    clone() {
+        const cloned = new DduPipeline();
+        cloned.steps = [...this.steps];
+        return cloned;
+    }
+    /**
+     * 파이프라인을 초기화합니다.
+     */
+    clear() {
+        this.steps = [];
+        return this;
+    }
+}

package/dist/mjs/utils/DduStream.d.ts

@@ -0,0 +1,64 @@
+import { Transform, TransformCallback, TransformOptions } from "stream";
+import { Ddu64 } from "../encoders/Ddu64";
+import { DduOptions } from "../types";
+/**
+ * Ddu64 인코딩을 위한 Transform 스트림
+ * (내부적으로 청크 단위 인코딩을 수행합니다. 압축이 필요한 경우
+ * `createEncodeStream` 팩토리 함수를 사용하는 것을 권장합니다.)
+ *
+ * @example
+ * const encoder = new Ddu64(chars, pad);
+ * const stream = new DduEncodeStream(encoder);
+ * fs.createReadStream('input.bin')
+ *   .pipe(stream)
+ *   .pipe(fs.createWriteStream('output.txt'));
+ */
+export declare class DduEncodeStream extends Transform {
+    private encoder;
+    private options;
+    private buffers;
+    private totalLength;
+    private chunkSize;
+    constructor(encoder: Ddu64, options?: DduOptions & TransformOptions);
+    /**
+     * 비트 길이에 맞는 최적의 청크 크기를 계산합니다.
+     */
+    private calculateChunkSize;
+    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private encodeChunk;
+}
+/**
+ * Ddu64 디코딩을 위한 Transform 스트림
+ * (내부적으로 청크 단위 디코딩을 수행합니다. 압축 해제가 필요한 경우
+ * `createDecodeStream` 팩토리 함수를 사용하는 것을 권장합니다.)
+ *
+ * @example
+ * const encoder = new Ddu64(chars, pad);
+ * const stream = new DduDecodeStream(encoder);
+ * fs.createReadStream('input.txt')
+ *   .pipe(stream)
+ *   .pipe(fs.createWriteStream('output.bin'));
+ */
+export declare class DduDecodeStream extends Transform {
+    private encoder;
+    private options;
+    private buffers;
+    private totalLength;
+    private charLength;
+    private chunkSize;
+    constructor(encoder: Ddu64, options?: DduOptions & TransformOptions);
+    private calculateChunkSize;
+    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+}
+/**
+ * Ddu64 인코더에서 스트림을 생성하는 팩토리 함수
+ * 옵션에 따라 압축 스트림을 자동으로 연결합니다.
+ */
+export declare function createEncodeStream(encoder: Ddu64, options?: DduOptions & TransformOptions): NodeJS.ReadWriteStream;
+/**
+ * Ddu64 인코더에서 디코드 스트림을 생성하는 팩토리 함수
+ * 옵션에 따라 압축 해제 스트림을 자동으로 연결합니다.
+ */
+export declare function createDecodeStream(encoder: Ddu64, options?: DduOptions & TransformOptions): NodeJS.ReadWriteStream;

package/dist/mjs/utils/DduStream.js

@@ -0,0 +1,225 @@
+import { Transform, PassThrough } from "stream";
+import { createDeflate, createInflate } from "zlib";
+/**
+ * 두 스트림을 하나의 ReadWrite 스트림으로 결합합니다.
+ * write는 input에, read는 output에서 수행됩니다.
+ */
+function combineStreams(input, output) {
+    const combined = new PassThrough();
+    // write 방향: combined → input
+    const origWrite = combined.write.bind(combined);
+    combined.write = function (chunk, encodingOrCb, cb) {
+        if (typeof encodingOrCb === "function") {
+            return input.write(chunk, encodingOrCb);
+        }
+        return input.write(chunk, encodingOrCb, cb);
+    };
+    combined.end = function (chunk, encodingOrCb, cb) {
+        if (typeof chunk === "function") {
+            return input.end(chunk);
+        }
+        if (typeof encodingOrCb === "function") {
+            return input.end(chunk, encodingOrCb);
+        }
+        return input.end(chunk, encodingOrCb, cb);
+    };
+    // read 방향: output → combined (push)
+    output.on("data", (data) => origWrite(data));
+    output.on("end", () => combined.push(null));
+    output.on("error", (err) => combined.destroy(err));
+    input.on("error", (err) => combined.destroy(err));
+    return combined;
+}
+/**
+ * Ddu64 인코딩을 위한 Transform 스트림
+ * (내부적으로 청크 단위 인코딩을 수행합니다. 압축이 필요한 경우
+ * `createEncodeStream` 팩토리 함수를 사용하는 것을 권장합니다.)
+ *
+ * @example
+ * const encoder = new Ddu64(chars, pad);
+ * const stream = new DduEncodeStream(encoder);
+ * fs.createReadStream('input.bin')
+ *   .pipe(stream)
+ *   .pipe(fs.createWriteStream('output.txt'));
+ */
+export class DduEncodeStream extends Transform {
+    encoder;
+    options;
+    buffers;
+    totalLength;
+    chunkSize;
+    constructor(encoder, options) {
+        super({
+            ...options,
+            readableObjectMode: false,
+            writableObjectMode: false,
+        });
+        this.encoder = encoder;
+        // 스트림 자체에서는 청크 단위 인코딩만 수행하므로
+        // 압축 및 체크섬 옵션은 팩토리 함수(createEncodeStream)에서 스트림 파이핑으로 처리함.
+        this.options = { ...options, compress: false, checksum: false };
+        this.buffers = [];
+        this.totalLength = 0;
+        // 청크 크기: 비트 길이에 따라 최적화 (LCM 기반)
+        const info = encoder.getCharSetInfo();
+        this.chunkSize = this.calculateChunkSize(info.bitLength);
+    }
+    /**
+     * 비트 길이에 맞는 최적의 청크 크기를 계산합니다.
+     */
+    calculateChunkSize(bitLength) {
+        // 8과 bitLength의 최소공배수의 배수로 설정
+        const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b));
+        const lcm = (8 * bitLength) / gcd(8, bitLength);
+        // 적절한 크기로 조정 (4KB ~ 64KB)
+        const multiplier = Math.max(1, Math.floor(4096 / lcm));
+        return lcm * multiplier;
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            this.buffers.push(chunk);
+            this.totalLength += chunk.length;
+            // 청크 크기만큼씩 처리
+            while (this.totalLength >= this.chunkSize) {
+                // 처리할 만큼의 버퍼를 합침
+                const concatBuffer = Buffer.concat(this.buffers, this.totalLength);
+                const toProcess = concatBuffer.subarray(0, this.chunkSize);
+                // 남은 데이터 저장
+                const remainder = concatBuffer.subarray(this.chunkSize);
+                this.buffers = remainder.length > 0 ? [remainder] : [];
+                this.totalLength = remainder.length;
+                // 중간 청크는 패딩 없이 인코딩 (compress 없이)
+                const encoded = this.encodeChunk(toProcess, false);
+                this.push(encoded);
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _flush(callback) {
+        try {
+            // 남은 데이터 처리 (패딩 포함)
+            if (this.totalLength > 0) {
+                const remainingBuffer = Buffer.concat(this.buffers, this.totalLength);
+                const encoded = this.encodeChunk(remainingBuffer, true);
+                this.push(encoded);
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    encodeChunk(data, _isLast) {
+        // options에서 compress: false로 강제되어 있으므로 모든 청크 동일 처리
+        return this.encoder.encode(data, this.options);
+    }
+}
+/**
+ * Ddu64 디코딩을 위한 Transform 스트림
+ * (내부적으로 청크 단위 디코딩을 수행합니다. 압축 해제가 필요한 경우
+ * `createDecodeStream` 팩토리 함수를 사용하는 것을 권장합니다.)
+ *
+ * @example
+ * const encoder = new Ddu64(chars, pad);
+ * const stream = new DduDecodeStream(encoder);
+ * fs.createReadStream('input.txt')
+ *   .pipe(stream)
+ *   .pipe(fs.createWriteStream('output.bin'));
+ */
+export class DduDecodeStream extends Transform {
+    encoder;
+    options;
+    buffers;
+    totalLength;
+    charLength;
+    chunkSize;
+    constructor(encoder, options) {
+        super({
+            ...options,
+            readableObjectMode: false,
+            writableObjectMode: false,
+        });
+        this.encoder = encoder;
+        // 디코딩 스트림에서도 zlib 파이프라인에서 압축 해제를 담당하므로 비활성화
+        this.options = { ...options, compress: false, checksum: false };
+        this.buffers = [];
+        this.totalLength = 0;
+        const info = encoder.getCharSetInfo();
+        this.charLength = info.charLength;
+        // 디코딩 청크 크기
+        this.chunkSize = this.calculateChunkSize(info.charLength);
+    }
+    calculateChunkSize(charLength) {
+        // 문자 길이의 배수로 설정
+        return charLength * 1024;
+    }
+    _transform(chunk, _encoding, callback) {
+        try {
+            // 문자열로 변환하고 줄바꿈 등 제거 후 배열에 추가
+            const chunkStr = chunk.toString("utf-8").replace(/[\r\n\s]/g, "");
+            if (chunkStr.length > 0) {
+                this.buffers.push(chunkStr);
+                this.totalLength += chunkStr.length;
+            }
+            // 청크 크기만큼씩 처리
+            while (this.totalLength >= this.chunkSize) {
+                // 처리할 만큼의 문자열을 합침
+                const concatStr = this.buffers.join("");
+                const toProcess = concatStr.slice(0, this.chunkSize);
+                // 남은 데이터 저장
+                const remainder = concatStr.slice(this.chunkSize);
+                this.buffers = remainder.length > 0 ? [remainder] : [];
+                this.totalLength = remainder.length;
+                const decoded = this.encoder.decodeToBuffer(toProcess, this.options);
+                this.push(decoded);
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _flush(callback) {
+        try {
+            // 남은 데이터 처리
+            if (this.totalLength > 0) {
+                const remainingStr = this.buffers.join("");
+                const decoded = this.encoder.decodeToBuffer(remainingStr, this.options);
+                this.push(decoded);
+            }
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+}
+/**
+ * Ddu64 인코더에서 스트림을 생성하는 팩토리 함수
+ * 옵션에 따라 압축 스트림을 자동으로 연결합니다.
+ */
+export function createEncodeStream(encoder, options) {
+    const encodeStream = new DduEncodeStream(encoder, options);
+    if (options?.compress) {
+        const deflate = createDeflate({ level: 9 });
+        deflate.pipe(encodeStream);
+        return combineStreams(deflate, encodeStream);
+    }
+    return encodeStream;
+}
+/**
+ * Ddu64 인코더에서 디코드 스트림을 생성하는 팩토리 함수
+ * 옵션에 따라 압축 해제 스트림을 자동으로 연결합니다.
+ */
+export function createDecodeStream(encoder, options) {
+    const decodeStream = new DduDecodeStream(encoder, options);
+    if (options?.compress) {
+        const inflate = createInflate();
+        decodeStream.pipe(inflate);
+        return combineStreams(decodeStream, inflate);
+    }
+    return decodeStream;
+}

package/dist/mjs/utils/crypto.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 문자열 키를 AES-256용 32바이트 키로 변환합니다.
+ */
+export declare function deriveKey(key: string): Buffer;
+/**
+ * AES-256-GCM으로 데이터를 암호화합니다.
+ *
+ * @param data - 암호화할 데이터
+ * @param keyHash - 32바이트 해시된 키 (deriveKey로 생성)
+ * @returns iv (12) + authTag (16) + encrypted
+ */
+export declare function encryptAes256Gcm(data: Buffer, keyHash: Buffer): Buffer;
+/**
+ * AES-256-GCM으로 암호화된 데이터를 복호화합니다.
+ *
+ * @param data - 암호화된 데이터 (iv + authTag + encrypted)
+ * @param keyHash - 32바이트 해시된 키 (deriveKey로 생성)
+ * @returns 복호화된 데이터
+ * @throws 데이터가 28바이트 미만이면 에러
+ */
+export declare function decryptAes256Gcm(data: Buffer, keyHash: Buffer): Buffer;
+/**
+ * 크기 제한을 적용하여 zlib 압축을 해제합니다.
+ *
+ * @param data - 압축된 데이터
+ * @param maxBytes - 최대 압축해제 바이트 수
+ * @param context - 에러 메시지에 표시할 컨텍스트 (예: "Ddu64 decode", "DduPipeline decompress")
+ * @returns 압축 해제된 데이터
+ */
+export declare function inflateWithLimit(data: Buffer, maxBytes: number, context?: string): Buffer;

package/dist/mjs/utils/crypto.js

@@ -0,0 +1,78 @@
+import { createCipheriv, createDecipheriv, randomBytes, createHash } from "crypto";
+import { inflateSync } from "zlib";
+/**
+ * 문자열 키를 AES-256용 32바이트 키로 변환합니다.
+ */
+export function deriveKey(key) {
+    return createHash("sha256").update(key).digest();
+}
+/**
+ * AES-256-GCM으로 데이터를 암호화합니다.
+ *
+ * @param data - 암호화할 데이터
+ * @param keyHash - 32바이트 해시된 키 (deriveKey로 생성)
+ * @returns iv (12) + authTag (16) + encrypted
+ */
+export function encryptAes256Gcm(data, keyHash) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", keyHash, iv);
+    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([iv, authTag, encrypted]);
+}
+/**
+ * AES-256-GCM으로 암호화된 데이터를 복호화합니다.
+ *
+ * @param data - 암호화된 데이터 (iv + authTag + encrypted)
+ * @param keyHash - 32바이트 해시된 키 (deriveKey로 생성)
+ * @returns 복호화된 데이터
+ * @throws 데이터가 28바이트 미만이면 에러
+ */
+export function decryptAes256Gcm(data, keyHash) {
+    if (data.length < 28) {
+        throw new Error("[decrypt] Invalid encrypted data: too short");
+    }
+    const iv = data.subarray(0, 12);
+    const authTag = data.subarray(12, 28);
+    const encrypted = data.subarray(28);
+    const decipher = createDecipheriv("aes-256-gcm", keyHash, iv);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
+/**
+ * 크기 제한을 적용하여 zlib 압축을 해제합니다.
+ *
+ * @param data - 압축된 데이터
+ * @param maxBytes - 최대 압축해제 바이트 수
+ * @param context - 에러 메시지에 표시할 컨텍스트 (예: "Ddu64 decode", "DduPipeline decompress")
+ * @returns 압축 해제된 데이터
+ */
+export function inflateWithLimit(data, maxBytes, context = "inflate") {
+    if (maxBytes === Number.POSITIVE_INFINITY)
+        return inflateSync(data);
+    try {
+        return inflateSync(data, { maxOutputLength: maxBytes });
+    }
+    catch (e) {
+        const err = e;
+        const msg = String(err?.message ?? "");
+        const code = String(err?.code ?? "");
+        // maxOutputLength 미지원 시 fallback
+        if (msg.toLowerCase().includes("maxoutputlength") ||
+            msg.toLowerCase().includes("unknown option") ||
+            code === "ERR_INVALID_ARG_VALUE") {
+            const inflated = inflateSync(data);
+            if (inflated.length > maxBytes) {
+                throw new Error(`[${context}] Decompressed data exceeds limit. Size: ${inflated.length} bytes, Limit: ${maxBytes} bytes`);
+            }
+            return inflated;
+        }
+        // 출력 제한 초과
+        if (code === "ERR_BUFFER_TOO_LARGE" ||
+            msg.toLowerCase().includes("output length") ||
+            msg.toLowerCase().includes("buffer too large")) {
+            throw new Error(`[${context}] Decompressed data exceeds limit. Limit: ${maxBytes} bytes`);
+        }
+        throw e;
+    }
+}

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

@@ -0,0 +1,3 @@
+export { CharsetBuilder } from "./CharsetBuilder";
+export { DduPipeline } from "./DduPipeline";
+export { DduEncodeStream, DduDecodeStream, createEncodeStream, createDecodeStream, } from "./DduStream";

package/dist/mjs/utils/index.js

@@ -0,0 +1,3 @@
+export { CharsetBuilder } from "./CharsetBuilder.js";
+export { DduPipeline } from "./DduPipeline.js";
+export { DduEncodeStream, DduDecodeStream, createEncodeStream, createDecodeStream, } from "./DduStream.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ddunigma/node",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/mjs/index.d.ts",
@@ -9,7 +9,8 @@
     "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && sh postProcess.sh",
     "test": "tsx ./src/test/test-quick.ts",
     "test:comprehensive": "tsx ./src/test/test-comprehensive.ts",
-    "test:all": "tsx ./src/test/test-all-integrated.ts",
+    "test:compat": "tsx ./src/test/test-compat.ts",
+    "test:all": "tsx ./src/test/test-quick.ts && tsx ./src/test/test-comprehensive.ts && tsx ./src/test/test-compat.ts",
     "dev": "tsx ./src/test/test-quick.ts"
   },
   "exports": {
@@ -41,7 +42,7 @@
     "enigma",
     "Base64",
     "base conversion",
-    "base64 encord",
+    "base64 encode",
     "base64 decode",
     "base64_encode",
     "base64_decode",