hangul-trie 0.1.0 → 0.1.1

package/dist/{core/index.d.ts → index.d.mts}

@@ -1,4 +1,4 @@
-export declare class Trie {
+declare class Trie {
     private root;
     size: number;
     constructor();
@@ -24,3 +24,5 @@ export declare class Trie {
      */
     autoComplete(str: string): string[];
 }
+
+export { Trie };

package/dist/index.d.ts

@@ -1 +1,28 @@
-export { Trie } from './core/index.js';
+declare class Trie {
+    private root;
+    size: number;
+    constructor();
+    private static _dfs;
+    /**
+     * Trie 자료구조에 문자열을 삽입합니다.
+     */
+    insert(str: string): void;
+    /**
+     * 해당 문자열이 Trie에 존재하는지 검색합니다.
+     */
+    has(str: string): boolean;
+    /**
+     * 해당 문자열을 Trie 자료구조에서 제거합니다.
+     */
+    remove(str: string): void;
+    /**
+     * 현재 Trie 자료구조에 삽입된 모든 문자열을 반환합니다.
+     */
+    getAll(): string[];
+    /**
+     * 현재 문자열로부터 완성될 수 있는 문자열들을 반환합니다.
+     */
+    autoComplete(str: string): string[];
+}
+
+export { Trie };

package/dist/index.js

@@ -1 +1,224 @@
-export { Trie } from './core/index.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Trie: () => Trie
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/index.ts
+var import_es_hangul = require("es-hangul");
+function commonPrefixLength(a, b) {
+  let len = 0;
+  while (len < a.length && len < b.length) {
+    if (a[len] !== b[len]) break;
+    len += 1;
+  }
+  return len;
+}
+function hasHangul(str) {
+  return [...str].some((s) => /^[가-힣ㄱ-ㅣ]$/.test(s));
+}
+function onlyHangulOrSpace(str) {
+  return [...str].every((s) => /^[가-힣ㄱ-ㅣ ]$/.test(s));
+}
+function integratedDisassemble(str) {
+  const isSomeHangul = hasHangul(str);
+  const isEveryHangul = onlyHangulOrSpace(str);
+  if (isEveryHangul) return (0, import_es_hangul.disassemble)(str);
+  if (isSomeHangul) {
+    const splitted = str.split(/([가-힣ㄱ-ㅣ]+)/);
+    return splitted.reduce((acc, cur) => {
+      if (cur.length === 0) return acc;
+      const isHangul = /^[가-힣ㄱ-ㅣ]$/.test(cur[0]);
+      if (!isHangul) return acc + cur;
+      return acc + (0, import_es_hangul.disassemble)(cur);
+    }, "");
+  }
+  return str;
+}
+function integratedAssemble(str) {
+  const isSomeHangul = hasHangul(str);
+  const isEveryHangul = onlyHangulOrSpace(str);
+  if (isEveryHangul) return (0, import_es_hangul.assemble)([str]);
+  if (isSomeHangul) {
+    const splitted = str.split(/([가-힣ㄱ-ㅣ]+)/);
+    return splitted.reduce((acc, cur) => {
+      if (cur.length === 0) return acc;
+      const isHangul = /^[가-힣ㄱ-ㅣ]$/.test(cur[0]);
+      if (!isHangul) return acc + cur;
+      return acc + (0, import_es_hangul.assemble)([...cur]);
+    }, "");
+  }
+  return str;
+}
+
+// src/core/index.ts
+var TrieNode = class {
+  prefix;
+  isEndofStr;
+  children;
+  constructor(prefix = "") {
+    this.prefix = prefix;
+    this.isEndofStr = false;
+    this.children = {};
+  }
+};
+var Trie = class _Trie {
+  root;
+  size;
+  constructor() {
+    this.root = new TrieNode();
+    this.size = 0;
+  }
+  static _dfs(curNode, prefix, collectArray) {
+    const concatenatedPrefix = prefix + curNode.prefix;
+    if (curNode.isEndofStr) {
+      collectArray.push(integratedAssemble(concatenatedPrefix));
+    }
+    for (const childNode of Object.values(curNode.children)) {
+      _Trie._dfs(childNode, concatenatedPrefix, collectArray);
+    }
+  }
+  /**
+   * Trie 자료구조에 문자열을 삽입합니다.
+   */
+  insert(str) {
+    if (this.has(str)) return;
+    str = integratedDisassemble(str);
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      const isChildExists = key in node.children;
+      if (!isChildExists) {
+        const newNode = new TrieNode(str.slice(i));
+        newNode.isEndofStr = true;
+        node.children[key] = newNode;
+        break;
+      }
+      node = node.children[key];
+      const prefixLen = commonPrefixLength(node.prefix, str.slice(i));
+      i += prefixLen;
+      if (prefixLen < node.prefix.length) {
+        const newNode = new TrieNode(node.prefix.slice(prefixLen));
+        newNode.isEndofStr = node.isEndofStr;
+        newNode.children = node.children;
+        node.prefix = node.prefix.slice(0, prefixLen);
+        node.children = { [newNode.prefix[0]]: newNode };
+        node.isEndofStr = i === str.length;
+      }
+    }
+    this.size += 1;
+  }
+  /**
+   * 해당 문자열이 Trie에 존재하는지 검색합니다.
+   */
+  has(str) {
+    str = integratedDisassemble(str);
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      if (!(key in node.children)) return false;
+      node = node.children[key];
+      const prefixLen = commonPrefixLength(str.slice(i), node.prefix);
+      if (prefixLen !== node.prefix.length) return false;
+      i += prefixLen;
+      if (i === str.length) return node.isEndofStr;
+    }
+    return false;
+  }
+  /**
+   * 해당 문자열을 Trie 자료구조에서 제거합니다.
+   */
+  remove(str) {
+    str = integratedDisassemble(str);
+    let parentNode = null;
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      if (!(key in node.children)) return;
+      parentNode = node;
+      node = node.children[key];
+      const prefixLen = commonPrefixLength(str.slice(i), node.prefix);
+      if (prefixLen !== node.prefix.length) return;
+      i += prefixLen;
+      if (i === str.length && node.isEndofStr) {
+        node.isEndofStr = false;
+        this.size -= 1;
+        const childrenKeys = Object.keys(node.children);
+        const childrenCount = childrenKeys.length;
+        if (childrenCount === 0) {
+          delete parentNode.children[node.prefix[0]];
+          const parentNodeChildrenKeys = Object.keys(parentNode.children);
+          const parentNodeChildrenCount = parentNodeChildrenKeys.length;
+          if (!parentNode.isEndofStr && parentNodeChildrenCount === 1) {
+            const childNode = parentNode.children[parentNodeChildrenKeys[0]];
+            parentNode.prefix += childNode.prefix;
+            parentNode.isEndofStr = childNode.isEndofStr;
+            parentNode.children = childNode.children;
+          }
+        } else if (childrenCount === 1) {
+          const childNode = node.children[childrenKeys[0]];
+          node.prefix += childNode.prefix;
+          node.isEndofStr = childNode.isEndofStr;
+          node.children = childNode.children;
+        }
+        return;
+      }
+    }
+  }
+  /**
+   * 현재 Trie 자료구조에 삽입된 모든 문자열을 반환합니다.
+   */
+  getAll() {
+    const result = [];
+    _Trie._dfs(this.root, "", result);
+    return result;
+  }
+  /**
+   * 현재 문자열로부터 완성될 수 있는 문자열들을 반환합니다.
+   */
+  autoComplete(str) {
+    const result = [];
+    str = integratedDisassemble(str);
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      if (!(key in node.children)) return [];
+      node = node.children[key];
+      const remainStr = str.slice(i);
+      const prefixLen = commonPrefixLength(remainStr, node.prefix);
+      if (prefixLen === remainStr.length) break;
+      else if (prefixLen === node.prefix.length) i += prefixLen;
+      else return [];
+    }
+    _Trie._dfs(node, str.slice(0, i), result);
+    return result;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Trie
+});

