@ddunigma/node 1.0.10 → 1.0.12

package/dist/cjs/index.js

@@ -3,31 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ddu64 = void 0;
 class Ddu64 {
     constructor(dduChar, paddingChar) {
-        this.dduCharKr = ["뜌", "땨", "이", "우", "야", "!", "?", "."];
+        this.dduCharKr = [
+            "뜌",
+            "땨",
+            "이",
+            "우",
+            "야",
+            "!",
+            "?",
+            ".",
+        ];
         this.paddingCharKr = "뭐";
         this.defaultEncoding = "utf-8";
-        this.dduChar = dduChar || this.dduCharKr;
-        this.paddingChar = paddingChar || this.paddingCharKr;
         this.bitLengthMap = new Map();
-        this.binaryLookup = new Array(256);
+        this.binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
         this.dduBinaryLookup = new Map();
         this.dduBinaryLookupKr = new Map();
         this.paddingRegex = new Map();
-        for (let i = 0; i < 256; i++) {
-            this.binaryLookup[i] = i.toString(2).padStart(8, '0');
-        }
-        this.dduChar.forEach((char, index) => {
-            this.dduBinaryLookup.set(char, index);
-        });
-        this.dduCharKr.forEach((char, index) => {
-            this.dduBinaryLookupKr.set(char, index);
-        });
-        this.paddingRegex.set('default', new RegExp(this.paddingChar, "g"));
-        this.paddingRegex.set('KR', new RegExp(this.paddingCharKr, "g"));
-    }
-    getLargestPowerOfTwo(n) {
-        let power = Math.floor(Math.log2(n));
-        return Math.pow(2, power);
+        this.dduChar = dduChar || this.dduCharKr;
+        this.paddingChar = paddingChar || this.paddingCharKr;
+        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
+        this.dduCharKr.forEach((char, index) => this.dduBinaryLookupKr.set(char, index));
+        this.paddingRegex.set("default", new RegExp(this.paddingChar, "g"));
+        this.paddingRegex.set("KR", new RegExp(this.paddingCharKr, "g"));
     }
     getBitLength(setLength) {
         let cached = this.bitLengthMap.get(setLength);
@@ -37,122 +35,99 @@ class Ddu64 {
         }
         return cached;
     }
+    getLargestPowerOfTwo(n) {
+        return Math.pow(2, Math.floor(Math.log2(n)));
+    }
     *splitString(s, length) {
-        const len = s.length;
-        for (let i = 0; i < len; i += length) {
-            yield s.slice(i, Math.min(i + length, len));
+        for (let i = 0; i < s.length; i += length) {
+            yield s.slice(i, Math.min(i + length, s.length));
         }
     }
-    getSelectedSets(option) {
-        if (option === "KR") {
-            return {
-                dduSet: this.dduCharKr,
-                padChar: this.paddingCharKr,
-                dduLength: this.dduCharKr.length,
-                bitLength: this.getBitLength(this.dduCharKr.length),
-                lookupTable: this.dduBinaryLookupKr,
-                paddingRegExp: this.paddingRegex.get('KR')
-            };
+    getSelectedSets(dduSetSymbol, usePowerOfTwo) {
+        const isKR = dduSetSymbol === "KR";
+        const dduSet = isKR ? this.dduCharKr : this.dduChar;
+        const padChar = isKR ? this.paddingCharKr : this.paddingChar;
+        let dduLength = dduSet.length;
+        if (usePowerOfTwo) {
+            const powerOfTwoLength = this.getLargestPowerOfTwo(dduLength);
+            dduLength = powerOfTwoLength;
         }
         return {
-            dduSet: this.dduChar,
-            padChar: this.paddingChar,
-            dduLength: this.dduChar.length,
-            bitLength: this.getBitLength(this.dduChar.length),
-            lookupTable: this.dduBinaryLookup,
-            paddingRegExp: this.paddingRegex.get('default')
+            dduSet: usePowerOfTwo ? dduSet.slice(0, dduLength) : dduSet,
+            padChar,
+            dduLength,
+            bitLength: this.getBitLength(dduLength),
+            lookupTable: isKR ? this.dduBinaryLookupKr : this.dduBinaryLookup,
+            paddingRegExp: this.paddingRegex.get(isKR ? "KR" : "default"),
         };
     }
-    getSelectedSets64(option) {
-        const baseSet = this.getSelectedSets(option);
-        const powerOfTwoLength = this.getLargestPowerOfTwo(baseSet.dduSet.length);
-        return Object.assign(Object.assign({}, baseSet), { dduSet: baseSet.dduSet.slice(0, powerOfTwoLength), dduLength: powerOfTwoLength, bitLength: Math.log2(powerOfTwoLength) });
-    }
     bufferToDduBinary(input, bitLength) {
-        const bufferLength = input.length;
-        let encodedBin = '';
-        for (let i = 0; i < bufferLength; i++) {
-            encodedBin += this.binaryLookup[input[i]];
-        }
+        const encodedBin = input.reduce((acc, byte) => acc + this.binaryLookup[byte], "");
         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);
+            dduBinary[dduBinary.length - 1] += "0".repeat(padding);
         }
         return { dduBinary, padding };
     }
-    dduBinaryToBuffer(decodedBin, paddingCount) {
-        const paddingBits = paddingCount * 2;
+    dduBinaryToBuffer(decodedBin, paddingBits) {
         if (paddingBits > 0) {
             decodedBin = decodedBin.slice(0, -paddingBits);
         }
-        const chunkCount = Math.floor(decodedBin.length / 8);
-        const buffer = new Array(chunkCount);
-        for (let i = 0; i < chunkCount; i++) {
-            const start = i * 8;
-            buffer[i] = parseInt(decodedBin.slice(start, start + 8), 2);
+        const buffer = [];
+        for (let i = 0; i < decodedBin.length; i += 8) {
+            buffer.push(parseInt(decodedBin.slice(i, i + 8), 2));
         }
-        return buffer;
+        return Buffer.from(buffer);
     }
-    encode(input, option = "default", encoding = this.defaultEncoding) {
-        const bufferInput = typeof input === 'string' ? Buffer.from(input, encoding) : input;
-        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(option);
+    encode(input, options = {}) {
+        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = false, } = options;
+        const bufferInput = typeof input === "string" ? Buffer.from(input, encoding) : input;
+        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
         const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
         let resultString = "";
-        for (const char of dduBinary) {
-            const charInt = parseInt(char, 2);
-            const quotient = Math.floor(charInt / dduLength);
-            const remainder = charInt % dduLength;
-            resultString += dduSet[quotient] + dduSet[remainder];
+        for (const binaryChunk of dduBinary) {
+            const charInt = parseInt(binaryChunk, 2);
+            if (usePowerOfTwo) {
+                resultString += dduSet[charInt];
+            }
+            else {
+                const quotient = Math.floor(charInt / dduLength);
+                const remainder = charInt % dduLength;
+                resultString += dduSet[quotient] + dduSet[remainder];
+            }
         }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
-        }
-        return resultString;
-    }
-    encode64(input, option = "default", encoding = this.defaultEncoding) {
-        const bufferInput = typeof input === 'string' ? Buffer.from(input, encoding) : input;
-        const { dduSet, padChar, bitLength } = this.getSelectedSets64(option);
-        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
-        let resultString = "";
-        for (const char of dduBinary) {
-            const charInt = parseInt(char, 2);
-            resultString += dduSet[charInt];
-        }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
-        }
-        return resultString;
+        return padding > 0
+            ? resultString + padChar.repeat(Math.floor(padding / 2))
+            : resultString;
     }
-    decode(input, option = "default", encoding = this.defaultEncoding) {
-        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(option);
+    decode(input, options = {}) {
+        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = false, } = options;
+        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
         const paddingCount = (input.match(paddingRegExp) || []).length;
-        input = input.replace(paddingRegExp, '');
+        const paddingBits = paddingCount * 2;
+        input = input.replace(paddingRegExp, "");
         let dduBinary = "";
-        for (let i = 0; i < input.length; i += 2) {
-            const firstIndex = lookupTable.get(input[i]);
-            const secondIndex = lookupTable.get(input[i + 1]);
-            if (firstIndex === undefined || secondIndex === undefined)
-                continue;
-            const value = firstIndex * dduLength + secondIndex;
-            dduBinary += value.toString(2).padStart(bitLength, '0');
-        }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingCount);
-        return Buffer.from(decoded).toString(encoding);
-    }
-    decode64(input, option = "default", encoding = this.defaultEncoding) {
-        const { dduSet, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets64(option);
-        const paddingCount = (input.match(paddingRegExp) || []).length;
-        input = input.replace(paddingRegExp, '');
-        let dduBinary = '';
-        for (let i = 0; i < input.length; i++) {
-            const charIndex = lookupTable.get(input[i]);
-            if (charIndex === undefined)
-                continue;
-            dduBinary += charIndex.toString(2).padStart(bitLength, '0');
+        for (let i = 0; i < input.length; i += usePowerOfTwo ? 1 : 2) {
+            const firstChar = input[i];
+            const secondChar = input[i + 1];
+            if (usePowerOfTwo) {
+                const charIndex = lookupTable.get(firstChar);
+                if (charIndex === undefined)
+                    throw new Error(`Invalid character: ${firstChar}`);
+                dduBinary += charIndex.toString(2).padStart(bitLength, "0");
+            }
+            else {
+                const firstIndex = lookupTable.get(firstChar);
+                const secondIndex = lookupTable.get(secondChar);
+                if (firstIndex === undefined || secondIndex === undefined)
+                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
+                const value = firstIndex * dduLength + secondIndex;
+                dduBinary += value.toString(2).padStart(bitLength, "0");
+            }
         }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingCount);
-        return Buffer.from(decoded).toString(encoding);
+        const decoded = this.dduBinaryToBuffer(dduBinary, usePowerOfTwo ? paddingBits : paddingCount * bitLength);
+        return decoded.toString(encoding);
     }
 }
 exports.Ddu64 = Ddu64;

package/dist/cjs/test/{test1.js → test2.js}

@@ -26,19 +26,19 @@ const koreanChars = [
 ]; //129
 const ddu64 = new __1.Ddu64(["D", "d", "U", "u", "T", "t", "A", "a"], "응");
 const answer = "안녕 나 안보고싶었어?12";
-const encoded = ddu64.encode64(answer);
+const encoded = ddu64.encode(answer, { usePowerOfTwo: true });
 console.log(encoded);
-const decoded = ddu64.decode64(encoded);
+const decoded = ddu64.decode(encoded, { usePowerOfTwo: true });
 console.log(decoded);
 console.log("=-==");
-const encoded_eng = ddu64.encode(answer, "KR");
+const encoded_eng = ddu64.encode(answer, { dduSetSymbol: "KR" });
 console.log(encoded_eng);
-const decoded_eng = ddu64.decode(encoded_eng, "KR");
+const decoded_eng = ddu64.decode(encoded_eng, { dduSetSymbol: "KR" });
 console.log(decoded_eng);
 console.log("=-==");
 const ddu64_other = new __1.Ddu64(koreanChars, "즁");
 const answer2 = "안녕나안보고싶었어?스스로칭찬하려니까부담되는걸?하지만기록은완성해야하니까어쩔수없지~엘리시아는상냥하고,친근하고,귀엽고,똑똑하고아름다운소녀야.그녀의초대를거절하거나그녀를냉정하게대할수있는사람은없어.전설속의엘프처럼모든이의마음을사로잡고13명의영웅을이곳에모았으면서첫번째자리를양보하는겸손함까지...영웅들에게엘리시아는가장믿음직스럽고사랑받는동료야.너희도그렇게생각하지?1";
-const encoded2 = ddu64_other.encode64(answer2);
+const encoded2 = ddu64_other.encode(answer2, { usePowerOfTwo: true });
 console.log(encoded2);
-const decoded2 = ddu64_other.decode64(encoded2);
+const decoded2 = ddu64_other.decode(encoded2, { usePowerOfTwo: true });
 console.log(decoded2);

package/dist/cjs/test/tester2.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+function measurePerformance(yaho = -1) {
+    const encoderDecoder = new __1.Ddu64();
+    const testData = `Hello,${yaho} World! Thi${yaho}s is ${yaho}a per${yaho}formance te${yaho}st for e${yaho}ncod${yaho}ing an${yaho}d decod${yaho}ing.`;
+    // 메모리 사용량 측정
+    const initialMemoryUsage = process.memoryUsage().heapUsed;
+    // CPU 사용량 측정
+    const initialCpuUsage = process.cpuUsage();
+    // 인코딩 성능 테스트
+    const encodeStartTime = performance.now();
+    const encodedData = encoderDecoder.encode(testData);
+    const encodeEndTime = performance.now();
+    const encodeTime = encodeEndTime - encodeStartTime;
+    // 디코딩 성능 테스트
+    const decodeStartTime = performance.now();
+    const decodedData = encoderDecoder.decode(encodedData);
+    const decodeEndTime = performance.now();
+    const decodeTime = decodeEndTime - decodeStartTime;
+    // 메모리 사용량 측정
+    const finalMemoryUsage = process.memoryUsage().heapUsed;
+    const memoryUsage = finalMemoryUsage - initialMemoryUsage;
+    const finalCpuUsage = process.cpuUsage(initialCpuUsage);
+    const cpuUsage = finalCpuUsage.user + finalCpuUsage.system;
+    return { encodeTime, decodeTime, memoryUsage, cpuUsage };
+}
+const result1 = measurePerformance();
+console.log(`Encode Time: ${result1.encodeTime.toFixed(2)} ms`);
+console.log(`Decode Time: ${result1.decodeTime.toFixed(2)} ms`);
+console.log(`Memory Usage: ${result1.memoryUsage} bytes`);
+console.log(`CPU Usage: ${result1.cpuUsage} microseconds\n`);
+const yaho = 10000;
+let yaho2 = yaho;
+console.log(`loop ${yaho}`);
+while (--yaho2 > 0) {
+    const result2 = measurePerformance(yaho);
+    result1.encodeTime += result2.encodeTime;
+    result1.decodeTime += result2.decodeTime;
+    result1.memoryUsage += result2.memoryUsage;
+    result1.cpuUsage += result2.cpuUsage;
+}
+console.log(`Encode Time: ${(result1.encodeTime / yaho).toFixed(2)} ms`);
+console.log(`Decode Time: ${(result1.decodeTime / yaho).toFixed(2)} ms`);
+console.log(`Memory Usage: ${result1.memoryUsage / yaho} bytes`);
+console.log(`CPU Usage: ${result1.cpuUsage / yaho} microseconds\n`);

package/dist/index.d.ts

@@ -10,15 +10,20 @@ export declare class Ddu64 {
     private readonly dduBinaryLookupKr;
     private readonly paddingRegex;
     constructor(dduChar?: string[], paddingChar?: string);
-    private getLargestPowerOfTwo;
     private getBitLength;
+    private getLargestPowerOfTwo;
     private splitString;
     private getSelectedSets;
-    private getSelectedSets64;
     private bufferToDduBinary;
     private dduBinaryToBuffer;
-    encode(input: Buffer | string, option?: string, encoding?: BufferEncoding): string;
-    encode64(input: Buffer | string, option?: string, encoding?: BufferEncoding): string;
-    decode(input: string, option?: string, encoding?: BufferEncoding): string;
-    decode64(input: string, option?: string, encoding?: BufferEncoding): string;
+    encode(input: Buffer | string, options?: {
+        dduSetSymbol?: string;
+        encoding?: BufferEncoding;
+        usePowerOfTwo?: boolean;
+    }): string;
+    decode(input: string, options?: {
+        dduSetSymbol?: string;
+        encoding?: BufferEncoding;
+        usePowerOfTwo?: boolean;
+    }): string;
 }

package/dist/mjs/index.js

@@ -1,37 +1,30 @@
 export class Ddu64 {
     dduChar;
     paddingChar;
-    dduCharKr = ["뜌", "땨", "이", "우", "야", "!", "?", "."];
+    dduCharKr = [
+        "뜌",
+        "땨",
+        "이",
+        "우",
+        "야",
+        "!",
+        "?",
+        ".",
+    ];
     paddingCharKr = "뭐";
     defaultEncoding = "utf-8";
-    bitLengthMap;
-    binaryLookup;
-    dduBinaryLookup;
-    dduBinaryLookupKr;
-    paddingRegex;
+    bitLengthMap = new Map();
+    binaryLookup = Array.from({ length: 256 }, (_, i) => i.toString(2).padStart(8, "0"));
+    dduBinaryLookup = new Map();
+    dduBinaryLookupKr = new Map();
+    paddingRegex = new Map();
     constructor(dduChar, paddingChar) {
         this.dduChar = dduChar || this.dduCharKr;
         this.paddingChar = paddingChar || this.paddingCharKr;
-        this.bitLengthMap = new Map();
-        this.binaryLookup = new Array(256);
-        this.dduBinaryLookup = new Map();
-        this.dduBinaryLookupKr = new Map();
-        this.paddingRegex = new Map();
-        for (let i = 0; i < 256; i++) {
-            this.binaryLookup[i] = i.toString(2).padStart(8, '0');
-        }
-        this.dduChar.forEach((char, index) => {
-            this.dduBinaryLookup.set(char, index);
-        });
-        this.dduCharKr.forEach((char, index) => {
-            this.dduBinaryLookupKr.set(char, index);
-        });
-        this.paddingRegex.set('default', new RegExp(this.paddingChar, "g"));
-        this.paddingRegex.set('KR', new RegExp(this.paddingCharKr, "g"));
-    }
-    getLargestPowerOfTwo(n) {
-        let power = Math.floor(Math.log2(n));
-        return 2 ** power;
+        this.dduChar.forEach((char, index) => this.dduBinaryLookup.set(char, index));
+        this.dduCharKr.forEach((char, index) => this.dduBinaryLookupKr.set(char, index));
+        this.paddingRegex.set("default", new RegExp(this.paddingChar, "g"));
+        this.paddingRegex.set("KR", new RegExp(this.paddingCharKr, "g"));
     }
     getBitLength(setLength) {
         let cached = this.bitLengthMap.get(setLength);
@@ -41,126 +34,98 @@ export class Ddu64 {
         }
         return cached;
     }
+    getLargestPowerOfTwo(n) {
+        return 2 ** Math.floor(Math.log2(n));
+    }
     *splitString(s, length) {
-        const len = s.length;
-        for (let i = 0; i < len; i += length) {
-            yield s.slice(i, Math.min(i + length, len));
+        for (let i = 0; i < s.length; i += length) {
+            yield s.slice(i, Math.min(i + length, s.length));
         }
     }
-    getSelectedSets(option) {
-        if (option === "KR") {
-            return {
-                dduSet: this.dduCharKr,
-                padChar: this.paddingCharKr,
-                dduLength: this.dduCharKr.length,
-                bitLength: this.getBitLength(this.dduCharKr.length),
-                lookupTable: this.dduBinaryLookupKr,
-                paddingRegExp: this.paddingRegex.get('KR')
-            };
+    getSelectedSets(dduSetSymbol, usePowerOfTwo) {
+        const isKR = dduSetSymbol === "KR";
+        const dduSet = isKR ? this.dduCharKr : this.dduChar;
+        const padChar = isKR ? this.paddingCharKr : this.paddingChar;
+        let dduLength = dduSet.length;
+        if (usePowerOfTwo) {
+            const powerOfTwoLength = this.getLargestPowerOfTwo(dduLength);
+            dduLength = powerOfTwoLength;
         }
         return {
-            dduSet: this.dduChar,
-            padChar: this.paddingChar,
-            dduLength: this.dduChar.length,
-            bitLength: this.getBitLength(this.dduChar.length),
-            lookupTable: this.dduBinaryLookup,
-            paddingRegExp: this.paddingRegex.get('default')
-        };
-    }
-    getSelectedSets64(option) {
-        const baseSet = this.getSelectedSets(option);
-        const powerOfTwoLength = this.getLargestPowerOfTwo(baseSet.dduSet.length);
-        return {
-            ...baseSet,
-            dduSet: baseSet.dduSet.slice(0, powerOfTwoLength),
-            dduLength: powerOfTwoLength,
-            bitLength: Math.log2(powerOfTwoLength)
+            dduSet: usePowerOfTwo ? dduSet.slice(0, dduLength) : dduSet,
+            padChar,
+            dduLength,
+            bitLength: this.getBitLength(dduLength),
+            lookupTable: isKR ? this.dduBinaryLookupKr : this.dduBinaryLookup,
+            paddingRegExp: this.paddingRegex.get(isKR ? "KR" : "default"),
         };
     }
     bufferToDduBinary(input, bitLength) {
-        const bufferLength = input.length;
-        let encodedBin = '';
-        for (let i = 0; i < bufferLength; i++) {
-            encodedBin += this.binaryLookup[input[i]];
-        }
+        const encodedBin = input.reduce((acc, byte) => acc + this.binaryLookup[byte], "");
         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);
+            dduBinary[dduBinary.length - 1] += "0".repeat(padding);
         }
         return { dduBinary, padding };
     }
-    dduBinaryToBuffer(decodedBin, paddingCount) {
-        const paddingBits = paddingCount * 2;
+    dduBinaryToBuffer(decodedBin, paddingBits) {
         if (paddingBits > 0) {
             decodedBin = decodedBin.slice(0, -paddingBits);
         }
-        const chunkCount = Math.floor(decodedBin.length / 8);
-        const buffer = new Array(chunkCount);
-        for (let i = 0; i < chunkCount; i++) {
-            const start = i * 8;
-            buffer[i] = parseInt(decodedBin.slice(start, start + 8), 2);
-        }
-        return buffer;
-    }
-    encode(input, option = "default", encoding = this.defaultEncoding) {
-        const bufferInput = typeof input === 'string' ? Buffer.from(input, encoding) : input;
-        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(option);
-        const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
-        let resultString = "";
-        for (const char of dduBinary) {
-            const charInt = parseInt(char, 2);
-            const quotient = Math.floor(charInt / dduLength);
-            const remainder = charInt % dduLength;
-            resultString += dduSet[quotient] + dduSet[remainder];
+        const buffer = [];
+        for (let i = 0; i < decodedBin.length; i += 8) {
+            buffer.push(parseInt(decodedBin.slice(i, i + 8), 2));
         }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
-        }
-        return resultString;
+        return Buffer.from(buffer);
     }
-    encode64(input, option = "default", encoding = this.defaultEncoding) {
-        const bufferInput = typeof input === 'string' ? Buffer.from(input, encoding) : input;
-        const { dduSet, padChar, bitLength } = this.getSelectedSets64(option);
+    encode(input, options = {}) {
+        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = false, } = options;
+        const bufferInput = typeof input === "string" ? Buffer.from(input, encoding) : input;
+        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
         const { dduBinary, padding } = this.bufferToDduBinary(bufferInput, bitLength);
         let resultString = "";
-        for (const char of dduBinary) {
-            const charInt = parseInt(char, 2);
-            resultString += dduSet[charInt];
+        for (const binaryChunk of dduBinary) {
+            const charInt = parseInt(binaryChunk, 2);
+            if (usePowerOfTwo) {
+                resultString += dduSet[charInt];
+            }
+            else {
+                const quotient = Math.floor(charInt / dduLength);
+                const remainder = charInt % dduLength;
+                resultString += dduSet[quotient] + dduSet[remainder];
+            }
         }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
-        }
-        return resultString;
+        return padding > 0
+            ? resultString + padChar.repeat(Math.floor(padding / 2))
+            : resultString;
     }
-    decode(input, option = "default", encoding = this.defaultEncoding) {
-        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(option);
+    decode(input, options = {}) {
+        const { dduSetSymbol = "default", encoding = this.defaultEncoding, usePowerOfTwo = false, } = options;
+        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(dduSetSymbol, usePowerOfTwo);
         const paddingCount = (input.match(paddingRegExp) || []).length;
-        input = input.replace(paddingRegExp, '');
+        const paddingBits = paddingCount * 2;
+        input = input.replace(paddingRegExp, "");
         let dduBinary = "";
-        for (let i = 0; i < input.length; i += 2) {
-            const firstIndex = lookupTable.get(input[i]);
-            const secondIndex = lookupTable.get(input[i + 1]);
-            if (firstIndex === undefined || secondIndex === undefined)
-                continue;
-            const value = firstIndex * dduLength + secondIndex;
-            dduBinary += value.toString(2).padStart(bitLength, '0');
-        }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingCount);
-        return Buffer.from(decoded).toString(encoding);
-    }
-    decode64(input, option = "default", encoding = this.defaultEncoding) {
-        const { dduSet, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets64(option);
-        const paddingCount = (input.match(paddingRegExp) || []).length;
-        input = input.replace(paddingRegExp, '');
-        let dduBinary = '';
-        for (let i = 0; i < input.length; i++) {
-            const charIndex = lookupTable.get(input[i]);
-            if (charIndex === undefined)
-                continue;
-            dduBinary += charIndex.toString(2).padStart(bitLength, '0');
+        for (let i = 0; i < input.length; i += usePowerOfTwo ? 1 : 2) {
+            const firstChar = input[i];
+            const secondChar = input[i + 1];
+            if (usePowerOfTwo) {
+                const charIndex = lookupTable.get(firstChar);
+                if (charIndex === undefined)
+                    throw new Error(`Invalid character: ${firstChar}`);
+                dduBinary += charIndex.toString(2).padStart(bitLength, "0");
+            }
+            else {
+                const firstIndex = lookupTable.get(firstChar);
+                const secondIndex = lookupTable.get(secondChar);
+                if (firstIndex === undefined || secondIndex === undefined)
+                    throw new Error(`Invalid character: ${firstChar} or ${secondChar}`);
+                const value = firstIndex * dduLength + secondIndex;
+                dduBinary += value.toString(2).padStart(bitLength, "0");
+            }
         }
-        const decoded = this.dduBinaryToBuffer(dduBinary, paddingCount);
-        return Buffer.from(decoded).toString(encoding);
+        const decoded = this.dduBinaryToBuffer(dduBinary, usePowerOfTwo ? paddingBits : paddingCount * bitLength);
+        return decoded.toString(encoding);
     }
 }

package/dist/mjs/test/test2.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/test/{test1.js → test2.js}

@@ -24,19 +24,19 @@ const koreanChars = [
 ]; //129
 const ddu64 = new Ddu64(["D", "d", "U", "u", "T", "t", "A", "a"], "응");
 const answer = "안녕 나 안보고싶었어?12";
-const encoded = ddu64.encode64(answer);
+const encoded = ddu64.encode(answer, { usePowerOfTwo: true });
 console.log(encoded);
-const decoded = ddu64.decode64(encoded);
+const decoded = ddu64.decode(encoded, { usePowerOfTwo: true });
 console.log(decoded);
 console.log("=-==");
-const encoded_eng = ddu64.encode(answer, "KR");
+const encoded_eng = ddu64.encode(answer, { dduSetSymbol: "KR" });
 console.log(encoded_eng);
-const decoded_eng = ddu64.decode(encoded_eng, "KR");
+const decoded_eng = ddu64.decode(encoded_eng, { dduSetSymbol: "KR" });
 console.log(decoded_eng);
 console.log("=-==");
 const ddu64_other = new Ddu64(koreanChars, "즁");
 const answer2 = "안녕나안보고싶었어?스스로칭찬하려니까부담되는걸?하지만기록은완성해야하니까어쩔수없지~엘리시아는상냥하고,친근하고,귀엽고,똑똑하고아름다운소녀야.그녀의초대를거절하거나그녀를냉정하게대할수있는사람은없어.전설속의엘프처럼모든이의마음을사로잡고13명의영웅을이곳에모았으면서첫번째자리를양보하는겸손함까지...영웅들에게엘리시아는가장믿음직스럽고사랑받는동료야.너희도그렇게생각하지?1";
-const encoded2 = ddu64_other.encode64(answer2);
+const encoded2 = ddu64_other.encode(answer2, { usePowerOfTwo: true });
 console.log(encoded2);
-const decoded2 = ddu64_other.decode64(encoded2);
+const decoded2 = ddu64_other.decode(encoded2, { usePowerOfTwo: true });
 console.log(decoded2);

package/dist/mjs/test/tester2.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mjs/test/tester2.js

@@ -0,0 +1,44 @@
+import { Ddu64 } from "..";
+function measurePerformance(yaho = -1) {
+    const encoderDecoder = new Ddu64();
+    const testData = `Hello,${yaho} World! Thi${yaho}s is ${yaho}a per${yaho}formance te${yaho}st for e${yaho}ncod${yaho}ing an${yaho}d decod${yaho}ing.`;
+    // 메모리 사용량 측정
+    const initialMemoryUsage = process.memoryUsage().heapUsed;
+    // CPU 사용량 측정
+    const initialCpuUsage = process.cpuUsage();
+    // 인코딩 성능 테스트
+    const encodeStartTime = performance.now();
+    const encodedData = encoderDecoder.encode(testData);
+    const encodeEndTime = performance.now();
+    const encodeTime = encodeEndTime - encodeStartTime;
+    // 디코딩 성능 테스트
+    const decodeStartTime = performance.now();
+    const decodedData = encoderDecoder.decode(encodedData);
+    const decodeEndTime = performance.now();
+    const decodeTime = decodeEndTime - decodeStartTime;
+    // 메모리 사용량 측정
+    const finalMemoryUsage = process.memoryUsage().heapUsed;
+    const memoryUsage = finalMemoryUsage - initialMemoryUsage;
+    const finalCpuUsage = process.cpuUsage(initialCpuUsage);
+    const cpuUsage = finalCpuUsage.user + finalCpuUsage.system;
+    return { encodeTime, decodeTime, memoryUsage, cpuUsage };
+}
+const result1 = measurePerformance();
+console.log(`Encode Time: ${result1.encodeTime.toFixed(2)} ms`);
+console.log(`Decode Time: ${result1.decodeTime.toFixed(2)} ms`);
+console.log(`Memory Usage: ${result1.memoryUsage} bytes`);
+console.log(`CPU Usage: ${result1.cpuUsage} microseconds\n`);
+const yaho = 10000;
+let yaho2 = yaho;
+console.log(`loop ${yaho}`);
+while (--yaho2 > 0) {
+    const result2 = measurePerformance(yaho);
+    result1.encodeTime += result2.encodeTime;
+    result1.decodeTime += result2.decodeTime;
+    result1.memoryUsage += result2.memoryUsage;
+    result1.cpuUsage += result2.cpuUsage;
+}
+console.log(`Encode Time: ${(result1.encodeTime / yaho).toFixed(2)} ms`);
+console.log(`Decode Time: ${(result1.decodeTime / yaho).toFixed(2)} ms`);
+console.log(`Memory Usage: ${result1.memoryUsage / yaho} bytes`);
+console.log(`CPU Usage: ${result1.cpuUsage / yaho} microseconds\n`);

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@ddunigma/node",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "tsx ./src/test/test.ts",
     "build": "rm -rf dist/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && sh postProcess.sh",
-    "test1": "tsx ./src/test/test1.ts"
+    "test": "tsx ./src/test/test2.ts",
+    "tester": "echo tester2 && tsx ./src/test/tester2.ts && echo tester && tsx ./src/test/tester.ts"
   },
   "exports": {
     ".": {