Rust
JSR

    Quick start

    All Gukhanmun implementations export a single async factory function load. Call it once, then use the returned Gukhanmun instance for all conversions.

    Minimal example

    import { 
    function load(options?: GukhanmunOptions): Promise<Gukhanmun>
    Creates a Gukhanmun converter with the given options.
    

    Initialises the WASM module on the first call (subsequent calls reuse the
cached module).  Dictionaries supplied via
 
GukhanmunOptions.dictionaries
  are fetched and passed to the Rust
engine as FileDictionarySource values.
    

    Note: unlike the Rust ko-kr preset, the JavaScript preset never includes a
bundled dictionary.  Pass dictionaries: [await stdictFst()] to include the
Standard Korean Language Dictionary.
    @paramoptions  - Conversion options.  All fields are optional; defaults match
the ko-kr preset.@returnsA  Gukhanmun instance.@throws{@linkGukhanmunError } on invalid options or dictionary load failure.
    load     } from "@gukhanmun/wasm";    
import { 
    function stdictFst(): Promise<FileDictionarySource>
    Loads the bundled Standard Korean Language Dictionary as a
    

    FileDictionarySource
ready to pass to load({ dictionaries: [...] }).
    @returnsA  FileDictionarySource with format: "fst".
    stdictFst     } from "@gukhanmun/stdict-fst";    

const 
    const g: Gukhanmun
    g     = await 
    function load(options?: GukhanmunOptions): Promise<Gukhanmun>
    Creates a Gukhanmun converter with the given options.
    

    Initialises the WASM module on the first call (subsequent calls reuse the
cached module).  Dictionaries supplied via
 
GukhanmunOptions.dictionaries
  are fetched and passed to the Rust
engine as FileDictionarySource values.
    

    Note: unlike the Rust ko-kr preset, the JavaScript preset never includes a
bundled dictionary.  Pass dictionaries: [await stdictFst()] to include the
Standard Korean Language Dictionary.
    @paramoptions  - Conversion options.  All fields are optional; defaults match
the ko-kr preset.@returnsA  Gukhanmun instance.@throws{@linkGukhanmunError } on invalid options or dictionary load failure.
    load    ({    
  
    GukhanmunOptions.dictionaries?: readonly FileDictionarySource[] | undefined
    Ordered list of dictionary sources.  Sources are queried in order;
earlier entries take precedence.  When omitted (or empty), only the
fallback Unihan character map is used (no stdict).
    

    Unlike the "ko-kr" Rust preset, JavaScript presets do not
automatically include a bundled dictionary.  To use the Standard Korean
Language Dictionary, add @gukhanmun/stdict-fst or
@gukhanmun/stdict-cdb explicitly.
    @seeDictionarySource
    dictionaries    : [await 
    function stdictFst(): Promise<FileDictionarySource>
    Loads the bundled Standard Korean Language Dictionary as a
    

    FileDictionarySource
ready to pass to load({ dictionaries: [...] }).
    @returnsA  FileDictionarySource with format: "fst".
    stdictFst    ()],    
});


    var console: Console
    The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
    

    The module exports two specific components:
    

      

    • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
      • 

    • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
      • 

    

    Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
    

    Example using the global console:
    

    console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
    

    Example using the Console class:
    

    const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
    @seesource
    console    .
    Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
    Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
    

    const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
    

    See util.format() for more information.
    @sincev0 .1.100
    log    (
    const g: Gukhanmun
    g    .
    Gukhanmun.convert(source: string, format?: Format): string
    Converts source to hangul in one shot.  Buffers the entire input
before returning.
    @paramsource  - The text to convert.@paramformat  - Input / output format.  Defaults to "text".@returnsThe  converted text.@throws{@linkGukhanmunError } on conversion failure.
    convert    ("漢字를 한글로"));    
// → 한자를 한글로

    Switching to the NAPI backend

    The API is identical; only the import path changes:

    import { 
    function load(options?: GukhanmunOptions): Promise<Gukhanmun>
    Creates a Gukhanmun converter with the given options.
    

    The native addon is synchronously ready; dictionaries supplied via
 
GukhanmunOptions.dictionaries
  are fetched or read from disk and
passed to the Rust engine as FileDictionarySource values.
    

    Note: unlike the Rust ko-kr preset, the JavaScript preset never includes a
bundled dictionary.  Pass dictionaries: [await stdictFst()] to include the
Standard Korean Language Dictionary.
    @paramoptions  - Conversion options.  All fields are optional; defaults match
the ko-kr preset.@returnsA  Gukhanmun instance.@throws{@linkGukhanmunError } on invalid options or dictionary load failure.
    load     } from "@gukhanmun/napi";    
