🥮 mooncakes.io

    moon_l10n

    A cross-target ICU MessageFormat subset runtime and catalog linter for MoonBit.

    moonbit
    i18n
    l10n
    icu
    localization
    Download zip
    Author
    Version
    0.2.0
    License
    MIT
    Repository
    Last updated
    2 months ago
    Downloads
    82

    #MoonL10n

    CI

    MoonL10n is a cross-target MoonBit internationalization library and CLI. It implements the practical core of ICU MessageFormat: variables, select, cardinal plural, selectordinal, nested branches, locale-aware fallback, JSON catalogs, static linting, and deterministic validation reports.

    The runtime has no file-system dependency and supports native, JavaScript, WebAssembly, and wasm-gc. File access is isolated in the CLI package.

    #Installation

    Add the latest Mooncakes release:

    moon add Zhouz-z/moon_l10n

    To reproduce this release after version 0.2.0 is published:

    moon add Zhouz-z/moon_l10n@0.2.0

    Import the package from moon.pkg:

    ///|
    import {
      "Zhouz-z/moon_l10n",
    }

    The default package alias is @moon_l10n. Run moon update after changing dependencies if the local package index is stale.

    #Minimal library example

    ///|
    test {
      let message = @moon_l10n.parse_message(
        "{count, plural, one {# file} other {# files}}",
      )
      let values : Map[String, @moon_l10n.Argument] = {
        "count": @moon_l10n.Number(2),
      }
      inspect(@moon_l10n.format(message, values, "en"), content="2 files")
    }

    Load catalogs and use locale fallback:

    ///|
    test {
      let english = @moon_l10n.Catalog::from_json(
        "en", "{\"files\":\"{count, plural, one {# file} other {# files}}\"}",
      )
      let translator = @moon_l10n.Translator::new("zh-CN", "en")
      translator.add_catalog(english)
      let result = translator.translate_detailed(
        "files",
        { "count": @moon_l10n.Number(1) },
        locale="zh-Hans-CN",
      )
      inspect(result.value(), content="1 file")
      inspect(result.resolved_locale(), content="en")
    }

    Fallback formatting uses the locale of the catalog that supplied the message. For example, an English fallback selected from a Chinese request still applies English plural rules.

    #Message syntax

    Variables:

    Hello {name}

    Text selection:

    {gender, select, female {She} male {He} other {They}}

    Cardinal plural:

    {count, plural, =0 {No files} one {# file} other {# files}}

    Ordinal selection:

    {position, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}

    Choices may contain other choices. Within a plural or ordinal branch, # renders the active numeric argument. An inner plural temporarily replaces the outer # value; an inner select preserves it.

    The standard formatter name is selectordinal. The parser rejects the common misspelling selectorordinal and reports a correction.

    #Catalogs and fallback

    A catalog is a JSON object whose values are MessageFormat templates:

    {
  "greeting": "Hello {name}",
  "files": "{count, plural, one {# file} other {# files}}"
}

    Catalog::from_json is strict and rejects malformed templates. Catalog::from_json_lenient preserves malformed templates so validators and translation editors can report all problems in one run.

    Requested locales are canonicalized and expanded into parents. A request for zh-Hans-CN tries:

    zh-Hans-CN -> zh-Hans -> zh -> configured default -> configured fallback

    Translator::resolve and translate_detailed expose the requested locale, resolved catalog locale, template provenance, and whether fallback occurred.

    #Linting

    lint_catalogs(reference, translation) reports:

    • missing and extra keys;
    • malformed reference or translation templates with line and column;
    • missing and extra arguments;
    • text-versus-number argument usage changes;
    • select, plural, and selectordinal kind changes;
    • missing or unexpected selectors;
    • missing exact selectors such as =0;
    • plural categories expected by the target locale.

    Reports have stable issue codes, severity, text output, JSON output, summary counts, and exit-code semantics. Catalog utilities also provide key diffs, coverage percentages, builders, deterministic JSON serialization, statistics, and multi-locale coverage matrices.

    #CLI

    Validate templates and semantic signatures:

    moon run cmd/main -- validate examples/locales/en.json examples/locales/en.json en
moon run cmd/main -- validate examples/locales/en.json examples/locales/ru.json ru --json

    Compare catalog key sets:

    moon run cmd/main -- diff examples/locales/en.json examples/locales/zh-CN.json zh-CN

    Render one message:

    moon run cmd/main -- render examples/locales/en.json en files count=3
moon run cmd/main -- render examples/locales/en.json en files count=1 --json

    Exit code 0 means clean, 1 means warnings or extra-only differences, and 2 means errors or missing required content. render returns 0 on success.

    #Locale coverage

    Version 0.2.0 explicitly implements integer plural behavior for:

    • Chinese (zh, including zh-CN) and Japanese (ja): other;
    • English (en): cardinal one/other, ordinal one/two/few/other;
    • Russian (ru): one/few/many/other;
    • Arabic (ar): zero/one/two/few/many/other.

    The locale layer also provides canonicalization, language/script/region parsing, parent fallback chains, text direction, negotiation, supported category metadata, and representative plural examples.

    #ICU and CLDR scope

    MoonL10n is an original MoonBit implementation informed by public internationalization specifications. It does not copy ICU or CLDR source code or data files.

    References:

    Version 0.2.0 intentionally does not implement:

    • date, time, number, or currency formatting;
    • gettext PO/POT catalogs;
    • plural offset;
    • decimal plural operands;
    • complete generated CLDR locale data;
    • ICU apostrophe quoting;
    • remote translation services.

    Backslash escaping is used for literal {, }, #, and \ in this subset. These boundaries keep the runtime compact, deterministic, and cross-target.

    #Validation

    python scripts/count_effective_moonbit.py --minimum 4000
moon fmt --check
moon check --target all --deny-warn
moon build --target all --deny-warn
moon test --target all --deny-warn
moon info
moon package

    The effective-line check counts code-bearing lines in production MoonBit library packages. Tests, examples, the CLI executable, generated interfaces, comments, and build output are excluded.

    GitHub Actions runs the same gates plus CLI smoke tests and uploads the Mooncakes zip artifact.

    #License

    MIT. See LICENSE.

    MessageError

    source
    pub(all) suberror MessageError {
      ParseError(position~ : Int, message~ : String)
      InvalidCatalog(String)
      InvalidLocale(String)
      InvalidCommand(String)
      EvaluationLimit(Int)
      MissingArgument(String)
      WrongArgumentType(String)
      MissingChoice(String)
    } derive(Eq, 
    Debug    )

    Argument

    source
    pub(all) enum Argument {
      Text(String)
      Number(Int)
    } derive(Eq, 
    Debug    )

    Argument::as_number

    source
    fn Argument::as_number(self : Argument) -> Int raise MessageError

    Argument::as_text

    source
    fn Argument::as_text(self : Argument) -> String

    Argument::is_number

    source
    fn Argument::is_number(self : Argument) -> Bool

    Argument::is_text

    source
    fn Argument::is_text(self : Argument) -> Bool

    Argument::kind

    source
    fn Argument::kind(self : Argument) -> String

    ArgumentRole

    source
    pub(all) enum ArgumentRole {
      Interpolation
      SelectSelector
      CardinalSelector
      OrdinalSelector
    } derive(Eq, 
    Debug    )

    Describes how an argument is consumed by a message.

    ArgumentRole::expects_number

    source
    fn ArgumentRole::expects_number(self : ArgumentRole) -> Bool

    ArgumentRole::name

    source
    fn ArgumentRole::name(self : ArgumentRole) -> String

    ArgumentUse

    source
    pub(all) struct ArgumentUse {
      name : String
      roles : Array[ArgumentRole]
      occurrences : Int
    } derive(Eq, 
    Debug    )

    A single use of an argument in a parsed message.

    ArgumentUse::expects_number

    source
    fn ArgumentUse::expects_number(self : ArgumentUse) -> Bool

    ArgumentUse::name

    source
    fn ArgumentUse::name(self : ArgumentUse) -> String

    ArgumentUse::occurrences

    source
    fn ArgumentUse::occurrences(self : ArgumentUse) -> Int

    ArgumentUse::roles

    source

    ArgumentUse::uses_role

    source
    fn ArgumentUse::uses_role(self : ArgumentUse, role : ArgumentRole) -> Bool

    Catalog

    source
    pub struct Catalog {
      locale : String
      entries : Map[String, String]
    } derive(
    Debug    )

    Catalog::analyses

    source
    fn Catalog::analyses(self : Catalog) -> Array[CatalogEntryAnalysis]

    Catalog::contains

    source
    fn Catalog::contains(self : Catalog, key : String) -> Bool

    Catalog::entries

    source
    fn Catalog::entries(self : Catalog) -> Map[String, String]

    Catalog::entry_analysis

    source
    fn Catalog::entry_analysis(self : Catalog, key : String) -> CatalogEntryAnalysis?

    Catalog::from_json

    source
    fn Catalog::from_json(locale : String, source : String) -> Catalog raise MessageError

    Catalog::from_json_lenient

    source
    fn Catalog::from_json_lenient(locale : String, source : String) -> Catalog raise MessageError

    Load a catalog without rejecting invalid message templates.

    This is intended for validators and editors that need to report every malformed entry in one pass. Applications should normally use from_json.

    Catalog::get

    source
    fn Catalog::get(self : Catalog, key : String) -> String?

    Catalog::invalid_keys

    source
    fn Catalog::invalid_keys(self : Catalog) -> Array[String]

    Catalog::is_empty

    source
    fn Catalog::is_empty(self : Catalog) -> Bool

    Catalog::keys

    source
    fn Catalog::keys(self : Catalog) -> Array[String]

    Catalog::length

    source
    fn Catalog::length(self : Catalog) -> Int

    Catalog::locale

    source
    fn Catalog::locale(self : Catalog) -> String

    Catalog::merge

    source
    fn Catalog::merge(self : Catalog, other : Catalog, policy? : CatalogMergePolicy) -> Catalog raise MessageError

    Catalog::parsed

    source
    fn Catalog::parsed(self : Catalog, key : String) -> Message?

    Catalog::stats

    source
    fn Catalog::stats(self : Catalog) -> CatalogStats

    Compute aggregate catalog statistics.

    Catalog::subset

    source
    fn Catalog::subset(self : Catalog, prefix : String) -> Catalog

    Catalog::to_json

    source
    fn Catalog::to_json(self : Catalog, pretty? : Bool) -> String

    Serialize a catalog deterministically with keys in lexical order.

    Catalog::valid_keys

    source
    fn Catalog::valid_keys(self : Catalog) -> Array[String]

    Catalog::values

    source
    fn Catalog::values(self : Catalog) -> Array[String]

    Catalog::with_entry

    source
    fn Catalog::with_entry(self : Catalog, key : String, template : String) -> Catalog raise MessageError

    Catalog::without_entry

    source
    fn Catalog::without_entry(self : Catalog, key : String) -> Catalog

    CatalogBuilder

    source
    pub struct CatalogBuilder {
      locale : String
      entries : Map[String, String]
    }

    A builder for constructing catalogs without exposing mutable internals.

    CatalogBuilder::build

    source
    fn CatalogBuilder::build(self : CatalogBuilder, validate? : Bool) -> Catalog raise MessageError

    CatalogBuilder::clear

    source

    CatalogBuilder::contains

    source
    fn CatalogBuilder::contains(self : CatalogBuilder, key : String) -> Bool

    CatalogBuilder::from_catalog

    source
    fn CatalogBuilder::from_catalog(catalog : Catalog) -> CatalogBuilder

    CatalogBuilder::length

    source
    fn CatalogBuilder::length(self : CatalogBuilder) -> Int

    CatalogBuilder::locale

    source
    fn CatalogBuilder::locale(self : CatalogBuilder) -> String

    CatalogBuilder::new

    source
    fn CatalogBuilder::new(locale : String) -> CatalogBuilder

    CatalogBuilder::remove

    source
    fn CatalogBuilder::remove(self : CatalogBuilder, key : String) -> CatalogBuilder

    CatalogBuilder::set

    source
    fn CatalogBuilder::set(self : CatalogBuilder, key : String, template : String) -> CatalogBuilder

    CatalogCoverage

    source
    pub(all) struct CatalogCoverage {
      reference_keys : Int
      translated_keys : Int
      missing_keys : Int
      extra_keys : Int
      coverage_percent : Int
    } derive(Eq, 
    Debug    )

    Result of a catalog coverage calculation.

    CatalogCoverage::coverage_percent

    source
    fn CatalogCoverage::coverage_percent(self : CatalogCoverage) -> Int

    CatalogCoverage::extra_keys

    source
    fn CatalogCoverage::extra_keys(self : CatalogCoverage) -> Int

    CatalogCoverage::missing_keys

    source
    fn CatalogCoverage::missing_keys(self : CatalogCoverage) -> Int

    CatalogCoverage::reference_keys

    source
    fn CatalogCoverage::reference_keys(self : CatalogCoverage) -> Int

    CatalogCoverage::summary

    source
    fn CatalogCoverage::summary(self : CatalogCoverage) -> String

    CatalogCoverage::translated_keys

    source
    fn CatalogCoverage::translated_keys(self : CatalogCoverage) -> Int

    CatalogDiff

    source
    pub(all) struct CatalogDiff {
      reference_locale : String
      translation_locale : String
      shared_keys : Array[String]
      missing_keys : Array[String]
      extra_keys : Array[String]
    } derive(Eq, 
    Debug    )

    Key-level difference between two catalogs.

    CatalogDiff::coverage

    source
    fn CatalogDiff::coverage(self : CatalogDiff) -> CatalogCoverage

    CatalogDiff::extra_keys

    source
    fn CatalogDiff::extra_keys(self : CatalogDiff) -> Array[String]

    CatalogDiff::is_equal

    source
    fn CatalogDiff::is_equal(self : CatalogDiff) -> Bool

    CatalogDiff::missing_keys

    source
    fn CatalogDiff::missing_keys(self : CatalogDiff) -> Array[String]

    CatalogDiff::reference_locale

    source
    fn CatalogDiff::reference_locale(self : CatalogDiff) -> String

    CatalogDiff::shared_keys

    source
    fn CatalogDiff::shared_keys(self : CatalogDiff) -> Array[String]

    CatalogDiff::translation_locale

    source
    fn CatalogDiff::translation_locale(self : CatalogDiff) -> String

    CatalogEntryAnalysis

    source
    pub(all) struct CatalogEntryAnalysis {
      key : String
      template : String
      valid : Bool
      diagnostic : MessageDiagnostic?
      message : MessageAnalysis?
    } derive(
    Debug    )

    Analysis for a single catalog entry.

    CatalogEntryAnalysis::diagnostic

    source

    CatalogEntryAnalysis::key

    source
    fn CatalogEntryAnalysis::key(self : CatalogEntryAnalysis) -> String

    CatalogEntryAnalysis::message

    source

    CatalogEntryAnalysis::template

    source
    fn CatalogEntryAnalysis::template(self : CatalogEntryAnalysis) -> String

    CatalogEntryAnalysis::valid

    source
    fn CatalogEntryAnalysis::valid(self : CatalogEntryAnalysis) -> Bool

    CatalogMatrix

    source
    pub(all) struct CatalogMatrix {
      reference_locale : String
      locales : Array[String]
      rows : Array[CatalogMatrixRow]
    } derive(Eq, 
    Debug    )

    Cross-locale catalog coverage matrix.

    CatalogMatrix::complete

    source
    fn CatalogMatrix::complete(self : CatalogMatrix) -> Bool

    CatalogMatrix::complete_rows

    source
    fn CatalogMatrix::complete_rows(self : CatalogMatrix) -> Array[CatalogMatrixRow]

    CatalogMatrix::coverage_for

    source
    fn CatalogMatrix::coverage_for(self : CatalogMatrix, locale : String) -> CatalogCoverage?

    CatalogMatrix::has_locale

    source
    fn CatalogMatrix::has_locale(self : CatalogMatrix, locale : String) -> Bool

    CatalogMatrix::incomplete_rows

    source
    fn CatalogMatrix::incomplete_rows(self : CatalogMatrix) -> Array[CatalogMatrixRow]

    CatalogMatrix::key_count

    source
    fn CatalogMatrix::key_count(self : CatalogMatrix) -> Int

    CatalogMatrix::locale_count

    source
    fn CatalogMatrix::locale_count(self : CatalogMatrix) -> Int

    CatalogMatrix::locales

    source
    fn CatalogMatrix::locales(self : CatalogMatrix) -> Array[String]

    CatalogMatrix::missing_count

    source
    fn CatalogMatrix::missing_count(self : CatalogMatrix) -> Int

    CatalogMatrix::missing_keys_for

    source
    fn CatalogMatrix::missing_keys_for(self : CatalogMatrix, locale : String) -> Array[String]

    CatalogMatrix::present_keys_for

    source
    fn CatalogMatrix::present_keys_for(self : CatalogMatrix, locale : String) -> Array[String]

    CatalogMatrix::reference_locale

    source
    fn CatalogMatrix::reference_locale(self : CatalogMatrix) -> String

    CatalogMatrix::row

    source
    fn CatalogMatrix::row(self : CatalogMatrix, key : String) -> CatalogMatrixRow?

    CatalogMatrix::rows

    source

    CatalogMatrix::to_json

    source
    fn CatalogMatrix::to_json(self : CatalogMatrix) -> String

    CatalogMatrix::to_text

    source
    fn CatalogMatrix::to_text(self : CatalogMatrix) -> String

    CatalogMatrixRow

    source
    pub(all) struct CatalogMatrixRow {
      key : String
      present_locales : Array[String]
      missing_locales : Array[String]
    } derive(Eq, 
    Debug    )

    Presence information for one key across a catalog set.

    CatalogMatrixRow::complete

    source
    fn CatalogMatrixRow::complete(self : CatalogMatrixRow) -> Bool

    CatalogMatrixRow::coverage_percent

    source
    fn CatalogMatrixRow::coverage_percent(self : CatalogMatrixRow) -> Int

    CatalogMatrixRow::key

    source
    fn CatalogMatrixRow::key(self : CatalogMatrixRow) -> String

    CatalogMatrixRow::missing_locales

    source
    fn CatalogMatrixRow::missing_locales(self : CatalogMatrixRow) -> Array[String]

    CatalogMatrixRow::present_locales

    source
    fn CatalogMatrixRow::present_locales(self : CatalogMatrixRow) -> Array[String]

    CatalogMergePolicy

    source
    pub(all) enum CatalogMergePolicy {
      KeepExisting
      ReplaceExisting
      RejectDuplicate
    } derive(Eq, 
    Debug    )

    How duplicate keys should be handled while combining catalogs.

    CatalogStats

    source
    pub(all) struct CatalogStats {
      locale : String
      key_count : Int
      template_count : Int
      valid_template_count : Int
      invalid_template_count : Int
      argument_count : Int
      choice_count : Int
    } derive(Eq, 
    Debug    )

    Summary information for one catalog.

    CatalogStats::argument_count

    source
    fn CatalogStats::argument_count(self : CatalogStats) -> Int

    CatalogStats::choice_count

    source
    fn CatalogStats::choice_count(self : CatalogStats) -> Int

    CatalogStats::invalid_template_count

    source
    fn CatalogStats::invalid_template_count(self : CatalogStats) -> Int

    CatalogStats::key_count

    source
    fn CatalogStats::key_count(self : CatalogStats) -> Int

    CatalogStats::locale

    source
    fn CatalogStats::locale(self : CatalogStats) -> String

    CatalogStats::summary

    source
    fn CatalogStats::summary(self : CatalogStats) -> String

    CatalogStats::template_count

    source
    fn CatalogStats::template_count(self : CatalogStats) -> Int

    CatalogStats::valid_template_count

    source
    fn CatalogStats::valid_template_count(self : CatalogStats) -> Int

    ChoiceKind

    source
    pub(all) enum ChoiceKind {
      Select
      Plural
      SelectOrdinal
    } derive(Eq, 
    Debug    )

    The kind of selector represented by a choice expression.

    ChoiceKind::from_name

    source
    fn ChoiceKind::from_name(name : String) -> ChoiceKind?

    ChoiceKind::is_numeric

    source
    fn ChoiceKind::is_numeric(self : ChoiceKind) -> Bool

    ChoiceKind::name

    source
    fn ChoiceKind::name(self : ChoiceKind) -> String

    ChoiceUse

    source
    pub(all) struct ChoiceUse {
      argument : String
      kind : ChoiceKind
      selectors : Array[String]
      depth : Int
      ordinal : Int
    } derive(Eq, 
    Debug    )

    One choice expression found in a message.

    ChoiceUse::argument

    source
    fn ChoiceUse::argument(self : ChoiceUse) -> String

    ChoiceUse::category_selectors

    source
    fn ChoiceUse::category_selectors(self : ChoiceUse) -> Array[String]

    ChoiceUse::depth

    source
    fn ChoiceUse::depth(self : ChoiceUse) -> Int

    ChoiceUse::exact_selectors

    source
    fn ChoiceUse::exact_selectors(self : ChoiceUse) -> Array[String]

    ChoiceUse::has_selector

    source
    fn ChoiceUse::has_selector(self : ChoiceUse, selector : String) -> Bool

    ChoiceUse::identifier

    source
    fn ChoiceUse::identifier(self : ChoiceUse) -> String

    ChoiceUse::kind

    source
    fn ChoiceUse::kind(self : ChoiceUse) -> ChoiceKind

    ChoiceUse::ordinal

    source
    fn ChoiceUse::ordinal(self : ChoiceUse) -> Int

    ChoiceUse::selectors

    source
    fn ChoiceUse::selectors(self : ChoiceUse) -> Array[String]

    CliCommandKind

    source
    pub(all) enum CliCommandKind {
      Validate
      Diff
      Render
      Help
    } derive(Eq, 
    Debug    )

    Stable command names understood by the pure CLI parser.

    CliCommandKind::name

    source
    fn CliCommandKind::name(self : CliCommandKind) -> String

    CliOutput

    source
    pub(all) struct CliOutput {
      exit_code : Int
      stdout : String
      stderr : String
    } derive(Eq, 
    Debug    )

    Result returned by the pure CLI execution layer.

    CliOutput::display

    source
    fn CliOutput::display(self : CliOutput) -> String

    CliOutput::exit_code

    source
    fn CliOutput::exit_code(self : CliOutput) -> Int

    CliOutput::failed

    source
    fn CliOutput::failed(self : CliOutput) -> Bool

    CliOutput::stderr

    source
    fn CliOutput::stderr(self : CliOutput) -> String

    CliOutput::stdout

    source
    fn CliOutput::stdout(self : CliOutput) -> String

    CliOutput::succeeded

    source
    fn CliOutput::succeeded(self : CliOutput) -> Bool

    CliRequest

    source
    pub(all) struct CliRequest {
      kind : CliCommandKind
      paths : Array[String]
      locale : String?
      key : String?
      arguments : Map[String, Argument]
      json : Bool
    } derive(Eq, 
    Debug    )

    Parsed CLI request independent of file-system access.

    CliRequest::arguments

    source
    fn CliRequest::arguments(self : CliRequest) -> Map[String, Argument]

    CliRequest::json

    source
    fn CliRequest::json(self : CliRequest) -> Bool

    CliRequest::key

    source
    fn CliRequest::key(self : CliRequest) -> String?

    CliRequest::kind

    source

    CliRequest::locale

    source
    fn CliRequest::locale(self : CliRequest) -> String?

    CliRequest::path

    source
    fn CliRequest::path(self : CliRequest, index : Int) -> String?

    CliRequest::paths

    source
    fn CliRequest::paths(self : CliRequest) -> Array[String]

    FormatEvent

    source
    pub(all) struct FormatEvent {
      kind : FormatEventKind
      depth : Int
      path : String
      argument : String?
      selector : String?
      output : String
    } derive(Eq, 
    Debug    )

    One deterministic event from message evaluation.

    FormatEvent::argument

    source
    fn FormatEvent::argument(self : FormatEvent) -> String?

    FormatEvent::depth

    source
    fn FormatEvent::depth(self : FormatEvent) -> Int

    FormatEvent::display

    source
    fn FormatEvent::display(self : FormatEvent) -> String

    FormatEvent::emits_output

    source
    fn FormatEvent::emits_output(self : FormatEvent) -> Bool

    FormatEvent::has_argument

    source
    fn FormatEvent::has_argument(self : FormatEvent) -> Bool

    FormatEvent::has_selector

    source
    fn FormatEvent::has_selector(self : FormatEvent) -> Bool

    FormatEvent::is_choice

    source
    fn FormatEvent::is_choice(self : FormatEvent) -> Bool

    FormatEvent::kind

    source

    FormatEvent::output

    source
    fn FormatEvent::output(self : FormatEvent) -> String

    FormatEvent::path

    source
    fn FormatEvent::path(self : FormatEvent) -> String

    FormatEvent::selector

    source
    fn FormatEvent::selector(self : FormatEvent) -> String?

    FormatEventKind

    source
    pub(all) enum FormatEventKind {
      EmitText
      EmitArgument
      EmitPound
      SelectBranch
    } derive(Eq, 
    Debug    )

    Kind of evaluation event emitted by format_with_trace.

    FormatEventKind::name

    source
    fn FormatEventKind::name(self : FormatEventKind) -> String

    FormatOptions

    source
    pub(all) struct FormatOptions {
      missing_argument : MissingArgumentBehavior
      maximum_depth : Int
    } derive(Eq, 
    Debug    )

    Runtime options for message evaluation.

    FormatOptions::default

    source
    fn FormatOptions::default() -> FormatOptions

    FormatOptions::maximum_depth

    source
    fn FormatOptions::maximum_depth(self : FormatOptions) -> Int

    FormatOptions::missing_argument

    source
    fn FormatOptions::missing_argument(self : FormatOptions) -> MissingArgumentBehavior

    FormatOptions::permissive

    source
    fn FormatOptions::permissive() -> FormatOptions

    FormattedMessage

    source
    pub(all) struct FormattedMessage {
      value : String
      events : Array[FormatEvent]
    } derive(Eq, 
    Debug    )

    Formatted value plus a deterministic evaluation trace.

    FormattedMessage::choice_events

    source
    fn FormattedMessage::choice_events(self : FormattedMessage) -> Array[FormatEvent]

    FormattedMessage::event_count

    source
    fn FormattedMessage::event_count(self : FormattedMessage) -> Int

    FormattedMessage::events

    source

    FormattedMessage::events_for_argument

    source
    fn FormattedMessage::events_for_argument(self : FormattedMessage, argument : String) -> Array[FormatEvent]

    FormattedMessage::maximum_depth

    source
    fn FormattedMessage::maximum_depth(self : FormattedMessage) -> Int

    FormattedMessage::trace_text

    source
    fn FormattedMessage::trace_text(self : FormattedMessage) -> String

    FormattedMessage::value

    source
    fn FormattedMessage::value(self : FormattedMessage) -> String

    LintIssue

    source
    pub struct LintIssue {
      severity : LintSeverity
      code : String
      key : String
      message : String
      argument : String?
      selector : String?
    } derive(Eq, 
    Debug    )

    LintIssue::argument

    source
    fn LintIssue::argument(self : LintIssue) -> String?

    LintIssue::code

    source
    fn LintIssue::code(self : LintIssue) -> String

    LintIssue::display

    source
    fn LintIssue::display(self : LintIssue) -> String

    LintIssue::key

    source
    fn LintIssue::key(self : LintIssue) -> String

    LintIssue::message

    source
    fn LintIssue::message(self : LintIssue) -> String

    LintIssue::selector

    source
    fn LintIssue::selector(self : LintIssue) -> String?

    LintIssue::severity

    source
    fn LintIssue::severity(self : LintIssue) -> LintSeverity

    LintOptions

    source
    pub(all) struct LintOptions {
      report_extra_keys : Bool
      report_extra_arguments : Bool
      report_extra_selectors : Bool
      require_locale_categories : Bool
    } derive(Eq, 
    Debug    )

    Policy switches for catalog linting.

    LintOptions::default

    source
    fn LintOptions::default() -> LintOptions

    LintOptions::minimal

    source
    fn LintOptions::minimal() -> LintOptions

    LintOptions::report_extra_arguments

    source
    fn LintOptions::report_extra_arguments(self : LintOptions) -> Bool

    LintOptions::report_extra_keys

    source
    fn LintOptions::report_extra_keys(self : LintOptions) -> Bool

    LintOptions::report_extra_selectors

    source
    fn LintOptions::report_extra_selectors(self : LintOptions) -> Bool

    LintOptions::require_locale_categories

    source
    fn LintOptions::require_locale_categories(self : LintOptions) -> Bool

    LintReport

    source
    pub struct LintReport {
      reference_locale : String
      locale : String
      issues : Array[LintIssue]
    } derive(
    Debug    )

    LintReport::contains_code

    source
    fn LintReport::contains_code(self : LintReport, code : String) -> Bool

    LintReport::exit_code

    source
    fn LintReport::exit_code(self : LintReport) -> Int

    LintReport::has_errors

    source
    fn LintReport::has_errors(self : LintReport) -> Bool

    LintReport::issues

    source
    fn LintReport::issues(self : LintReport) -> Array[LintIssue]

    LintReport::issues_with_code

    source
    fn LintReport::issues_with_code(self : LintReport, code : String) -> Array[LintIssue]

    LintReport::issues_with_severity

    source
    fn LintReport::issues_with_severity(self : LintReport, severity : LintSeverity) -> Array[LintIssue]

    LintReport::locale

    source
    fn LintReport::locale(self : LintReport) -> String

    LintReport::ok

    source
    fn LintReport::ok(self : LintReport) -> Bool

    LintReport::reference_locale

    source
    fn LintReport::reference_locale(self : LintReport) -> String

    LintReport::summary

    source
    fn LintReport::summary(self : LintReport) -> LintSummary

    LintReport::to_json

    source
    fn LintReport::to_json(self : LintReport) -> String

    LintReport::to_text

    source
    fn LintReport::to_text(self : LintReport) -> String

    LintSeverity

    source
    pub(all) enum LintSeverity {
      Error
      Warning
      Information
    } derive(Eq, 
    Debug    )

    Severity assigned to a catalog lint issue.

    LintSeverity::name

    source
    fn LintSeverity::name(self : LintSeverity) -> String

    LintSeverity::rank

    source
    fn LintSeverity::rank(self : LintSeverity) -> Int

    LintSummary

    source
    pub(all) struct LintSummary {
      errors : Int
      warnings : Int
      information : Int
      total : Int
    } derive(Eq, 
    Debug    )

    Aggregate lint counts.

    LintSummary::display

    source
    fn LintSummary::display(self : LintSummary) -> String

    LintSummary::errors

    source
    fn LintSummary::errors(self : LintSummary) -> Int

    LintSummary::information

    source
    fn LintSummary::information(self : LintSummary) -> Int

    LintSummary::total

    source
    fn LintSummary::total(self : LintSummary) -> Int

    LintSummary::warnings

    source
    fn LintSummary::warnings(self : LintSummary) -> Int

    LocaleId

    source
    pub(all) struct LocaleId {
      original : String
      canonical : String
      language : String
      script : String?
      region : String?
      variants : Array[String]
    } derive(Eq, 
    Debug    )

    Parsed and normalized locale identifier.

    LocaleId::canonical

    source
    fn LocaleId::canonical(self : LocaleId) -> String

    LocaleId::fallback_chain

    source
    fn LocaleId::fallback_chain(self : LocaleId) -> Array[String]

    Return the exact locale followed by progressively broader parent locales.

    LocaleId::has_region

    source
    fn LocaleId::has_region(self : LocaleId) -> Bool

    LocaleId::has_script

    source
    fn LocaleId::has_script(self : LocaleId) -> Bool

    LocaleId::is_language

    source
    fn LocaleId::is_language(self : LocaleId, language : String) -> Bool

    LocaleId::language

    source
    fn LocaleId::language(self : LocaleId) -> String

    LocaleId::original

    source
    fn LocaleId::original(self : LocaleId) -> String

    LocaleId::parse

    source
    fn LocaleId::parse(value : String) -> LocaleId raise MessageError

    Parse and canonicalize a compact BCP-47-style locale identifier.

    LocaleId::region

    source
    fn LocaleId::region(self : LocaleId) -> String?

    LocaleId::script

    source
    fn LocaleId::script(self : LocaleId) -> String?

    LocaleId::variants

    source
    fn LocaleId::variants(self : LocaleId) -> Array[String]

    LocaleNegotiation

    source
    pub(all) struct LocaleNegotiation {
      requested : String
      candidates : Array[String]
      available : Array[String]
      matched : String?
      used_default : Bool
    } derive(Eq, 
    Debug    )

    Result of negotiating requested and available locales.

    LocaleNegotiation::available

    source
    fn LocaleNegotiation::available(self : LocaleNegotiation) -> Array[String]

    LocaleNegotiation::candidates

    source
    fn LocaleNegotiation::candidates(self : LocaleNegotiation) -> Array[String]

    LocaleNegotiation::matched

    source
    fn LocaleNegotiation::matched(self : LocaleNegotiation) -> String?

    LocaleNegotiation::requested

    source
    fn LocaleNegotiation::requested(self : LocaleNegotiation) -> String

    LocaleNegotiation::succeeded

    source
    fn LocaleNegotiation::succeeded(self : LocaleNegotiation) -> Bool

    LocaleNegotiation::summary

    source
    fn LocaleNegotiation::summary(self : LocaleNegotiation) -> String

    LocaleNegotiation::used_default

    source
    fn LocaleNegotiation::used_default(self : LocaleNegotiation) -> Bool

    LocaleProfile

    source
    pub(all) struct LocaleProfile {
      locale : LocaleId
      direction : TextDirection
      cardinal_family : PluralRuleFamily
      ordinal_family : PluralRuleFamily
      cardinal_categories : Array[String]
      ordinal_categories : Array[String]
    } derive(Eq, 
    Debug    )

    Metadata used by the runtime and linter for a supported locale.

    LocaleProfile::cardinal_categories

    source
    fn LocaleProfile::cardinal_categories(self : LocaleProfile) -> Array[String]

    LocaleProfile::cardinal_family

    source
    fn LocaleProfile::cardinal_family(self : LocaleProfile) -> PluralRuleFamily

    LocaleProfile::direction

    source
    fn LocaleProfile::direction(self : LocaleProfile) -> TextDirection

    LocaleProfile::locale

    source
    fn LocaleProfile::locale(self : LocaleProfile) -> LocaleId

    LocaleProfile::ordinal_categories

    source
    fn LocaleProfile::ordinal_categories(self : LocaleProfile) -> Array[String]

    LocaleProfile::ordinal_family

    source
    fn LocaleProfile::ordinal_family(self : LocaleProfile) -> PluralRuleFamily

    LocaleSupport

    source
    pub(all) struct LocaleSupport {
      language : String
      english_name : String
      native_name : String
      direction : TextDirection
      cardinal_categories : Array[String]
      ordinal_categories : Array[String]
    } derive(Eq, 
    Debug    )

    Human-facing metadata for one explicitly supported base locale.

    LocaleSupport::cardinal_categories

    source
    fn LocaleSupport::cardinal_categories(self : LocaleSupport) -> Array[String]

    LocaleSupport::direction

    source
    fn LocaleSupport::direction(self : LocaleSupport) -> TextDirection

    LocaleSupport::english_name

    source
    fn LocaleSupport::english_name(self : LocaleSupport) -> String

    LocaleSupport::language

    source
    fn LocaleSupport::language(self : LocaleSupport) -> String

    LocaleSupport::native_name

    source
    fn LocaleSupport::native_name(self : LocaleSupport) -> String

    LocaleSupport::ordinal_categories

    source
    fn LocaleSupport::ordinal_categories(self : LocaleSupport) -> Array[String]

    LocaleSupport::summary

    source
    fn LocaleSupport::summary(self : LocaleSupport) -> String

    Message

    source
    pub struct Message {
      nodes : Array[MessageNode]
    } derive(
    Debug    )

    Message::analyze

    source
    fn Message::analyze(self : Message) -> MessageAnalysis

    Analyze the argument signature and structural complexity of a message.

    Message::argument_uses

    source
    fn Message::argument_uses(self : Message) -> Array[ArgumentUse]

    Message::ast_text

    source
    fn Message::ast_text(self : Message) -> String

    Render a deterministic, human-readable AST tree.

    Message::choice_uses

    source
    fn Message::choice_uses(self : Message) -> Array[ChoiceUse]

    Message::from_nodes

    source
    fn Message::from_nodes(nodes : Array[MessageNode]) -> Message

    Construct a message from AST nodes.

    Message::maximum_depth

    source
    fn Message::maximum_depth(self : Message) -> Int

    Message::node_count

    source
    fn Message::node_count(self : Message) -> Int

    Message::nodes

    source
    fn Message::nodes(self : Message) -> Array[MessageNode]

    Message::signature

    source
    fn Message::signature(self : Message) -> MessageSignature

    Return a semantic signature for linting and tooling.

    Message::to_template

    source
    fn Message::to_template(self : Message) -> String

    Serialize an AST using MoonL10n's canonical spacing and escaping.

    MessageAnalysis

    source
    pub(all) struct MessageAnalysis {
      arguments : Array[ArgumentUse]
      node_count : Int
      text_node_count : Int
      argument_node_count : Int
      choice_node_count : Int
      pound_node_count : Int
      maximum_depth : Int
    } derive(Eq, 
    Debug    )

    Structural information collected from a parsed message.

    MessageAnalysis::argument_node_count

    source
    fn MessageAnalysis::argument_node_count(self : MessageAnalysis) -> Int

    MessageAnalysis::arguments

    source

    MessageAnalysis::choice_node_count

    source
    fn MessageAnalysis::choice_node_count(self : MessageAnalysis) -> Int

    MessageAnalysis::maximum_depth

    source
    fn MessageAnalysis::maximum_depth(self : MessageAnalysis) -> Int

    MessageAnalysis::node_count

    source
    fn MessageAnalysis::node_count(self : MessageAnalysis) -> Int

    MessageAnalysis::pound_node_count

    source
    fn MessageAnalysis::pound_node_count(self : MessageAnalysis) -> Int

    MessageAnalysis::text_node_count

    source
    fn MessageAnalysis::text_node_count(self : MessageAnalysis) -> Int

    MessageDiagnostic

    source
    pub(all) struct MessageDiagnostic {
      code : String
      message : String
      position : SourcePosition
    } derive(Eq, 
    Debug    )

    A stable, serializable parser diagnostic.

    MessageDiagnostic::code

    source
    fn MessageDiagnostic::code(self : MessageDiagnostic) -> String

    MessageDiagnostic::display

    source
    fn MessageDiagnostic::display(self : MessageDiagnostic) -> String

    MessageDiagnostic::message

    source
    fn MessageDiagnostic::message(self : MessageDiagnostic) -> String

    MessageDiagnostic::position

    source

    MessageNode

    source
    pub(all) enum MessageNode {
      TextNode(String)
      ArgumentNode(String)
      PoundNode
      ChoiceNode(String, String, Map[String, Array[MessageNode]])
    } derive(
    Debug    )

    MessageSignature

    source
    pub(all) struct MessageSignature {
      arguments : Array[ArgumentUse]
      choices : Array[ChoiceUse]
    } derive(Eq, 
    Debug    )

    Full semantic signature used by catalog linting.

    MessageSignature::argument

    source
    fn MessageSignature::argument(self : MessageSignature, name : String) -> ArgumentUse?

    MessageSignature::argument_count

    source
    fn MessageSignature::argument_count(self : MessageSignature) -> Int

    MessageSignature::argument_names

    source
    fn MessageSignature::argument_names(self : MessageSignature) -> Array[String]

    Return sorted argument names used by a message.

    MessageSignature::arguments

    source

    MessageSignature::choice_count

    source
    fn MessageSignature::choice_count(self : MessageSignature) -> Int

    MessageSignature::choices

    source

    MessageSignature::choices_for_argument

    source
    fn MessageSignature::choices_for_argument(self : MessageSignature, name : String) -> Array[ChoiceUse]

    MessageSignature::choices_of_kind

    source
    fn MessageSignature::choices_of_kind(self : MessageSignature, kind : ChoiceKind) -> Array[ChoiceUse]

    MessageSignature::compatible_with

    source
    fn MessageSignature::compatible_with(self : MessageSignature, other : MessageSignature) -> Bool

    Compare argument names and roles while ignoring occurrence counts.

    MessageSignature::has_argument

    source
    fn MessageSignature::has_argument(self : MessageSignature, name : String) -> Bool

    MessageSignature::summary

    source
    fn MessageSignature::summary(self : MessageSignature) -> String

    Render a compact signature suitable for CLI diagnostics.

    MissingArgumentBehavior

    source
    pub(all) enum MissingArgumentBehavior {
      RaiseError
      KeepPlaceholder
      ReplaceWithEmpty
    } derive(Eq, 
    Debug    )

    Behavior used by the configurable formatter when an argument is absent.

    MissingArgumentBehavior::name

    source

    PluralExamples

    source
    pub(all) struct PluralExamples {
      category : String
      values : Array[Int]
    } derive(Eq, 
    Debug    )

    Example values discovered for one plural category.

    PluralExamples::category

    source
    fn PluralExamples::category(self : PluralExamples) -> String

    PluralExamples::is_empty

    source
    fn PluralExamples::is_empty(self : PluralExamples) -> Bool

    PluralExamples::summary

    source
    fn PluralExamples::summary(self : PluralExamples) -> String

    PluralExamples::values

    source
    fn PluralExamples::values(self : PluralExamples) -> Array[Int]

    PluralRuleFamily

    source
    pub(all) enum PluralRuleFamily {
      OtherOnly
      English
      Russian
      Arabic
    } derive(Eq, 
    Debug    )

    Plural rule set selected for a locale.

    PluralRuleFamily::name

    source
    fn PluralRuleFamily::name(self : PluralRuleFamily) -> String

    PluralSelection

    source
    pub(all) struct PluralSelection {
      locale : String
      value : Int
      ordinal : Bool
      category : String
      exact_selector : String
      selected_selector : String
      used_exact : Bool
      used_other : Bool
    } derive(Eq, 
    Debug    )

    Explanation of plural branch selection.

    PluralSelection::category

    source
    fn PluralSelection::category(self : PluralSelection) -> String

    PluralSelection::exact_selector

    source
    fn PluralSelection::exact_selector(self : PluralSelection) -> String

    PluralSelection::locale

    source
    fn PluralSelection::locale(self : PluralSelection) -> String

    PluralSelection::ordinal

    source
    fn PluralSelection::ordinal(self : PluralSelection) -> Bool

    PluralSelection::selected_selector

    source
    fn PluralSelection::selected_selector(self : PluralSelection) -> String

    PluralSelection::summary

    source
    fn PluralSelection::summary(self : PluralSelection) -> String

    PluralSelection::used_exact

    source
    fn PluralSelection::used_exact(self : PluralSelection) -> Bool

    PluralSelection::used_other

    source
    fn PluralSelection::used_other(self : PluralSelection) -> Bool

    PluralSelection::value

    source
    fn PluralSelection::value(self : PluralSelection) -> Int

    ResolvedMessage

    source
    pub(all) struct ResolvedMessage {
      key : String
      requested_locale : String
      resolved_locale : String
      template : String
      used_fallback : Bool
    } derive(Eq, 
    Debug    )

    A message template together with the catalog that supplied it.

    ResolvedMessage::key

    source
    fn ResolvedMessage::key(self : ResolvedMessage) -> String

    ResolvedMessage::requested_locale

    source
    fn ResolvedMessage::requested_locale(self : ResolvedMessage) -> String

    ResolvedMessage::resolved_locale

    source
    fn ResolvedMessage::resolved_locale(self : ResolvedMessage) -> String

    ResolvedMessage::template

    source
    fn ResolvedMessage::template(self : ResolvedMessage) -> String

    ResolvedMessage::used_fallback

    source
    fn ResolvedMessage::used_fallback(self : ResolvedMessage) -> Bool

    SourcePosition

    source
    pub(all) struct SourcePosition {
      offset : Int
      line : Int
      column : Int
    } derive(Eq, 
    Debug    )

    A one-based source location together with its zero-based character offset.

    SourcePosition::column

    source
    fn SourcePosition::column(self : SourcePosition) -> Int

    SourcePosition::display

    source
    fn SourcePosition::display(self : SourcePosition) -> String

    SourcePosition::line

    source
    fn SourcePosition::line(self : SourcePosition) -> Int

    SourcePosition::offset

    source
    fn SourcePosition::offset(self : SourcePosition) -> Int

    SourceSpan

    source
    pub(all) struct SourceSpan {
      start : SourcePosition
      end : SourcePosition
    } derive(Eq, 
    Debug    )

    A half-open range in a message template.

    SourceSpan::end

    source

    SourceSpan::length

    source
    fn SourceSpan::length(self : SourceSpan) -> Int

    SourceSpan::start

    source
    fn SourceSpan::start(self : SourceSpan) -> SourcePosition

    TextDirection

    source
    pub(all) enum TextDirection {
      LeftToRight
      RightToLeft
    } derive(Eq, 
    Debug    )

    Text direction associated with a locale.

    TextDirection::name

    source
    fn TextDirection::name(self : TextDirection) -> String

    TranslationResult

    source
    pub(all) struct TranslationResult {
      key : String
      requested_locale : String
      resolved_locale : String
      value : String
      used_fallback : Bool
    } derive(Eq, 
    Debug    )

    Detailed result returned after translation and formatting.

    TranslationResult::key

    source
    fn TranslationResult::key(self : TranslationResult) -> String

    TranslationResult::requested_locale

    source
    fn TranslationResult::requested_locale(self : TranslationResult) -> String

    TranslationResult::resolved_locale

    source
    fn TranslationResult::resolved_locale(self : TranslationResult) -> String

    TranslationResult::used_fallback

    source
    fn TranslationResult::used_fallback(self : TranslationResult) -> Bool

    TranslationResult::value

    source
    fn TranslationResult::value(self : TranslationResult) -> String

    Translator

    source
    pub struct Translator {
      default_locale : String
      fallback_locale : String
      catalogs : Map[String, Catalog]
    } derive(
    Debug    )

    Translator::add_catalog

    source
    fn Translator::add_catalog(self : Translator, catalog : Catalog) -> Unit

    Translator::available_locales

    source
    fn Translator::available_locales(self : Translator) -> Array[String]

    Translator::catalog_count

    source
    fn Translator::catalog_count(self : Translator) -> Int

    Translator::default_locale

    source
    fn Translator::default_locale(self : Translator) -> String

    Translator::fallback_locale

    source
    fn Translator::fallback_locale(self : Translator) -> String

    Translator::has_catalog

    source
    fn Translator::has_catalog(self : Translator, locale : String) -> Bool

    Translator::new

    source
    fn Translator::new(default_locale : String, fallback_locale : String) -> Translator

    Translator::resolve

    source
    fn Translator::resolve(self : Translator, key : String, locale? : String) -> ResolvedMessage raise MessageError

    Resolve a key and preserve the locale of the catalog that supplied it.

    Translator::translate

    source
    fn Translator::translate(self : Translator, key : String, arguments : Map[String, Argument], locale? : String) -> String raise MessageError

    Look up and format a key, trying requested, default, then fallback locale.

    Translator::translate_detailed

    source
    fn Translator::translate_detailed(self : Translator, key : String, arguments : Map[String, Argument], locale? : String) -> TranslationResult raise MessageError

    Resolve, format, and return locale provenance for a translation.

    canonicalize_locale

    source
    fn canonicalize_locale(value : String) -> String raise MessageError

    Canonicalize a locale identifier.

    catalog_matrix

    source
    fn catalog_matrix(reference : Catalog, translations : Array[Catalog]) -> CatalogMatrix

    Build a key-presence matrix for a reference and multiple translations.

    cli_diff_sources

    source
    fn cli_diff_sources(reference_source : String, translation_source : String, locale : String, json? : Bool) -> CliOutput raise MessageError

    Compare the key sets of two in-memory catalog sources.

    cli_render_source

    source
    fn cli_render_source(source : String, locale : String, key : String, arguments : Map[String, Argument], json? : Bool) -> CliOutput raise MessageError

    Render one key from an in-memory catalog source.

    cli_usage

    source
    fn cli_usage() -> String

    Return the stable command-line help text.

    cli_validate_sources

    source
    fn cli_validate_sources(reference_source : String, translation_source : String, locale : String, json? : Bool) -> CliOutput raise MessageError

    Validate two in-memory catalog sources.

    diagnose_message

    source
    fn diagnose_message(template : String) -> MessageDiagnostic?

    Parse a message and return a diagnostic instead of raising on failure.

    diagnostic_from_error

    source
    fn diagnostic_from_error(source : String, error : MessageError) -> MessageDiagnostic

    Convert a parser error into a stable diagnostic with line and column.

    diff_catalogs

    source
    fn diff_catalogs(reference : Catalog, translation : Catalog) -> CatalogDiff

    Compare the key sets of two catalogs.

    format

    source
    fn format(message : Message, arguments : Map[String, Argument], locale : String) -> String raise MessageError

    Format a parsed message with text and integer arguments.

    format_with_options

    source
    fn format_with_options(message : Message, arguments : Map[String, Argument], locale : String, options : FormatOptions) -> String raise MessageError

    Format a message using explicit runtime options.

    format_with_trace

    source
    fn format_with_trace(message : Message, arguments : Map[String, Argument], locale : String, options? : FormatOptions) -> FormattedMessage raise MessageError

    Format a message and retain a deterministic evaluation trace.

    is_supported_locale

    source
    fn is_supported_locale(locale : String) -> Bool

    Return whether MoonL10n has an explicit plural rule for the locale.

    lint_catalog_set

    source
    fn lint_catalog_set(reference : Catalog, translations : Array[Catalog]) -> Array[LintReport]

    Lint multiple translations using one reference catalog.

    lint_catalogs

    source
    fn lint_catalogs(reference : Catalog, translation : Catalog) -> LintReport

    Compare a translation against the reference catalog.

    lint_catalogs_with_options

    source
    fn lint_catalogs_with_options(reference : Catalog, translation : Catalog, options : LintOptions) -> LintReport

    Compare a translation against the reference catalog with explicit policy.

    locale_fallback_chain

    source
    fn locale_fallback_chain(locale : String) -> Array[String]

    Build a fallback chain for a locale, tolerating non-canonical input.

    locale_profile

    source
    fn locale_profile(locale : String) -> LocaleProfile raise MessageError

    Return plural metadata for a locale.

    locale_support

    source
    fn locale_support(locale : String) -> LocaleSupport?

    locale_support_table

    source
    fn locale_support_table() -> Array[LocaleSupport]

    Return human-facing metadata for every explicitly supported language.

    missing_plural_categories

    source
    fn missing_plural_categories(locale : String, selectors : Array[String], ordinal? : Bool) -> Array[String]

    Check whether selectors cover all categories declared for a locale.

    negotiate_locale

    source
    fn negotiate_locale(requested : String, available : Array[String], default_locale? : String) -> LocaleNegotiation

    Negotiate a requested locale against an available locale list.

    observed_plural_categories

    source
    fn observed_plural_categories(locale : String, start : Int, end : Int, ordinal? : Bool) -> Array[String]

    Return every category observed over an inclusive integer range.

    ordinal_category

    source
    fn ordinal_category(locale : String, value : Int) -> String

    parse_cli_argument

    source
    fn parse_cli_argument(value : String) -> (String, Argument) raise MessageError

    Parse one name=value CLI argument.

    parse_cli_request

    source
    fn parse_cli_request(args : Array[String]) -> CliRequest raise MessageError

    Parse command arguments without accessing the file system.

    The first element must be the command itself, not the executable path.

    parse_message

    source
    fn parse_message(template : String) -> Message raise MessageError

    Parse a message template using the supported ICU MessageFormat subset.

    plural_category

    source
    fn plural_category(locale : String, value : Int) -> String

    plural_examples

    source
    fn plural_examples(locale : String, start : Int, end : Int, ordinal? : Bool, limit_per_category? : Int) -> Array[PluralExamples]

    Collect representative integer values for each plural category.

    required_cardinal_categories

    source
    fn required_cardinal_categories(locale : String) -> Array[String]

    Return the cardinal categories expected by the linter.

    required_ordinal_categories

    source
    fn required_ordinal_categories(locale : String) -> Array[String]

    Return the ordinal categories expected by the linter.

    select_plural_branch

    source
    fn select_plural_branch(locale : String, value : Int, ordinal : Bool, selectors : Array[String]) -> PluralSelection raise MessageError

    Explain how a numeric choice selects a branch.

    source_position

    source
    fn source_position(source : String, offset : Int) -> SourcePosition

    Convert a zero-based character offset into a one-based line and column.

    source_span

    source
    fn source_span(source : String, start : Int, end : Int) -> SourceSpan

    Create a half-open source span from two offsets.

    supported_languages

    source
    fn supported_languages() -> Array[String]

    Return all canonical base languages with explicit plural support.

    supported_locales

    source
    fn supported_locales() -> Array[String]

    Return all locale identifiers with explicit v0.2 plural support.

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io