package/dist/index.mjs

@@ -0,0 +1,197 @@
+// src/utils/index.ts
+import { assemble, disassemble } from "es-hangul";
+function commonPrefixLength(a, b) {
+  let len = 0;
+  while (len < a.length && len < b.length) {
+    if (a[len] !== b[len]) break;
+    len += 1;
+  }
+  return len;
+}
+function hasHangul(str) {
+  return [...str].some((s) => /^[가-힣ㄱ-ㅣ]$/.test(s));
+}
+function onlyHangulOrSpace(str) {
+  return [...str].every((s) => /^[가-힣ㄱ-ㅣ ]$/.test(s));
+}
+function integratedDisassemble(str) {
+  const isSomeHangul = hasHangul(str);
+  const isEveryHangul = onlyHangulOrSpace(str);
+  if (isEveryHangul) return disassemble(str);
+  if (isSomeHangul) {
+    const splitted = str.split(/([가-힣ㄱ-ㅣ]+)/);
+    return splitted.reduce((acc, cur) => {
+      if (cur.length === 0) return acc;
+      const isHangul = /^[가-힣ㄱ-ㅣ]$/.test(cur[0]);
+      if (!isHangul) return acc + cur;
+      return acc + disassemble(cur);
+    }, "");
+  }
+  return str;
+}
+function integratedAssemble(str) {
+  const isSomeHangul = hasHangul(str);
+  const isEveryHangul = onlyHangulOrSpace(str);
+  if (isEveryHangul) return assemble([str]);
+  if (isSomeHangul) {
+    const splitted = str.split(/([가-힣ㄱ-ㅣ]+)/);
+    return splitted.reduce((acc, cur) => {
+      if (cur.length === 0) return acc;
+      const isHangul = /^[가-힣ㄱ-ㅣ]$/.test(cur[0]);
+      if (!isHangul) return acc + cur;
+      return acc + assemble([...cur]);
+    }, "");
+  }
+  return str;
+}
+
+// src/core/index.ts
+var TrieNode = class {
+  prefix;
+  isEndofStr;
+  children;
+  constructor(prefix = "") {
+    this.prefix = prefix;
+    this.isEndofStr = false;
+    this.children = {};
+  }
+};
+var Trie = class _Trie {
+  root;
+  size;
+  constructor() {
+    this.root = new TrieNode();
+    this.size = 0;
+  }
+  static _dfs(curNode, prefix, collectArray) {
+    const concatenatedPrefix = prefix + curNode.prefix;
+    if (curNode.isEndofStr) {
+      collectArray.push(integratedAssemble(concatenatedPrefix));
+    }
+    for (const childNode of Object.values(curNode.children)) {
+      _Trie._dfs(childNode, concatenatedPrefix, collectArray);
+    }
+  }
+  /**
+   * Trie 자료구조에 문자열을 삽입합니다.
+   */
+  insert(str) {
+    if (this.has(str)) return;
+    str = integratedDisassemble(str);
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      const isChildExists = key in node.children;
+      if (!isChildExists) {
+        const newNode = new TrieNode(str.slice(i));
+        newNode.isEndofStr = true;
+        node.children[key] = newNode;
+        break;
+      }
+      node = node.children[key];
+      const prefixLen = commonPrefixLength(node.prefix, str.slice(i));
+      i += prefixLen;
+      if (prefixLen < node.prefix.length) {
+        const newNode = new TrieNode(node.prefix.slice(prefixLen));
+        newNode.isEndofStr = node.isEndofStr;
+        newNode.children = node.children;
+        node.prefix = node.prefix.slice(0, prefixLen);
+        node.children = { [newNode.prefix[0]]: newNode };
+        node.isEndofStr = i === str.length;
+      }
+    }
+    this.size += 1;
+  }
+  /**
+   * 해당 문자열이 Trie에 존재하는지 검색합니다.
+   */
+  has(str) {
+    str = integratedDisassemble(str);
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      if (!(key in node.children)) return false;
+      node = node.children[key];
+      const prefixLen = commonPrefixLength(str.slice(i), node.prefix);
+      if (prefixLen !== node.prefix.length) return false;
+      i += prefixLen;
+      if (i === str.length) return node.isEndofStr;
+    }
+    return false;
+  }
+  /**
+   * 해당 문자열을 Trie 자료구조에서 제거합니다.
+   */
+  remove(str) {
+    str = integratedDisassemble(str);
+    let parentNode = null;
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      if (!(key in node.children)) return;
+      parentNode = node;
+      node = node.children[key];
+      const prefixLen = commonPrefixLength(str.slice(i), node.prefix);
+      if (prefixLen !== node.prefix.length) return;
+      i += prefixLen;
+      if (i === str.length && node.isEndofStr) {
+        node.isEndofStr = false;
+        this.size -= 1;
+        const childrenKeys = Object.keys(node.children);
+        const childrenCount = childrenKeys.length;
+        if (childrenCount === 0) {
+          delete parentNode.children[node.prefix[0]];
+          const parentNodeChildrenKeys = Object.keys(parentNode.children);
+          const parentNodeChildrenCount = parentNodeChildrenKeys.length;
+          if (!parentNode.isEndofStr && parentNodeChildrenCount === 1) {
+            const childNode = parentNode.children[parentNodeChildrenKeys[0]];
+            parentNode.prefix += childNode.prefix;
+            parentNode.isEndofStr = childNode.isEndofStr;
+            parentNode.children = childNode.children;
+          }
+        } else if (childrenCount === 1) {
+          const childNode = node.children[childrenKeys[0]];
+          node.prefix += childNode.prefix;
+          node.isEndofStr = childNode.isEndofStr;
+          node.children = childNode.children;
+        }
+        return;
+      }
+    }
+  }
+  /**
+   * 현재 Trie 자료구조에 삽입된 모든 문자열을 반환합니다.
+   */
+  getAll() {
+    const result = [];
+    _Trie._dfs(this.root, "", result);
+    return result;
+  }
+  /**
+   * 현재 문자열로부터 완성될 수 있는 문자열들을 반환합니다.
+   */
+  autoComplete(str) {
+    const result = [];
+    str = integratedDisassemble(str);
+    let node = this.root;
+    let i = 0;
+    while (i < str.length) {
+      const key = str[i];
+      if (!(key in node.children)) return [];
+      node = node.children[key];
+      const remainStr = str.slice(i);
+      const prefixLen = commonPrefixLength(remainStr, node.prefix);
+      if (prefixLen === remainStr.length) break;
+      else if (prefixLen === node.prefix.length) i += prefixLen;
+      else return [];
+    }
+    _Trie._dfs(node, str.slice(0, i), result);
+    return result;
+  }
+};
+export {
+  Trie
+};

