mecab-ko-wasm 0.3.0

package/README.md

@@ -0,0 +1,315 @@
+# mecab-ko-wasm
+
+WebAssembly bindings for MeCab-Ko, a Korean morphological analyzer.
+
+This package enables Korean morphological analysis in web browsers and Node.js environments through WebAssembly.
+
+## Features
+
+- **Fast**: Compiled to WebAssembly for near-native performance
+- **Lightweight**: No external dependencies required in the browser
+- **Cross-platform**: Works in both browser and Node.js environments
+- **Type-safe**: Full TypeScript type definitions included
+
+## Installation
+
+### Using npm
+
+```bash
+npm install mecab-ko-wasm
+```
+
+### Using yarn
+
+```bash
+yarn add mecab-ko-wasm
+```
+
+## Usage
+
+### Browser (ES Modules)
+
+```javascript
+import init, { Mecab } from 'mecab-ko-wasm';
+
+async function analyze() {
+  // Initialize the WASM module
+  await init();
+
+  // Create a Mecab instance
+  const mecab = new Mecab();
+
+  // Extract morphemes
+  const morphs = mecab.morphs("안녕하세요");
+  console.log(morphs); // ["안녕", "하", "세요"]
+
+  // Get part-of-speech tags
+  const posJson = mecab.pos("형태소 분석");
+  const pos = JSON.parse(posJson);
+  console.log(pos); // [["형태소", "NNG"], ["분석", "NNG"]]
+
+  // Get detailed token information
+  const tokens = mecab.tokenize("한국어 분석기");
+  tokens.forEach(token => {
+    console.log(`${token.surface}: ${token.pos}`);
+  });
+}
+
+analyze();
+```
+
+### Node.js
+
+```javascript
+const { Mecab } = require('mecab-ko-wasm');
+
+const mecab = new Mecab();
+
+// Extract morphemes
+const morphs = mecab.morphs("안녕하세요");
+console.log(morphs); // ["안녕", "하", "세요"]
+
+// Extract nouns
+const nouns = mecab.nouns("형태소 분석기입니다");
+console.log(nouns); // ["형태소", "분석기"]
+
+// Wakati tokenization
+const words = mecab.wakati("한국어 처리");
+console.log(words); // ["한국어", "처리"]
+```
+
+### TypeScript
+
+```typescript
+import init, { Mecab, WasmToken } from 'mecab-ko-wasm';
+
+async function analyze(text: string): Promise<void> {
+  await init();
+
+  const mecab = new Mecab();
+
+  // Tokenize with full information
+  const tokens: WasmToken[] = mecab.tokenize(text);
+  tokens.forEach((token: WasmToken) => {
+    console.log({
+      surface: token.surface,
+      pos: token.pos,
+      start: token.start,
+      end: token.end,
+    });
+  });
+
+  // Extract morphemes
+  const morphs: string[] = mecab.morphs(text);
+  console.log('Morphemes:', morphs);
+}
+
+analyze("한국어 형태소 분석");
+```
+
+## API Reference
+
+### `Mecab`
+
+The main class for Korean morphological analysis.
+
+#### Constructor
+
+```typescript
+new Mecab(): Mecab
+```
+
+Creates a new Mecab instance with the default dictionary.
+
+**Throws**: Error if initialization fails
+
+#### Methods
+
+##### `tokenize(text: string): WasmToken[]`
+
+Tokenizes the input text and returns detailed token information.
+
+**Parameters:**
+- `text`: Input text to analyze
+
+**Returns**: Array of `WasmToken` objects containing surface form, POS tag, and position information
+
+**Example:**
+```javascript
+const tokens = mecab.tokenize("안녕하세요");
+// [
+//   { surface: "안녕", pos: "NNG", start: 0, end: 6, ... },
+//   { surface: "하", pos: "XSV", start: 6, end: 9, ... },
+//   ...
+// ]
+```
+
+##### `morphs(text: string): string[]`
+
+Extracts morphemes from the input text.
+
+**Parameters:**
+- `text`: Input text to analyze
+
+**Returns**: Array of morpheme strings
+
+**Example:**
+```javascript
+const morphs = mecab.morphs("안녕하세요");
+// ["안녕", "하", "세요"]
+```
+
+##### `pos(text: string): string`
+
+Extracts part-of-speech tagged pairs as a JSON string.
+
+**Parameters:**
+- `text`: Input text to analyze
+
+**Returns**: JSON string containing an array of `[surface, pos]` pairs
+
+**Example:**
+```javascript
+const posJson = mecab.pos("안녕하세요");
+const pos = JSON.parse(posJson);
+// [["안녕", "NNG"], ["하", "XSV"], ["세요", "EP+EF"]]
+```
+
+##### `nouns(text: string): string[]`
+
+Extracts only nouns from the input text.
+
+**Parameters:**
+- `text`: Input text to analyze
+
+**Returns**: Array of noun strings
+
+**Example:**
+```javascript
+const nouns = mecab.nouns("형태소 분석기입니다");
+// ["형태소", "분석기"]
+```
+
+##### `wakati(text: string): string[]`
+
+Performs wakati (space-separated) tokenization.
+
+**Parameters:**
+- `text`: Input text to analyze
+
+**Returns**: Array of morpheme strings
+
+**Example:**
+```javascript
+const words = mecab.wakati("형태소 분석");
+// ["형태소", "분석"]
+```
+
+### `WasmToken`
+
+Represents a single token with detailed morphological information.
+
+#### Properties
+
+- `surface: string` - The surface form (표면형) of the token
+- `pos: string` - Part-of-speech tag (품사 태그)
+- `start: number` - Start position in bytes
+- `end: number` - End position in bytes
+- `reading: string | undefined` - Reading of the token (if available)
+- `lemma: string | undefined` - Base form/lemma (if available)
+
+#### Methods
+
+##### `toJSON(): string`
+
+Converts the token to a JSON string.
+
+**Returns**: JSON string representation of the token
+
+## Building from Source
+
+### Prerequisites
+
+- Rust (1.75+)
+- wasm-pack
+
+```bash
+cargo install wasm-pack
+```
+
+### Build
+
+```bash
+# Build for browser
+wasm-pack build --target web
+
+# Build for Node.js
+wasm-pack build --target nodejs
+
+# Build for bundlers (webpack, etc.)
+wasm-pack build --target bundler
+```
+
+### Development
+
+```bash
+# Run tests
+wasm-pack test --node
+
+# Run tests in browser (requires Chrome/Firefox)
+wasm-pack test --headless --firefox
+```
+
+## Part-of-Speech Tags
+
+MeCab-Ko uses the Sejong corpus POS tag set. Common tags include:
+
+- `NNG`: General noun (일반 명사)
+- `NNP`: Proper noun (고유 명사)
+- `VV`: Verb (동사)
+- `VA`: Adjective (형용사)
+- `MAG`: General adverb (일반 부사)
+- `JKS`: Subjective case particle (주격 조사)
+- `JKO`: Objective case particle (목적격 조사)
+- `EP`: Pre-final ending (선어말 어미)
+- `EF`: Final ending (어말 어미)
+
+For a complete list, see [Sejong POS Tags](https://docs.google.com/spreadsheets/d/1-9blXKjtjeKZqsf4NzHeYJCrr49-nXeRF6D80udfcwY).
+
+## Performance
+
+MeCab-Ko WASM provides near-native performance through WebAssembly compilation:
+
+- **Tokenization**: ~1-2ms for typical sentences (10-20 words)
+- **Memory**: ~2-5MB WASM module size (with dictionary)
+- **Initialization**: ~10-50ms first load (cached afterwards)
+
+## Browser Compatibility
+
+- Chrome/Edge 57+
+- Firefox 52+
+- Safari 11+
+- Node.js 12+
+
+## License
+
+Licensed under either of:
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](../../CONTRIBUTING.md) for guidelines.
+
+## Related Projects
+
+- [mecab-ko](https://bitbucket.org/eunjeon/mecab-ko) - Original C++ implementation
+- [mecab-ko-dic](https://bitbucket.org/eunjeon/mecab-ko-dic) - Korean dictionary for MeCab
+- [konlpy](https://konlpy.org/) - Python Korean NLP library
+
+## Acknowledgments
+
+This project is based on MeCab-Ko, originally developed by the Eunjeon project.

package/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * MeCab-Ko WebAssembly TypeScript Definitions
+ * Korean morphological analyzer for browser and Node.js
+ */
+
+/**
+ * A token representing a morpheme in Korean text
+ */
+export interface Token {
+  /** The surface form (original text) */
+  readonly surface: string;
+  /** Part-of-speech tag */
+  readonly pos: string;
+  /** Start byte offset in the input text */
+  readonly start: number;
+  /** End byte offset in the input text */
+  readonly end: number;
+  /** Reading form (if available) */
+  readonly reading?: string;
+  /** Lemma/dictionary form (if available) */
+  readonly lemma?: string;
+  /** Convert token to JSON string */
+  toJSON(): string;
+}
+
+/**
+ * MeCab-Ko tokenizer class
+ *
+ * @example
+ * ```typescript
+ * import init, { Mecab } from 'mecab-ko-wasm';
+ *
+ * await init();
+ * const mecab = new Mecab();
+ *
+ * const tokens = mecab.tokenize('안녕하세요');
+ * console.log(tokens);
+ *
+ * const morphs = mecab.morphs('형태소 분석');
+ * console.log(morphs); // ['형태소', '분석']
+ *
+ * const nouns = mecab.nouns('한국어 형태소 분석기');
+ * console.log(nouns); // ['한국어', '형태소', '분석기']
+ * ```
+ */
+export class Mecab {
+  /** Create a new MeCab tokenizer instance */
+  constructor();
+
+  /**
+   * Tokenize Korean text into morphemes
+   * @param text - Input Korean text
+   * @returns Array of Token objects
+   */
+  tokenize(text: string): Token[];
+
+  /**
+   * Extract morpheme surface forms
+   * @param text - Input Korean text
+   * @returns Array of surface form strings
+   */
+  morphs(text: string): string[];
+
+  /**
+   * Extract part-of-speech tagged pairs
+   * @param text - Input Korean text
+   * @returns Array of [surface, pos] tuples
+   */
+  pos(text: string): [string, string][];
+
+  /**
+   * Extract only nouns from text
+   * @param text - Input Korean text
+   * @returns Array of noun strings
+   */
+  nouns(text: string): string[];
+
+  /**
+   * Split text into space-separated morphemes (wakati mode)
+   * @param text - Input Korean text
+   * @returns Array of morpheme strings
+   */
+  wakati(text: string): string[];
+}
+
+/**
+ * Initialize the WebAssembly module
+ * Must be called before creating Mecab instances
+ */
+export default function init(): Promise<void>;

package/index.js

@@ -0,0 +1,19 @@
+import init, * as wasm from './mecab_ko_wasm.js';
+
+let initialized = false;
+
+export async function initialize() {
+  if (!initialized) {
+    await init();
+    initialized = true;
+  }
+}
+
+export const tokenize = wasm.tokenize;
+export const morphs = wasm.morphs;
+export const nouns = wasm.nouns;
+export const pos = wasm.pos;
+export const wakati = wasm.wakati;
+export const getVersion = wasm.getVersion;
+
+export default { initialize, tokenize, morphs, nouns, pos, wakati, getVersion };

package/mecab_ko_wasm.d.ts

@@ -0,0 +1,148 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The main MeCab-Ko tokenizer for WebAssembly
+ *
+ * This class provides Korean morphological analysis capabilities
+ * in JavaScript/TypeScript environments.
+ */
+export class Mecab {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Extract morphemes (형태소) from text
+     *
+     * Returns an array of morpheme strings without POS information.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const morphs = mecab.morphs("안녕하세요");
+     * console.log(morphs); // ["안녕", "하", "세요"]
+     * ```
+     */
+    morphs(text: string): string[];
+    /**
+     * Create a new Mecab instance with the default dictionary
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const mecab = new Mecab();
+     * ```
+     *
+     * # Errors
+     *
+     * Returns an error if tokenizer initialization fails
+     */
+    constructor();
+    /**
+     * Extract nouns (명사) from text
+     *
+     * Returns an array of noun strings.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const nouns = mecab.nouns("형태소 분석기입니다");
+     * console.log(nouns); // ["형태소", "분석기"]
+     * ```
+     */
+    nouns(text: string): string[];
+    /**
+     * Extract part-of-speech tagged pairs
+     *
+     * Returns a JSON string containing an array of [surface, pos] pairs.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const posJson = mecab.pos("안녕하세요");
+     * const pos = JSON.parse(posJson);
+     * console.log(pos); // [["안녕", "NNG"], ["하", "XSV"], ["세요", "EP+EF"]]
+     * ```
+     *
+     * # Errors
+     *
+     * Returns an error if JSON serialization fails
+     */
+    pos(text: string): string;
+    /**
+     * Tokenize text and return detailed token information
+     *
+     * Returns an array of tokens with surface form, POS tag, and position information.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const tokens = mecab.tokenize("안녕하세요");
+     * tokens.forEach(token => {
+     *   console.log(`${token.surface}: ${token.pos}`);
+     * });
+     * ```
+     */
+    tokenize(text: string): WasmToken[];
+    /**
+     * Perform wakati (분리) tokenization
+     *
+     * Returns an array of morpheme strings, similar to `morphs()`.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const words = mecab.wakati("형태소 분석");
+     * console.log(words); // ["형태소", "분석"]
+     * ```
+     */
+    wakati(text: string): string[];
+}
+
+/**
+ * A JavaScript-friendly token representation
+ */
+export class WasmToken {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Convert to JSON string for easier JavaScript interop
+     *
+     * # Errors
+     *
+     * Returns an error if serialization fails
+     */
+    toJSON(): string;
+    /**
+     * Get the end position in bytes
+     */
+    readonly end: number;
+    /**
+     * Get the lemma/base form (if available)
+     */
+    readonly lemma: string | undefined;
+    /**
+     * Get the part-of-speech tag (품사)
+     */
+    readonly pos: string;
+    /**
+     * Get the reading (if available)
+     */
+    readonly reading: string | undefined;
+    /**
+     * Get the start position in bytes
+     */
+    readonly start: number;
+    /**
+     * Get the surface form (표면형)
+     */
+    readonly surface: string;
+}
+
+/**
+ * Initialize the WASM module
+ *
+ * This function should be called once before using the library.
+ * It sets up panic hooks for better error messages in development.
+ */
+export function init(): void;

package/mecab_ko_wasm.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./mecab_ko_wasm.d.ts" */
+
+import * as wasm from "./mecab_ko_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./mecab_ko_wasm_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();
+export {
+    Mecab, WasmToken, init
+} from "./mecab_ko_wasm_bg.js";

package/mecab_ko_wasm_bg.js

@@ -0,0 +1,548 @@
+/**
+ * The main MeCab-Ko tokenizer for WebAssembly
+ *
+ * This class provides Korean morphological analysis capabilities
+ * in JavaScript/TypeScript environments.
+ */
+export class Mecab {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MecabFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_mecab_free(ptr, 0);
+    }
+    /**
+     * Extract morphemes (형태소) from text
+     *
+     * Returns an array of morpheme strings without POS information.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const morphs = mecab.morphs("안녕하세요");
+     * console.log(morphs); // ["안녕", "하", "세요"]
+     * ```
+     * @param {string} text
+     * @returns {string[]}
+     */
+    morphs(text) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.mecab_morphs(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Create a new Mecab instance with the default dictionary
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const mecab = new Mecab();
+     * ```
+     *
+     * # Errors
+     *
+     * Returns an error if tokenizer initialization fails
+     */
+    constructor() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.mecab_new(retptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            MecabFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Extract nouns (명사) from text
+     *
+     * Returns an array of noun strings.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const nouns = mecab.nouns("형태소 분석기입니다");
+     * console.log(nouns); // ["형태소", "분석기"]
+     * ```
+     * @param {string} text
+     * @returns {string[]}
+     */
+    nouns(text) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.mecab_nouns(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Extract part-of-speech tagged pairs
+     *
+     * Returns a JSON string containing an array of [surface, pos] pairs.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const posJson = mecab.pos("안녕하세요");
+     * const pos = JSON.parse(posJson);
+     * console.log(pos); // [["안녕", "NNG"], ["하", "XSV"], ["세요", "EP+EF"]]
+     * ```
+     *
+     * # Errors
+     *
+     * Returns an error if JSON serialization fails
+     * @param {string} text
+     * @returns {string}
+     */
+    pos(text) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.mecab_pos(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Tokenize text and return detailed token information
+     *
+     * Returns an array of tokens with surface form, POS tag, and position information.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const tokens = mecab.tokenize("안녕하세요");
+     * tokens.forEach(token => {
+     *   console.log(`${token.surface}: ${token.pos}`);
+     * });
+     * ```
+     * @param {string} text
+     * @returns {WasmToken[]}
+     */
+    tokenize(text) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.mecab_tokenize(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Perform wakati (분리) tokenization
+     *
+     * Returns an array of morpheme strings, similar to `morphs()`.
+     *
+     * # Example (JavaScript)
+     *
+     * ```javascript
+     * const words = mecab.wakati("형태소 분석");
+     * console.log(words); // ["형태소", "분석"]
+     * ```
+     * @param {string} text
+     * @returns {string[]}
+     */
+    wakati(text) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.mecab_wakati(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export(r0, r1 * 4, 4);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Mecab.prototype[Symbol.dispose] = Mecab.prototype.free;
+
+/**
+ * A JavaScript-friendly token representation
+ */
+export class WasmToken {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmToken.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmTokenFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmTokenFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmtoken_free(ptr, 0);
+    }
+    /**
+     * Get the end position in bytes
+     * @returns {number}
+     */
+    get end() {
+        const ret = wasm.wasmtoken_end(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the lemma/base form (if available)
+     * @returns {string | undefined}
+     */
+    get lemma() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtoken_lemma(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the part-of-speech tag (품사)
+     * @returns {string}
+     */
+    get pos() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtoken_pos(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Get the reading (if available)
+     * @returns {string | undefined}
+     */
+    get reading() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtoken_reading(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get the start position in bytes
+     * @returns {number}
+     */
+    get start() {
+        const ret = wasm.wasmtoken_start(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get the surface form (표면형)
+     * @returns {string}
+     */
+    get surface() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtoken_surface(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Convert to JSON string for easier JavaScript interop
+     *
+     * # Errors
+     *
+     * Returns an error if serialization fails
+     * @returns {string}
+     */
+    toJSON() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmtoken_toJSON(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) WasmToken.prototype[Symbol.dispose] = WasmToken.prototype.free;
+
+/**
+ * Initialize the WASM module
+ *
+ * This function should be called once before using the library.
+ * It sets up panic hooks for better error messages in development.
+ */
+export function init() {
+    wasm.init();
+}
+export function __wbg___wbindgen_throw_6ddd609b62940d55(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_export(deferred0_0, deferred0_1, 1);
+    }
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return addHeapObject(ret);
+}
+export function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+export function __wbg_wasmtoken_new(arg0) {
+    const ret = WasmToken.__wrap(arg0);
+    return addHeapObject(ret);
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+}
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+}
+const MecabFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_mecab_free(ptr >>> 0, 1));
+const WasmTokenFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmtoken_free(ptr >>> 0, 1));
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "mecab-ko-wasm",
+  "version": "0.3.0",
+  "description": "WebAssembly bindings for MeCab-Ko Korean morphological analyzer",
+  "main": "index.js",
+  "module": "mecab_ko_wasm.js",
+  "types": "index.d.ts",
+  "sideEffects": [
+    "./mecab_ko_wasm.js"
+  ],
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "mecab_ko_wasm_bg.wasm",
+    "mecab_ko_wasm.js",
+    "mecab_ko_wasm.d.ts",
+    "mecab_ko_wasm_bg.js",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "wasm-pack build --target bundler --out-dir pkg",
+    "build:node": "wasm-pack build --target nodejs --out-dir pkg-node",
+    "build:web": "wasm-pack build --target web --out-dir pkg-web",
+    "test": "wasm-pack test --headless --firefox"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hephaex/mecab-ko"
+  },
+  "keywords": [
+    "korean",
+    "nlp",
+    "morphological-analysis",
+    "tokenizer",
+    "mecab",
+    "wasm",
+    "webassembly"
+  ],
+  "author": "hephaex <hephaex@gmail.com>",
+  "license": "MIT OR Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hephaex/mecab-ko/issues"
+  },
+  "homepage": "https://github.com/hephaex/mecab-ko#readme",
+  "exports": {
+    ".": {
+      "import": "./mecab_ko_wasm.js",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}