import { 
    function stdictFst(): Promise<FileDictionarySource>
    Loads the bundled Standard Korean Language Dictionary as a
    

    FileDictionarySource
ready to pass to load({ dictionaries: [...] }).
    @returnsA  FileDictionarySource with format: "fst".
    stdictFst     } from "@gukhanmun/stdict-fst";    

const 
    const g: Gukhanmun
    g     = await 
    function load(options?: GukhanmunOptions): Promise<Gukhanmun>
    Creates a Gukhanmun converter with the given options.
    

    The native addon is synchronously ready; dictionaries supplied via
 
GukhanmunOptions.dictionaries
  are fetched or read from disk and
passed to the Rust engine as FileDictionarySource values.
    

    Note: unlike the Rust ko-kr preset, the JavaScript preset never includes a
bundled dictionary.  Pass dictionaries: [await stdictFst()] to include the
Standard Korean Language Dictionary.
    @paramoptions  - Conversion options.  All fields are optional; defaults match
the ko-kr preset.@returnsA  Gukhanmun instance.@throws{@linkGukhanmunError } on invalid options or dictionary load failure.
    load    ({    
  
    GukhanmunOptions.dictionaries?: readonly FileDictionarySource[] | undefined
    Ordered list of dictionary sources.  Sources are queried in order;
earlier entries take precedence.  When omitted (or empty), only the
fallback Unihan character map is used (no stdict).
    

    Unlike the "ko-kr" Rust preset, JavaScript presets do not
automatically include a bundled dictionary.  To use the Standard Korean
Language Dictionary, add @gukhanmun/stdict-fst or
@gukhanmun/stdict-cdb explicitly.
    @seeDictionarySource
    dictionaries    : [await 
    function stdictFst(): Promise<FileDictionarySource>
    Loads the bundled Standard Korean Language Dictionary as a
    

    FileDictionarySource
ready to pass to load({ dictionaries: [...] }).
    @returnsA  FileDictionarySource with format: "fst".
    stdictFst    ()],    
});

    The convert() method

    g.convert(source) converts plain text by default. Pass a format string or object as the second argument for HTML or Markdown:

    const g: Gukhanmun
    g    .
    Gukhanmun.convert(source: string, format?: Format): string
    Converts source to hangul in one shot.  Buffers the entire input
before returning.
    @paramsource  - The text to convert.@paramformat  - Input / output format.  Defaults to "text".@returnsThe  converted text.@throws{@linkGukhanmunError } on conversion failure.
    convert    ("漢字를 한글로");             // plain text (default)    

    const g: Gukhanmun
    g    .
    Gukhanmun.convert(source: string, format?: Format): string
    Converts source to hangul in one shot.  Buffers the entire input
before returning.
    @paramsource  - The text to convert.@paramformat  - Input / output format.  Defaults to "text".@returnsThe  converted text.@throws{@linkGukhanmunError } on conversion failure.
    convert    ("<p>漢字</p>", "html");       // HTML fragment    

    const g: Gukhanmun
    g    .
    Gukhanmun.convert(source: string, format?: Format): string
    Converts source to hangul in one shot.  Buffers the entire input
before returning.
    @paramsource  - The text to convert.@paramformat  - Input / output format.  Defaults to "text".@returnsThe  converted text.@throws{@linkGukhanmunError } on conversion failure.
    convert    ("# 漢字", "markdown");        // CommonMark    

    const g: Gukhanmun
    g    .
    Gukhanmun.convert(source: string, format?: Format): string
    Converts source to hangul in one shot.  Buffers the entire input
