@ddunigma/node 1.0.11 → 1.0.13

package/README.md

@@ -1,23 +1,326 @@
 ## ddunigma-node
 
 ### Overview
+
 Node.js implementation of [ddunigma](https://github.com/i3l3/ddunigma) (Python original)
 
 ### Credits
+
 - Original Python Implementation by:
   - [@i3ls](https://github.com/i3l3)
   - [@gunu3371](https://github.com/gunu3371)
 - Original Repository: [ddunigma](https://github.com/i3l3/ddunigma)
 
 ### Usage
+
+- Use Basic
+
 ```js
-import { Ddu64 } from 'ddunigma-node'
+import { Ddu64 } from "@ddunigma/node";
 
 const ddu64 = new Ddu64(); //default encode utf-8
 
-const answer = "뜌땨어 고수가 될거야!"
+const answer = "뜌땨어 고수가 될거야!";
+
+const encoded = ddu64.encode(answer);
+console.log(encoded);
+//뜌.뜌이뜌.뜌땨뜌?뜌이뜌땨뜌야뜌.뜌이뜌.뜌땨뜌이뜌?뜌!뜌뜌뜌.뜌우뜌땨뜌땨뜌우뜌이뜌?뜌야뜌땨뜌뜌뜌땨뜌?뜌!뜌이뜌?뜌우뜌!뜌뜌뜌땨뜌?뜌?뜌이뜌땨뜌뜌뜌야뜌?뜌땨뜌?뜌!뜌이뜌?뜌뜌뜌야뜌뜌뜌뜌뜌이뜌뜌뜌우뜌!뜌우뜌야뜌야뜌땨뜌이뜌뜌뜌우뜌!뜌이뜌!뜌야뜌우뜌우뜌뜌뜌우뜌!뜌야뜌야뜌!뜌우뜌우뜌?뜌뜌뜌야뜌땨
+const decoded = ddu64.decode(encoded);
+console.log(decoded);
+//뜌땨어 고수가 될거야!
+
+//Encoding Shorter
+const encodedShorter = ddu64.encode(answer, { usePowerOfTwo: true });
+console.log(encodedShorter);
+//.이.땨?이땨야.이.땨이?!뜌.우땨땨우이?야땨뜌땨?!이?우!뜌땨??이땨뜌야?땨?!이?뜌야뜌뜌이뜌우!우야야땨이뜌우!이!야우우뜌우!야야!우우?뜌야땨
+const decodedShorter = ddu64.decode(encodedShorter, { usePowerOfTwo: true });
+console.log(decodedShorter);
+//뜌땨어 고수가 될거야!
+```
+
+- Use Custom Encoding CharSet
+
+```js
+import { Ddu64 } from "@ddunigma/node";
+const koreanChars = [
+  // 뜌 계열
+  "뜌",
+  "뜍",
+  "뜎",
+  "뜏",
+  "뜐",
+  "뜑",
+  "뜒",
+  "뜓",
+  "뜔",
+  "뜕",
+  "뜖",
+  "뜗",
+  "뜘",
+  "뜙",
+  "뜚",
+  "뜛",
+  "뜜",
+  "뜝",
+  "뜞",
+  "뜟",
+  "뜠",
+  "뜡",
+  "뜢",
+  "뜣",
+  "뜤",
+  "뜥",
+  "뜦",
+  "뜧",
+  "뜨",
+  "뜩",
+  "뜪",
+  "뜫",
+  "뜬",
+  "뜭",
+  "뜮",
+  "뜯",
+  "뜰",
+  "뜱",
+  "뜲",
+  "뜳",
+  "뜴",
+  "뜵",
+  "뜶",
+  "뜷",
+  "뜸",
+  "뜹",
+  "뜺",
+  "뜻",
+  "뜼",
+  "뜽",
+  "뜾",
+  "뜿",
+  // 땨 계열
+  "땨",
+  "땩",
+  "땪",
+  "땫",
+  "땬",
+  "땭",
+  "땮",
+  "땯",
+  "땰",
+  "땱",
+  "땲",
+  "땳",
+  "땴",
+  "땵",
+  "땶",
+  "땷",
+  "땸",
+  "땹",
+  "땺",
+  "땻",
+  "땼",
+  "땽",
+  "땾",
+  "땿",
+  "떀",
+  "떁",
+  "떂",
+  "떃",
+  "떄",
+  "떅",
+  "떆",
+  "떇",
+  "떈",
+  "떉",
+  "떊",
+  "떋",
+  "떌",
+  "떍",
+  "떎",
+  "떏",
+  "떐",
+  "떑",
+  "떒",
+  "떓",
+  "떔",
+  "떕",
+  "떖",
+  "떗",
+  "떘",
+  "떙",
+  "떚",
+  "떛",
+  // 우 계열
+  "우",
+  "욱",
+  "욲",
+  "욳",
+  "운",
+  "울",
+  "욶",
+  "욷",
+  "움",
+  "웁",
+  "웂",
+  "웃",
+  "웄",
+  "웅",
+  "웆",
+  "웇",
+  "워",
+  "웍",
+  "웎",
+  "웏",
+  "원",
+  "월",
+  "웒",
+  "웓",
+  "월",
+  "웕",
+  "웖",
+  "웗",
+  "웘",
+  "웙",
+  "웚",
+  "웛",
+  "위",
+  "윅",
+  "윆",
+  "윇",
+  "윈",
+  "윉",
+  "윊",
+  "윋",
+  "윌",
+  "윍",
+  "윎",
+  "윏",
+  "윐",
+  "윑",
+  "윒",
+  "윓",
+  "윔",
+  "윕",
+  "윖",
+  // 따 계열
+  "따",
+  "딱",
+  "딲",
+  "딳",
+  "딴",
+  "딵",
+  "딶",
+  "딷",
+  "딸",
+  "딹",
+  "딺",
+  "딻",
+  "딼",
+  "딽",
+  "딾",
+  "딿",
+  "땀",
+  "땁",
+  "땂",
+  "땃",
+  "땄",
+  "땅",
+  "땆",
+  "땇",
+  "땈",
+  "땉",
+  "땊",
+  "땋",
+  "때",
+  "땍",
+  "땎",
+  "땏",
+  "때",
+  "땑",
+  "땒",
+  "땓",
+  "땔",
+  "땕",
+  "땖",
+  "땗",
+  "땘",
+  "땙",
+  "땚",
+  "땛",
+  "땜",
+  "땝",
+  "땞",
+  "땟",
+  "땠",
+  "땡",
+  "땢",
+  // 야 계열
+  "야",
+  "약",
+  "얂",
+  "얃",
+  "얄",
+  "얅",
+  "얆",
+  "얇",
+  "얈",
+  "얉",
+  "얊",
+  "얋",
+  "얌",
+  "얍",
+  "얎",
+  "얏",
+  "양",
+  "양",
+  "얒",
+  "얓",
+  "얔",
+  "얕",
+  "얖",
+  "얗",
+  "얘",
+  "얙",
+  "얚",
+  "얛",
+  "얜",
+  "얝",
+  "얞",
+  "얟",
+  "얠",
+  "얡",
+  "얢",
+  "얣",
+  "얤",
+  "얥",
+  "얦",
+  "얧",
+  "얨",
+  "얩",
+  "얪",
+  "얫",
+  "얬",
+  "얭",
+  "얮",
+  "얯",
+  "얰",
+  "얱",
+];
+
+const ddu64 = new Ddu64(koreanChars, "뭐");
+
+const answer = "안녕하세요";
 const encoded = ddu64.encode(answer);
 console.log(encoded);
+//뜌얞뜌윑뜌위뜌얝뜌웙뜌윑뜌얟뜌윑뜌윔뜌얞뜌웘뜌땍뜌얞뜌윖뜌윐
 const decoded = ddu64.decode(encoded);
 console.log(decoded);
-```
+//안녕하세요
+
+//Encoding Shorter
+const encodedShorter = ddu64.encode(answer, { usePowerOfTwo: true });
+console.log(encodedShorter);
+//얞윑위얝웙윑얟윑윔얞웘땍얞윖윐
+const decodedShorter = ddu64.decode(encodedShorter, { usePowerOfTwo: true });
+console.log(decodedShorter);
+//안녕하세요
+```

package/dist/cjs/index.js

@@ -15,29 +15,18 @@ class Ddu64 {
         ];
         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.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"));
     }
-    getLargestPowerOfTwo(n) {
-        let power = Math.floor(Math.log2(n));
-        return Math.pow(2, power);
-    }
     getBitLength(setLength) {
         let cached = this.bitLengthMap.get(setLength);
         if (cached === undefined) {
@@ -46,43 +35,34 @@ 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(dduSetSymbol) {
-        if (dduSetSymbol === "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) {
@@ -90,86 +70,64 @@ class Ddu64 {
         }
         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, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const bufferInput = typeof input === "string" ? Buffer.from(input, options.encoding) : input;
-        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(options.dduSetSymbol);
-        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];
-        }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
-        }
-        return resultString;
-    }
-    encode64(input, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const bufferInput = typeof input === "string" ? Buffer.from(input, options.encoding) : input;
-        const { dduSet, padChar, bitLength } = this.getSelectedSets64(options.dduSetSymbol);
+        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];
-        }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
+        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];
+            }
         }
-        return resultString;
+        return padding > 0
+            ? resultString + padChar.repeat(Math.floor(padding / 2))
+            : resultString;
     }
     decode(input, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(options.dduSetSymbol);
-        const paddingCount = (input.match(paddingRegExp) || []).length;
-        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(options.encoding);
-    }
-    decode64(input, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const { dduSet, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets64(options.dduSetSymbol);
+        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;
+        const paddingBits = paddingCount * 2;
         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(options.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,9 +26,9 @@ 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, { dduSetSymbol: "KR" });
@@ -38,7 +38,7 @@ 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,27 +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, options?: {
         dduSetSymbol?: string;
         encoding?: BufferEncoding;
-    }): string;
-    encode64(input: Buffer | string, options?: {
-        dduSetSymbol?: string;
-        encoding?: BufferEncoding;
+        usePowerOfTwo?: boolean;
     }): string;
     decode(input: string, options?: {
         dduSetSymbol?: string;
         encoding?: BufferEncoding;
-    }): string;
-    decode64(input: string, options?: {
-        dduSetSymbol?: string;
-        encoding?: BufferEncoding;
+        usePowerOfTwo?: boolean;
     }): string;
 }

package/dist/mjs/index.js

@@ -13,35 +13,19 @@ export class Ddu64 {
     ];
     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.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;
-    }
     getBitLength(setLength) {
         let cached = this.bitLengthMap.get(setLength);
         if (cached === undefined) {
@@ -50,48 +34,34 @@ 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(dduSetSymbol) {
-        if (dduSetSymbol === "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) {
@@ -99,85 +69,63 @@ export class Ddu64 {
         }
         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, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const bufferInput = typeof input === "string" ? Buffer.from(input, options.encoding) : input;
-        const { dduSet, padChar, dduLength, bitLength } = this.getSelectedSets(options.dduSetSymbol);
-        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];
-        }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
-        }
-        return resultString;
-    }
-    encode64(input, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const bufferInput = typeof input === "string" ? Buffer.from(input, options.encoding) : input;
-        const { dduSet, padChar, bitLength } = this.getSelectedSets64(options.dduSetSymbol);
+        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];
-        }
-        if (padding > 0) {
-            return resultString + padChar.repeat(Math.floor(padding / 2));
+        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];
+            }
         }
-        return resultString;
+        return padding > 0
+            ? resultString + padChar.repeat(Math.floor(padding / 2))
+            : resultString;
     }
     decode(input, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const { dduSet, dduLength, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets(options.dduSetSymbol);
-        const paddingCount = (input.match(paddingRegExp) || []).length;
-        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(options.encoding);
-    }
-    decode64(input, options = {}) {
-        options.dduSetSymbol = options.dduSetSymbol || "default";
-        options.encoding = options.encoding || this.defaultEncoding;
-        const { dduSet, bitLength, lookupTable, paddingRegExp } = this.getSelectedSets64(options.dduSetSymbol);
+        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;
+        const paddingBits = paddingCount * 2;
         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(options.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,9 +24,9 @@ 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, { dduSetSymbol: "KR" });
@@ -36,7 +36,7 @@ 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.11",
+  "version": "1.0.13",
   "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": {
     ".": {
@@ -23,5 +23,19 @@
     "@types/node": "^22.13.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3"
-  }
+  },
+  "keywords": [
+    "ddu",
+    "enigma",
+    "Decrypt",
+    "Encrypt",
+    "Base64",
+    "base conversion",
+    "base64 encord",
+    "base64 decode",
+    "base64_encode",
+    "base64_decode",
+    "encode",
+    "decode"
+  ]
 }