Rust
JSR

    HTML processing

    Pass "html" as the format to convert():

    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    ("<p>漢字</p>", "html"));    
// → <p>한자</p>

    Gukhanmun parses the input as an HTML fragment, converts hanja in text nodes, and serialises the result while preserving all tags and attributes.

    Elements that are always preserved

    These elements and their descendants are never modified:

    • <code>, <kbd>, <pre>, <samp>
    • <script>, <style>, <textarea>
    • Elements with translate="no"
    • <ruby> annotation content

    Preserving elements by CSS class

    Use html.preserveClasses to skip conversion inside elements that carry specific classes:

    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    ()],    
  
    GukhanmunOptions.html?: HtmlOptions | undefined
    HTML-specific preservation rules.  Ignored for non-HTML input formats.
    @seeHtmlOptions
    html    : {    
    
    HtmlOptions.preserveClasses?: readonly string[] | undefined
    Class names whose containing element (and all descendants) should be
treated as a preserved region — the engine skips their text content.
    

    Equivalent to passing --html-preserve-class NAME to the CLI one or
more times.
    preserveClasses    : ["math", "no-translate"],    
  },
});

const 
    const html: "\n  <p>漢字</p>\n  <span class=\"math\">漢字</span>\n"
    html     = `    
  <p>漢字</p>
  <span class="math">漢字</span>
`;

    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    (
    const html: "\n  <p>漢字</p>\n  <span class=\"math\">漢字</span>\n"
    html    , "html"));    
// → <p>한자</p>
//   <span class="math">漢字</span>   ← preserved

    Preserving elements by attribute

    Use html.preserveAttributes to skip conversion based on an attribute name or an attribute name/value pair:

    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    ()],    
  
    GukhanmunOptions.html?: HtmlOptions | undefined
    HTML-specific preservation rules.  Ignored for non-HTML input formats.
    @seeHtmlOptions
    html    : {    
    
    HtmlOptions.preserveAttributes?: readonly (string | {
    readonly name: string;
    readonly value?: string;
})[] | undefined
    Attribute matchers; an element is preserved when it carries a matching
attribute.  Each entry is either:
    

      

    • A bare string — preserve any element that has the attribute, regardless
of value (e.g. "data-no-translate").
      • 

    • An object { name, value? } — preserve elements where the attribute
equals value, or has the attribute when value is omitted.
      • 

    

    Equivalent to --html-preserve-attr KEY[=VALUE] on the CLI.
    preserveAttributes    : [    
      "data-no-hanja",            // any element with this attribute
      { 
    name: string
    name    : "lang", 
    value?: string | undefined
    value    : "en" }, // elements with lang="en"    
    ],
  },
});

    Ruby markup in HTML

    Combine "html" format with a ruby rendering mode:

    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.rendering?: RenderMode | undefined
    How annotations are rendered into output text or markup.  Defaults to
"hangul-only".
    @seeRenderMode
    rendering    : "ruby-on-hangul",    
  
    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    ("<p>漢字</p>", "html"));    
// → <p><ruby>한자<rt>漢字</rt></ruby></p>