package/package.json

@@ -1,18 +1,35 @@
 {
   "name": "hangul-trie",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "한글을 지원하는 Compressed Trie 자료구조",
   "license": "MIT",
   "author": "Donghyeon Lee <ehdgus001928@gmail.com>",
-  "type": "module",
+  "type": "commonjs",
   "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
   "scripts": {
-    "build": "tsc --build --clean && tsc",
+    "build": "tsup",
     "test": "vitest"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "devDependencies": {
     "@types/node": "^25.1.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },

package/dist/core/index.js

@@ -1,180 +0,0 @@
-import { commonPrefixLength, integratedAssemble, integratedDisassemble } from "@/utils/index.js";
-class TrieNode {
-    prefix;
-    isEndofStr;
-    children;
-    constructor(prefix = '') {
-        this.prefix = prefix;
-        this.isEndofStr = false;
-        this.children = {};
-    }
-}
-export class Trie {
-    root;
-    size;
-    constructor() {
-        this.root = new TrieNode();
-        this.size = 0;
-    }
-    static _dfs(curNode, prefix, collectArray) {
-        const concatenatedPrefix = prefix + curNode.prefix;
-        if (curNode.isEndofStr) {
-            collectArray.push(integratedAssemble(concatenatedPrefix));
-        }
-        for (const childNode of Object.values(curNode.children)) {
-            Trie._dfs(childNode, concatenatedPrefix, collectArray);
-        }
-    }
-    /**
-     * Trie 자료구조에 문자열을 삽입합니다.
-     */
-    insert(str) {
-        // 한글 분해
-        str = integratedDisassemble(str);
-        let node = this.root;
-        let i = 0;
-        while (i < str.length) {
-            const key = str[i];
-            const isChildExists = key in node.children;
-            // 현재 글자를 key로 가지는 자식 노드가 없다면 새로 생성
-            if (!isChildExists) {
-                const newNode = new TrieNode(str.slice(i));
-                newNode.isEndofStr = true;
-                node.children[key] = newNode;
-                break;
-            }
-            // 현재 글자를 key로 가지는 자식 노드로 이동
-            node = node.children[key];
-            // 공통 prefix 길이 계산
-            const prefixLen = commonPrefixLength(node.prefix, str.slice(i));
-            i += prefixLen;
-            // 공통 prefixLen이 현재 노드의 prefix보다 작은 경우
-            // 현재 노드의 prefix를 prefixLen 기준으로 노드 두 개로 쪼개기
-            if (prefixLen < node.prefix.length) {
-                const newNode = new TrieNode(node.prefix.slice(prefixLen));
-                newNode.isEndofStr = node.isEndofStr;
-                newNode.children = node.children;
-                node.prefix = node.prefix.slice(0, prefixLen);
-                node.children = { [newNode.prefix[0]]: newNode };
-                // 공통 prefix가 삽입한 문자열의 끝부분인경우 현재 노드가 end 노드가 됨
-                node.isEndofStr = i === str.length;
-            }
-        }
-        this.size += 1;
-    }
-    /**
-     * 해당 문자열이 Trie에 존재하는지 검색합니다.
-     */
-    has(str) {
-        // 한글 분해
-        str = integratedDisassemble(str);
-        let node = this.root;
-        let i = 0;
-        while (i < str.length) {
-            const key = str[i];
-            // 현재 글자와 일치하는 경로가 없다면 검색 실패
-            if (!(key in node.children))
-                return false;
-            node = node.children[key];
-            const prefixLen = commonPrefixLength(str.slice(i), node.prefix);
-            // 공통 prefix 길이가 현재 node prefix 길이와 일치하지 않다면
-            // 검색하려는 문자열보다 현재 노드의 prefix가 더 긴 경우이므로 검색 실패
-            if (prefixLen !== node.prefix.length)
-                return false;
-            i += prefixLen;
-            // 공통 prefix가 검색하려는 문자열의 끝부분이라면
-            // 현재 노드가 EndofStr인지 여부에 따라 검색 성공 실패 여부 결정
-            if (i === str.length)
-                return node.isEndofStr;
-        }
-        return false;
-    }
-    /**
-     * 해당 문자열을 Trie 자료구조에서 제거합니다.
-     */
-    remove(str) {
-        // 한글 분해
-        str = integratedDisassemble(str);
-        let parentNode = null;
-        let node = this.root;
-        let i = 0;
-        while (i < str.length) {
-            const key = str[i];
-            if (!(key in node.children))
-                return;
-            parentNode = node;
-            node = node.children[key];
-            const prefixLen = commonPrefixLength(str.slice(i), node.prefix);
-            if (prefixLen !== node.prefix.length)
-                return;
-            i += prefixLen;
-            // 제거하려는 문자열과 일치하는 노드 검색 성공 시
-            if (i === str.length && node.isEndofStr) {
-                // 더 이상 EndofStr이 아니게 수정(문자열 제거)
-                node.isEndofStr = false;
-                this.size -= 1;
-                const childrenKeys = Object.keys(node.children);
-                const childrenCount = childrenKeys.length;
-                // leaf 노드인 경우 해당 노드로 가는 key 제거
-                if (childrenCount === 0) {
-                    delete parentNode.children[node.prefix[0]];
-                    const parentNodeChildrenKeys = Object.keys(parentNode.children);
-                    const parentNodeChildrenCount = parentNodeChildrenKeys.length;
-                    // 부모 노드가 EndofStr이 아니고 제거 후 부모 노드의 자식 노드가 하나뿐이라면 병합
-                    if (!parentNode.isEndofStr && parentNodeChildrenCount === 1) {
-                        const childNode = parentNode.children[parentNodeChildrenKeys[0]];
-                        parentNode.prefix += childNode.prefix;
-                        parentNode.isEndofStr = childNode.isEndofStr;
-                        parentNode.children = childNode.children;
-                    }
-                }
-                // 자식 노드가 1개인 중간 노드인 경우 자식 노드와 병합
-                else if (childrenCount === 1) {
-                    const childNode = node.children[childrenKeys[0]];
-                    node.prefix += childNode.prefix;
-                    node.isEndofStr = childNode.isEndofStr;
-                    node.children = childNode.children;
-                }
-                // 그 이외는 별도의 추가 작업 필요 없이 작업 종료
-                return;
-            }
-        }
-    }
-    /**
-     * 현재 Trie 자료구조에 삽입된 모든 문자열을 반환합니다.
-     */
-    getAll() {
-        const result = [];
-        Trie._dfs(this.root, '', result);
-        return result;
-    }
-    /**
-     * 현재 문자열로부터 완성될 수 있는 문자열들을 반환합니다.
-     */
-    autoComplete(str) {
-        const result = [];
-        str = integratedDisassemble(str);
-        let node = this.root;
-        let i = 0;
-        // 현재 문자열이 포함된 prefix를 가진 노드를 찾습니다.
-        while (i < str.length) {
-            const key = str[i];
-            if (!(key in node.children))
-                return [];
-            node = node.children[key];
-            const remainStr = str.slice(i);
-            const prefixLen = commonPrefixLength(remainStr, node.prefix);
-            // 현재 노드의 prefix가 공통 prefix인 경우
-            if (prefixLen === remainStr.length)
-                break;
-            // 현재 문자열의 prefix가 공통 prefix인 경우
-            else if (prefixLen === node.prefix.length)
-                i += prefixLen;
-            // 공통 prefix가 현재 노드의 prefix, 현재 문자열의 prefix 중 어느와도 일치하지 않는 경우
-            else
-                return [];
-        }
-        Trie._dfs(node, str.slice(0, i), result);
-        return result;
-    }
-}

package/dist/test/index.test.d.ts

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

package/dist/test/index.test.js

@@ -1,130 +0,0 @@
-import { Trie } from "@/core/index.js";
-import { commonPrefixLength, integratedAssemble, integratedDisassemble } from "@/utils/index.js";
-import { describe, expect, test } from "vitest";
-describe('Util functions test', () => {
-    test('commonPrefixLength', () => {
-        expect(commonPrefixLength('ㄱㄴ', 'ㄱ')).toBe(1);
-        expect(commonPrefixLength('ㄱㄴ', 'ㄱ')).toBe(commonPrefixLength('ㄱ', 'ㄱㄴ'));
-        expect(commonPrefixLength('ㄴㅏ ㅂㅣ', 'ㄴㅏ ㅂㅏㅇ')).toBe(4);
-    });
-    test('integratedDisassemble', () => {
-        expect(integratedDisassemble('ㄱㄴㄷ')).toBe('ㄱㄴㄷ');
-        expect(integratedDisassemble('가방과 나방')).toBe('ㄱㅏㅂㅏㅇㄱㅗㅏ ㄴㅏㅂㅏㅇ');
-        expect(integratedDisassemble('abc')).toBe('abc');
-        expect(integratedDisassemble('나비는 butterfly야')).toBe('ㄴㅏㅂㅣㄴㅡㄴ butterflyㅇㅑ');
-    });
-    test('integratedAssemble', () => {
-        expect(integratedAssemble('ㄱㅏㅁ')).toBe('감');
-        expect(integratedAssemble('ㄱㅏㅁㅏ')).toBe('가마');
-        expect(integratedAssemble('abc')).toBe('abc');
-        expect(integratedAssemble('ㄱㅏa ㅁㅜㄹ b치')).toBe('가a 물 b치');
-    });
-});
-describe('Trie test', () => {
-    test('Insert test', () => {
-        const trie = new Trie();
-        const input = [
-            'abc',
-            'ㄱㄴㄷ',
-            '개굴개굴 개구리',
-            '바나나는 banana야',
-        ];
-        input.forEach((value) => trie.insert(value));
-        expect(trie.has('abc')).toBe(true);
-        expect(trie.has('ㄱㄴㄷ')).toBe(true);
-        expect(trie.has('개굴개굴 개구리')).toBe(true);
-        expect(trie.has('바나나는 banana야')).toBe(true);
-        expect(trie.has('abd')).toBe(false);
-        expect(trie.has('ㄱㄴㄹ')).toBe(false);
-        expect(trie.has('개굴개굴개구리')).toBe(false);
-        expect(trie.size).toBe(4);
-    });
-    test('Remove test', () => {
-        const trie = new Trie();
-        const input = [
-            'ㄱㄴㄷ',
-            'ㄱㄴㄷㄹ',
-            '가나다',
-            '가나라',
-            '나방',
-            '나비',
-            '나비야',
-        ];
-        input.forEach((value) => trie.insert(value));
-        // leaf 노드 제거하는 경우
-        trie.remove('ㄱㄴㄷㄹ');
-        // leaf 노드 제거 후 부모 노드의 자식 노드가 1개인 경우
-        trie.remove('가나다');
-        // 자식 노드가 1개인 중간 노드인 경우
-        trie.remove('나비');
-        expect(trie.has('ㄱㄴㄷㄹ')).toBe(false);
-        expect(trie.has('가나다')).toBe(false);
-        expect(trie.has('나비')).toBe(false);
-        expect(trie.has('ㄱㄴㄷ')).toBe(true);
-        expect(trie.has('가나라')).toBe(true);
-        expect(trie.has('나방')).toBe(true);
-        expect(trie.has('나비야')).toBe(true);
-        expect(trie.size).toBe(4);
-    });
-    test('GetAll test', () => {
-        const trie = new Trie();
-        const input = [
-            'abc',
-            'ㄱㄴㄷ',
-            '개굴개굴 개구리',
-            '나비는 butterfly야',
-            'ㄱㄴㄷㄹ',
-            '가나다',
-            '가나라',
-            '나방',
-            '나비',
-            '나비야'
-        ];
-        input.forEach((value) => trie.insert(value));
-        expect(trie.getAll().sort()).toStrictEqual(input.sort());
-        expect(trie.size).toBe(input.length);
-    });
-    test('AutoComplete test', () => {
-        const trie = new Trie();
-        const input = [
-            'apple',
-            'apply',
-            'application',
-            'approach',
-            '납부',
-            '나비',
-            '나방',
-            '나쁜',
-        ];
-        input.forEach((value) => trie.insert(value));
-        expect(trie.autoComplete('appll')).toStrictEqual([]);
-        expect(trie.autoComplete('app').sort()).toStrictEqual([
-            'apple',
-            'apply',
-            'application',
-            'approach',
-        ].sort());
-        expect(trie.autoComplete('appl').sort()).toStrictEqual([
-            'apple',
-            'apply',
-            'application',
-        ].sort());
-        expect(trie.autoComplete('난').sort()).toStrictEqual([]);
-        expect(trie.autoComplete('나').sort()).toStrictEqual([
-            '납부',
-            '나비',
-            '나방',
-            '나쁜',
-        ].sort());
-        expect(trie.autoComplete('납').sort()).toStrictEqual([
-            '납부',
-            '나비',
-            '나방',
-        ].sort());
-        expect(trie.autoComplete('나ㅂ').sort()).toStrictEqual([
-            '납부',
-            '나비',
-            '나방',
-        ].sort());
-    });
-});

package/dist/utils/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * disassemble 된 두 한글 문자열의 공통 prefix 길이를 반환합니다.
- */
-export declare function commonPrefixLength(a: string, b: string): number;
-/**
- * 한글을 초성/중성/종성 단위로 완전히 분해합니다.
- * 한글이 아닌 문자가 포함되어 있는 경우에도 분해합니다.
- */
-export declare function integratedDisassemble(str: string): string;
-/**
- * 문자열에 포함된 한글 문장과 문자를 한글 규칙에 맞게 합성합니다.
- */
-export declare function integratedAssemble(str: string): string;

package/dist/utils/index.js

@@ -1,68 +0,0 @@
-import { assemble, disassemble } from "es-hangul";
-/**
- * disassemble 된 두 한글 문자열의 공통 prefix 길이를 반환합니다.
- */
-export function commonPrefixLength(a, b) {
-    let len = 0;
-    while (len < a.length && len < b.length) {
-        if (a[len] !== b[len])
-            break;
-        len += 1;
-    }
-    return len;
-}
-function hasHangul(str) {
-    return [...str].some((s) => /^[가-힣ㄱ-ㅣ]$/.test(s));
-}
-function onlyHangulOrSpace(str) {
-    return [...str].every((s) => /^[가-힣ㄱ-ㅣ ]$/.test(s));
-}
-/**
- * 한글을 초성/중성/종성 단위로 완전히 분해합니다.
- * 한글이 아닌 문자가 포함되어 있는 경우에도 분해합니다.
- */
-export function integratedDisassemble(str) {
-    const isSomeHangul = hasHangul(str);
-    const isEveryHangul = onlyHangulOrSpace(str);
-    // 전부 한글
-    if (isEveryHangul)
-        return disassemble(str);
-    // 일부만 한글
-    if (isSomeHangul) {
-        const splitted = str.split(/([가-힣ㄱ-ㅣ]+)/);
-        return splitted.reduce((acc, cur) => {
-            if (cur.length === 0)
-                return acc;
-            const isHangul = /^[가-힣ㄱ-ㅣ]$/.test(cur[0]);
-            if (!isHangul)
-                return acc + cur;
-            return acc + disassemble(cur);
-        }, '');
-    }
-    // 한글 미포함
-    return str;
-}
-/**
- * 문자열에 포함된 한글 문장과 문자를 한글 규칙에 맞게 합성합니다.
- */
-export function integratedAssemble(str) {
-    const isSomeHangul = hasHangul(str);
-    const isEveryHangul = onlyHangulOrSpace(str);
-    // 전부 한글
-    if (isEveryHangul)
-        return assemble([str]);
-    // 일부만 한글
-    if (isSomeHangul) {
-        const splitted = str.split(/([가-힣ㄱ-ㅣ]+)/);
-        return splitted.reduce((acc, cur) => {
-            if (cur.length === 0)
-                return acc;
-            const isHangul = /^[가-힣ㄱ-ㅣ]$/.test(cur[0]);
-            if (!isHangul)
-                return acc + cur;
-            return acc + assemble([...cur]);
-        }, '');
-    }
-    // 한글 미포함
-    return str;
-}