kuroshiro-enhance/dist/index.d.ts

kuroshiro is a Japanese language library for converting Japanese sentence to Hiragana, Katakana or Romaji with furigana and okurigana modes supported.

/**
 * Token interface representing a parsed morphological token.
 */
interface Token {
    surface_form: string;
    pos: string;
    reading?: string;
    pronunciation?: string;
}
/**
 * Interface that all Kuroshiro analyzers must implement.
 */
interface Analyzer {
    init(): Promise<void>;
    parse(str: string): Promise<Token[]>;
}
/**
 * Valid syllabaries for conversion targets.
 */
type TargetSyllabary = "hiragana" | "katakana" | "romaji";
/**
 * Valid modes for conversion.
 */
type ConvertMode = "normal" | "spaced" | "okurigana" | "furigana" | "furigana_segments" | "furigana_map";
/**
 * Valid romanization systems.
 */
type RomanizationSystem = "nippon" | "passport" | "hepburn";
/**
 * Options passed to convert method.
 */
interface ConvertOptions {
    to?: TargetSyllabary;
    mode?: ConvertMode;
    includeKatakana?: boolean;
    romajiSystem?: RomanizationSystem;
    delimiter_start?: string;
    delimiter_end?: string;
}
/**
 * A single segment of furigana_segments output.
 * `text` is a slice of the original input; `ruby` is present only when the
 * segment carries a reading (kanji, or katakana when includeKatakana is set).
 * Newlines are emitted as their own ruby-less segments.
 */
interface FuriganaSegment {
    text: string;
    ruby?: string;
}
/**
 * @deprecated Use "furigana_segments" mode ({@link FuriganaSegment}[]) instead. Will be removed in the next major version.
 */
interface FuriganaMapResult {
    text: string;
    ruby: Array<{
        s: number;
        e: number;
        rt: string;
    }>;
}

/**
 * Kuroshiro Class
 */
declare class Kuroshiro {
    static Util: {
        isHiragana: (ch: string) => boolean;
        isKatakana: (ch: string) => boolean;
        isKana: (ch: string) => boolean;
        isKanji: (ch: string) => boolean;
        isJapanese: (ch: string) => boolean;
        hasHiragana: (str: string) => boolean;
        hasKatakana: (str: string) => boolean;
        hasKana: (str: string) => boolean;
        hasKanji: (str: string) => boolean;
        hasJapanese: (str: string) => boolean;
        kanaToHiragana: (str: string) => string;
        /** @deprecated Misspelled legacy name. Use kanaToHiragana instead. Will be removed in the next major version. */
        kanaToHiragna: (str: string) => string;
        kanaToKatakana: (str: string) => string;
        kanaToRomaji: (str: string, system?: string) => string;
    };
    private _analyzer;
    private _furiganaMapDeprecationWarned;
    /**
     * Initialize Kuroshiro
     * @memberOf Kuroshiro
     * @instance
     * @returns {Promise} Promise object represents the result of initialization
     */
    init(analyzer: Analyzer): Promise<void>;
    /**
     * Convert given string to target syllabary with options available
     * @memberOf Kuroshiro
     * @instance
     * @param {string} str Given String
     * @param {Object} [options] Settings Object
     * @param {string} [options.to="hiragana"] Target syllabary ["hiragana"|"katakana"|"romaji"]
     * @param {string} [options.mode="normal"] Convert mode ["normal"|"spaced"|"okurigana"|"furigana"]
     * @param {string} [options.includeKatakana=false] Whether to include Katakana in Furigana mode
     * @param {string} [options.romajiSystem="hepburn"] Romanization System ["nippon"|"passport"|"hepburn"]
     * @param {string} [options.delimiter_start="("] Delimiter(Start)
     * @param {string} [options.delimiter_end=")"] Delimiter(End)
     * @returns {Promise} Promise object represents the result of conversion
     */
    convert(str: string, options?: ConvertOptions): Promise<string | FuriganaMapResult | FuriganaSegment[]>;
}

export { type Analyzer, type ConvertMode, type ConvertOptions, type FuriganaMapResult, type FuriganaSegment, type RomanizationSystem, type TargetSyllabary, type Token, Kuroshiro as default };