before returning.
    @paramsource  - The text to convert.@paramformat  - Input / output format.  Defaults to "text".@returnsThe  converted text.@throws{@linkGukhanmunError } on conversion failure.
    convert    ("# 漢字", { 
    format: "markdown"
    format    : "markdown", 
    gfm?: boolean | undefined
    gfm    : true });  // GFM

    Error handling

    load() and convert() throw GukhanmunError on failure:

    import { 
    function load(options?: GukhanmunOptions): Promise<Gukhanmun>
    Creates a Gukhanmun converter with the given options.
    

    Initialises the WASM module on the first call (subsequent calls reuse the
cached module).  Dictionaries supplied via
 
GukhanmunOptions.dictionaries
  are fetched and passed to the Rust
engine as FileDictionarySource values.
    

    Note: unlike the Rust ko-kr preset, the JavaScript preset never includes a
bundled dictionary.  Pass dictionaries: [await stdictFst()] to include the
Standard Korean Language Dictionary.
    @paramoptions  - Conversion options.  All fields are optional; defaults match
the ko-kr preset.@returnsA  Gukhanmun instance.@throws{@linkGukhanmunError } on invalid options or dictionary load failure.
    load    , 
    class GukhanmunError
    Error thrown by  
load
 ,  
Gukhanmun.convert
 , and
 
Gukhanmun.stream
  when the Rust engine reports a failure.
    

    code identifies the failure class; chain carries the full causal chain
materialised at the FFI boundary so callers do not need additional round
trips.
    GukhanmunError     } from "@gukhanmun/wasm";    
import { 
    function stdictFst(): Promise<FileDictionarySource>
    Loads the bundled Standard Korean Language Dictionary as a
    

    FileDictionarySource
ready to pass to load({ dictionaries: [...] }).
    @returnsA  FileDictionarySource with format: "fst".
    stdictFst     } from "@gukhanmun/stdict-fst";    

try {
  const 
    const g: Gukhanmun
    g     = await 
    function load(options?: GukhanmunOptions): Promise<Gukhanmun>
    Creates a Gukhanmun converter with the given options.
    

    Initialises the WASM module on the first call (subsequent calls reuse the
cached module).  Dictionaries supplied via
 
GukhanmunOptions.dictionaries
  are fetched and passed to the Rust
engine as FileDictionarySource values.
    

    Note: unlike the Rust ko-kr preset, the JavaScript preset never includes a
bundled dictionary.  Pass dictionaries: [await stdictFst()] to include the
Standard Korean Language Dictionary.
    @paramoptions  - Conversion options.  All fields are optional; defaults match
the ko-kr preset.@returnsA  Gukhanmun instance.@throws{@linkGukhanmunError } on invalid options or dictionary load failure.
    load    ({ 
    GukhanmunOptions.dictionaries?: readonly FileDictionarySource[] | undefined
    Ordered list of dictionary sources.  Sources are queried in order;
earlier entries take precedence.  When omitted (or empty), only the
fallback Unihan character map is used (no stdict).
    

    Unlike the "ko-kr" Rust preset, JavaScript presets do not
automatically include a bundled dictionary.  To use the Standard Korean
Language Dictionary, add @gukhanmun/stdict-fst or
@gukhanmun/stdict-cdb explicitly.
    @seeDictionarySource
    dictionaries    : [await 
    function stdictFst(): Promise<FileDictionarySource>
    Loads the bundled Standard Korean Language Dictionary as a
    

    FileDictionarySource
ready to pass to load({ dictionaries: [...] }).
    @returnsA  FileDictionarySource with format: "fst".
    stdictFst    ()] });    
  
    const g: Gukhanmun
    g    .
    Gukhanmun.convert(source: string, format?: Format): string
    Converts source to hangul in one shot.  Buffers the entire input
before returning.
    @paramsource  - The text to convert.@paramformat  - Input / output format.  Defaults to "text".@returnsThe  converted text.@throws{@linkGukhanmunError } on conversion failure.
    convert    ("<invalid html>", "html");    
} catch (
    var e: unknown
    e    ) {    
  if (
    var e: unknown
    e     instanceof 
    class GukhanmunError
    Error thrown by  
load
 ,  
Gukhanmun.convert
 , and
 
Gukhanmun.stream
  when the Rust engine reports a failure.
    

    code identifies the failure class; chain carries the full causal chain
materialised at the FFI boundary so callers do not need additional round
trips.
    GukhanmunError    ) {    
    
    var console: Console
    The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
    

    The module exports two specific components:
    

      

    • A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
      • 

    • A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.
      • 

    

    Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
    

    Example using the global console:
    

    console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
    

    Example using the Console class:
    

    const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
    @seesource
    console    .
    Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)
    Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
    

    const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr
    

    If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
    @sincev0 .1.100
    error    (
    var e: GukhanmunError
    e    .
    GukhanmunError.code: ErrorCode
    Machine-readable error code.
    @seeErrorCode
    code    , 
    var e: GukhanmunError
    e    .
    Error.message: string
    message    );    
  }
}