@keymanapp/kmc-model 18.0.53-alpha → 18.0.55-alpha

package/build/src/lexical-model.d.ts

@@ -1,144 +1,144 @@
-/**
- * Interfaces and constants used by the lexical model compiler. These target
- * the LMLayer's internal worker code, so we provide those definitions too.
- */
-/// <reference types="@keymanapp/models-types" />
-export interface LexicalModelDeclaration {
-    readonly format: 'trie-1.0' | 'fst-foma-1.0' | 'custom-1.0';
-}
-/**
- * @public
- * Keyman 14.0+ word breaker specification:
- *
- * Can support all old word breaking specification,
- * but can also be extended with options.
- *
- * @since 14.0
- */
-export interface WordBreakerSpec {
-    readonly use: SimpleWordBreakerSpec;
-    /**
-     * If present, joins words that were split by the word breaker
-     * together at the given strings. e.g.,
-     *
-     *    joinWordsAt: ['-'] // to keep hyphenated items together
-     *
-     * @since 14.0
-     */
-    readonly joinWordsAt?: string[];
-    /**
-     * Overrides word splitting behaviour for certain scripts.
-     * For example, specifing that spaces break words in certain South-East
-     * Asian scripts that otherwise do not use spaces.
-     *
-     * @since 14.0
-     */
-    readonly overrideScriptDefaults?: OverrideScriptDefaults;
-}
-/**
- * @public
- * Simplified word breaker specification.
- *
- * @since 11.0
- */
-export type SimpleWordBreakerSpec = 'default' | 'ascii' | WordBreakingFunction;
-/**
- * @public
- * Simplifies input text to facilitate finding entries within a lexical model's
- * lexicon.
- * @since 11.0
- */
-export type SimpleWordformToKeySpec = (term: string) => string;
-/**
- * @public
- * Simplifies input text to facilitate finding entries within a lexical model's
- * lexicon, using the model's `applyCasing` function to assist in the keying process.
- * @since 14.0
- */
-export type CasedWordformToKeySpec = (term: string, applyCasing?: CasingFunction) => string;
-/**
- * @public
- * Simplifies input text to facilitate finding entries within a lexical model's
- * lexicon.
- */
-export type WordformToKeySpec = SimpleWordformToKeySpec | CasedWordformToKeySpec;
-/**
- * Override the default word breaking behaviour for some scripts.
- *
- * There is currently only one option:
- *
- * 'break-words-at-spaces'
- * : some South-East Asian scripts conventionally do not use space or any
- * explicit word boundary character to write word breaks. These scripts are:
- *
- *   * Burmese
- *   * Khmer
- *   * Thai
- *   * Laos
- *
- * (this list may be incomplete and extended in the future)
- *
- * For these scripts, the default word breaker breaks at **every**
- * letter/syllable/ideograph. However, in languages that use these scripts BUT
- * use spaces (or some other delimier) as word breaks, enable
- * 'break-words-at-spaces'; enabling 'break-words-at-spaces' prevents the word
- * breaker from making too many breaks in these scripts.
- *
- * @since 14.0
- */
-export type OverrideScriptDefaults = 'break-words-at-spaces';
-/**
- * @public
- * Base interface for a lexical model source definition
- */
-export interface LexicalModelSource extends LexicalModelDeclaration {
-    readonly sources: Array<string>;
-    /**
-     * The name of the type to instantiate (without parameters) as the base object for a custom predictive model.
-     */
-    readonly rootClass?: string;
-    /**
-     * When set to `true`, suggestions will attempt to match the case of the input text even if
-     * the lexicon entries use a different casing scheme due to search term keying effects.
-     * @since 14.0
-     */
-    readonly languageUsesCasing?: boolean;
-    /**
-     * Specifies the casing rules for a language.  Should implement three casing forms:
-     * - 'lower' -- a fully-lowercased version of the text appropriate for the language's
-     *   use of the writing system.
-     * - 'upper' -- a fully-uppercased version of the text
-     * - 'initial' -- a version preserving the input casing aside from the initial character,
-     *   which is uppercased (like with proper nouns and sentence-initial words in English
-     *   sentences.)
-     *
-     * This is only utilized if `languageUsesCasing` is defined and set to `true`.
-     * @since 14.0
-     */
-    readonly applyCasing?: CasingFunction;
-    /**
-     * Which word breaker to use. Choose from:
-     *
-     *  - 'default' -- breaks according to Unicode UAX #29 §4.1 Default Word
-     *    Boundary Specification, which works well for *most* languages.
-     *  - 'ascii' -- a very simple word breaker, for demonstration purposes only.
-     *  - word breaking function -- provide your own function that breaks words.
-     *  - class-based word-breaker - may be supported in the future.
-     */
-    readonly wordBreaker?: WordBreakerSpec | SimpleWordBreakerSpec;
-    /**
-     * How to simplify words, to convert them into simplified search keys
-     * This often involves removing accents, lowercasing, etc.
-     */
-    readonly searchTermToKey?: WordformToKeySpec;
-    /**
-     * Punctuation and spacing suggested by the model.
-     *
-     * @see LexicalModelPunctuation
-     */
-    readonly punctuation?: LexicalModelPunctuation;
-}
-export interface LexicalModelCompiled extends LexicalModelDeclaration {
-    readonly id: string;
-}
+/**
+ * Interfaces and constants used by the lexical model compiler. These target
+ * the LMLayer's internal worker code, so we provide those definitions too.
+ */
+/// <reference types="@keymanapp/models-types" />
+export interface LexicalModelDeclaration {
+    readonly format: 'trie-1.0' | 'fst-foma-1.0' | 'custom-1.0';
+}
+/**
+ * @public
+ * Keyman 14.0+ word breaker specification:
+ *
+ * Can support all old word breaking specification,
+ * but can also be extended with options.
+ *
+ * @since 14.0
+ */
+export interface WordBreakerSpec {
+    readonly use: SimpleWordBreakerSpec;
+    /**
+     * If present, joins words that were split by the word breaker
+     * together at the given strings. e.g.,
+     *
+     *    joinWordsAt: ['-'] // to keep hyphenated items together
+     *
+     * @since 14.0
+     */
+    readonly joinWordsAt?: string[];
+    /**
+     * Overrides word splitting behaviour for certain scripts.
+     * For example, specifing that spaces break words in certain South-East
+     * Asian scripts that otherwise do not use spaces.
+     *
+     * @since 14.0
+     */
+    readonly overrideScriptDefaults?: OverrideScriptDefaults;
+}
+/**
+ * @public
+ * Simplified word breaker specification.
+ *
+ * @since 11.0
+ */
+export type SimpleWordBreakerSpec = 'default' | 'ascii' | WordBreakingFunction;
+/**
+ * @public
+ * Simplifies input text to facilitate finding entries within a lexical model's
+ * lexicon.
+ * @since 11.0
+ */
+export type SimpleWordformToKeySpec = (term: string) => string;
+/**
+ * @public
+ * Simplifies input text to facilitate finding entries within a lexical model's
+ * lexicon, using the model's `applyCasing` function to assist in the keying process.
+ * @since 14.0
+ */
+export type CasedWordformToKeySpec = (term: string, applyCasing?: CasingFunction) => string;
+/**
+ * @public
+ * Simplifies input text to facilitate finding entries within a lexical model's
+ * lexicon.
+ */
+export type WordformToKeySpec = SimpleWordformToKeySpec | CasedWordformToKeySpec;
+/**
+ * Override the default word breaking behaviour for some scripts.
+ *
+ * There is currently only one option:
+ *
+ * 'break-words-at-spaces'
+ * : some South-East Asian scripts conventionally do not use space or any
+ * explicit word boundary character to write word breaks. These scripts are:
+ *
+ *   * Burmese
+ *   * Khmer
+ *   * Thai
+ *   * Laos
+ *
+ * (this list may be incomplete and extended in the future)
+ *
+ * For these scripts, the default word breaker breaks at **every**
+ * letter/syllable/ideograph. However, in languages that use these scripts BUT
+ * use spaces (or some other delimier) as word breaks, enable
+ * 'break-words-at-spaces'; enabling 'break-words-at-spaces' prevents the word
+ * breaker from making too many breaks in these scripts.
+ *
+ * @since 14.0
+ */
+export type OverrideScriptDefaults = 'break-words-at-spaces';
+/**
+ * @public
+ * Base interface for a lexical model source definition
+ */
+export interface LexicalModelSource extends LexicalModelDeclaration {
+    readonly sources: Array<string>;
+    /**
+     * The name of the type to instantiate (without parameters) as the base object for a custom predictive model.
+     */
+    readonly rootClass?: string;
+    /**
+     * When set to `true`, suggestions will attempt to match the case of the input text even if
+     * the lexicon entries use a different casing scheme due to search term keying effects.
+     * @since 14.0
+     */
+    readonly languageUsesCasing?: boolean;
+    /**
+     * Specifies the casing rules for a language.  Should implement three casing forms:
+     * - 'lower' -- a fully-lowercased version of the text appropriate for the language's
+     *   use of the writing system.
+     * - 'upper' -- a fully-uppercased version of the text
+     * - 'initial' -- a version preserving the input casing aside from the initial character,
+     *   which is uppercased (like with proper nouns and sentence-initial words in English
+     *   sentences.)
+     *
+     * This is only utilized if `languageUsesCasing` is defined and set to `true`.
+     * @since 14.0
+     */
+    readonly applyCasing?: CasingFunction;
+    /**
+     * Which word breaker to use. Choose from:
+     *
+     *  - 'default' -- breaks according to Unicode UAX #29 §4.1 Default Word
+     *    Boundary Specification, which works well for *most* languages.
+     *  - 'ascii' -- a very simple word breaker, for demonstration purposes only.
+     *  - word breaking function -- provide your own function that breaks words.
+     *  - class-based word-breaker - may be supported in the future.
+     */
+    readonly wordBreaker?: WordBreakerSpec | SimpleWordBreakerSpec;
+    /**
+     * How to simplify words, to convert them into simplified search keys
+     * This often involves removing accents, lowercasing, etc.
+     */
+    readonly searchTermToKey?: WordformToKeySpec;
+    /**
+     * Punctuation and spacing suggested by the model.
+     *
+     * @see LexicalModelPunctuation
+     */
+    readonly punctuation?: LexicalModelPunctuation;
+}
+export interface LexicalModelCompiled extends LexicalModelDeclaration {
+    readonly id: string;
+}
 //# sourceMappingURL=lexical-model.d.ts.map

package/build/src/lexical-model.js

@@ -1,6 +1,6 @@
-/**
- * Interfaces and constants used by the lexical model compiler. These target
- * the LMLayer's internal worker code, so we provide those definitions too.
- */
-export {};
+/**
+ * Interfaces and constants used by the lexical model compiler. These target
+ * the LMLayer's internal worker code, so we provide those definitions too.
+ */
+export {};
 //# sourceMappingURL=lexical-model.js.map

package/build/src/main.d.ts

@@ -1,4 +1,4 @@
-export { LexicalModelCompiler, LexicalModelCompilerResult, LexicalModelCompilerArtifacts } from './lexical-model-compiler.js';
-export { LexicalModelSource, WordformToKeySpec, SimpleWordformToKeySpec, CasedWordformToKeySpec, WordBreakerSpec, SimpleWordBreakerSpec, } from './lexical-model.js';
-export { ModelCompilerMessages } from './model-compiler-messages.js';
+export { LexicalModelCompiler, LexicalModelCompilerResult, LexicalModelCompilerArtifacts } from './lexical-model-compiler.js';
+export { LexicalModelSource, WordformToKeySpec, SimpleWordformToKeySpec, CasedWordformToKeySpec, WordBreakerSpec, SimpleWordBreakerSpec, } from './lexical-model.js';
+export { ModelCompilerMessages } from './model-compiler-messages.js';
 //# sourceMappingURL=main.d.ts.map

package/build/src/main.js

@@ -1,3 +1,3 @@
-export { LexicalModelCompiler } from './lexical-model-compiler.js';
-export { ModelCompilerMessages } from './model-compiler-messages.js';
+export { LexicalModelCompiler } from './lexical-model-compiler.js';
+export { ModelCompilerMessages } from './model-compiler-messages.js';
 //# sourceMappingURL=main.js.map

package/build/src/model-compiler-messages.d.ts

@@ -1,57 +1,57 @@
-import { CompilerEvent } from "@keymanapp/common-types";
-/**
- * @internal
- */
-export declare class ModelCompilerMessageContext {
-    static line: number;
-    static filename: string;
-}
-/**
- * @internal
- */
-export declare class ModelCompilerMessages {
-    static FATAL_UnexpectedException: number;
-    static Fatal_UnexpectedException: (o: {
-        e: any;
-    }) => CompilerEvent;
-    static HINT_MixedNormalizationForms: number;
-    static Hint_MixedNormalizationForms: (o: {
-        wordform: string;
-    }) => CompilerEvent;
-    static HINT_DuplicateWordInSameFile: number;
-    static Hint_DuplicateWordInSameFile: (o: {
-        wordform: string;
-    }) => CompilerEvent;
-    static ERROR_UnimplementedModelFormat: number;
-    static Error_UnimplementedModelFormat: (o: {
-        format: string;
-    }) => CompilerEvent;
-    static ERROR_UnknownModelFormat: number;
-    static Error_UnknownModelFormat: (o: {
-        format: string;
-    }) => CompilerEvent;
-    static ERROR_NoDefaultExport: number;
-    static Error_NoDefaultExport: () => CompilerEvent;
-    static ERROR_SearchTermToKeyMustBeExplicitlySpecified: number;
-    static Error_SearchTermToKeyMustBeExplicitlySpecified: () => CompilerEvent;
-    static ERROR_UTF16BEUnsupported: number;
-    static Error_UTF16BEUnsupported: () => CompilerEvent;
-    static ERROR_UnknownWordBreaker: number;
-    static Error_UnknownWordBreaker: (o: {
-        spec: string;
-    }) => CompilerEvent;
-    static ERROR_UnsupportedScriptOverride: number;
-    static Error_UnsupportedScriptOverride: (o: {
-        option: string;
-    }) => CompilerEvent;
-}
-/**
- * A ModelCompilerError should be thrown when an unrecoverable error occurs that
- * would block further compilation. It will be caught in the top-most compiler
- * API endpoint and converted into a callback message.
- */
-export declare class ModelCompilerError extends Error {
-    event: CompilerEvent;
-    constructor(event: CompilerEvent);
-}
+import { CompilerEvent } from "@keymanapp/common-types";
+/**
+ * @internal
+ */
+export declare class ModelCompilerMessageContext {
+    static line: number;
+    static filename: string;
+}
+/**
+ * @internal
+ */
+export declare class ModelCompilerMessages {
+    static FATAL_UnexpectedException: number;
+    static Fatal_UnexpectedException: (o: {
+        e: any;
+    }) => CompilerEvent;
+    static HINT_MixedNormalizationForms: number;
+    static Hint_MixedNormalizationForms: (o: {
+        wordform: string;
+    }) => CompilerEvent;
+    static HINT_DuplicateWordInSameFile: number;
+    static Hint_DuplicateWordInSameFile: (o: {
+        wordform: string;
+    }) => CompilerEvent;
+    static ERROR_UnimplementedModelFormat: number;
+    static Error_UnimplementedModelFormat: (o: {
+        format: string;
+    }) => CompilerEvent;
+    static ERROR_UnknownModelFormat: number;
+    static Error_UnknownModelFormat: (o: {
+        format: string;
+    }) => CompilerEvent;
+    static ERROR_NoDefaultExport: number;
+    static Error_NoDefaultExport: () => CompilerEvent;
+    static ERROR_SearchTermToKeyMustBeExplicitlySpecified: number;
+    static Error_SearchTermToKeyMustBeExplicitlySpecified: () => CompilerEvent;
+    static ERROR_UTF16BEUnsupported: number;
+    static Error_UTF16BEUnsupported: () => CompilerEvent;
+    static ERROR_UnknownWordBreaker: number;
+    static Error_UnknownWordBreaker: (o: {
+        spec: string;
+    }) => CompilerEvent;
+    static ERROR_UnsupportedScriptOverride: number;
+    static Error_UnsupportedScriptOverride: (o: {
+        option: string;
+    }) => CompilerEvent;
+}
+/**
+ * A ModelCompilerError should be thrown when an unrecoverable error occurs that
+ * would block further compilation. It will be caught in the top-most compiler
+ * API endpoint and converted into a callback message.
+ */
+export declare class ModelCompilerError extends Error {
+    event: CompilerEvent;
+    constructor(event: CompilerEvent);
+}
 //# sourceMappingURL=model-compiler-messages.d.ts.map

package/build/src/model-compiler-messages.js

@@ -1,64 +1,64 @@
-import { CompilerErrorNamespace, CompilerErrorSeverity, CompilerMessageSpec, CompilerMessageDef as def, CompilerMessageSpecWithException } from "@keymanapp/common-types";
-const Namespace = CompilerErrorNamespace.ModelCompiler;
-// const SevInfo = CompilerErrorSeverity.Info | Namespace;
-const SevHint = CompilerErrorSeverity.Hint | Namespace;
-// const SevWarn = CompilerErrorSeverity.Warn | Namespace;
-const SevError = CompilerErrorSeverity.Error | Namespace;
-const SevFatal = CompilerErrorSeverity.Fatal | Namespace;
-const m = (code, message) => ({
-    ...CompilerMessageSpec(code, message),
-    line: ModelCompilerMessageContext.line,
-    filename: ModelCompilerMessageContext.filename,
-});
-const m_e = (code, message, exceptionVar) => ({
-    ...CompilerMessageSpecWithException(code, message, exceptionVar),
-    line: ModelCompilerMessageContext.line,
-    filename: ModelCompilerMessageContext.filename,
-});
-/**
- * @internal
- */
-export class ModelCompilerMessageContext {
-    // Context added to all messages
-    static line;
-    static filename;
-}
-/**
- * @internal
- */
-export class ModelCompilerMessages {
-    static FATAL_UnexpectedException = SevFatal | 0x0001;
-    static Fatal_UnexpectedException = (o) => m_e(this.FATAL_UnexpectedException, null, o.e ?? 'unknown error');
-    static HINT_MixedNormalizationForms = SevHint | 0x0002;
-    static Hint_MixedNormalizationForms = (o) => m(this.HINT_MixedNormalizationForms, `“${def(o.wordform)}” is not in Unicode NFC. Automatically converting to NFC.`);
-    static HINT_DuplicateWordInSameFile = SevHint | 0x0003;
-    static Hint_DuplicateWordInSameFile = (o) => m(this.HINT_DuplicateWordInSameFile, `duplicate word “${def(o.wordform)}” found in same file; summing counts`);
-    static ERROR_UnimplementedModelFormat = SevError | 0x0004;
-    static Error_UnimplementedModelFormat = (o) => m(this.ERROR_UnimplementedModelFormat, `Unimplemented model format: ${def(o.format)}`);
-    static ERROR_UnknownModelFormat = SevError | 0x0005;
-    static Error_UnknownModelFormat = (o) => m(this.ERROR_UnknownModelFormat, `Unimplemented model format: ${def(o.format)}`);
-    static ERROR_NoDefaultExport = SevError | 0x0006;
-    static Error_NoDefaultExport = () => m(this.ERROR_NoDefaultExport, `Model source does have a default export. Did you remember to write \`export default source;\`?`);
-    static ERROR_SearchTermToKeyMustBeExplicitlySpecified = SevError | 0x0007;
-    static Error_SearchTermToKeyMustBeExplicitlySpecified = () => m(this.ERROR_SearchTermToKeyMustBeExplicitlySpecified, "searchTermToKey must be explicitly specified");
-    static ERROR_UTF16BEUnsupported = SevError | 0x0008;
-    static Error_UTF16BEUnsupported = () => m(this.ERROR_UTF16BEUnsupported, 'UTF-16BE is unsupported');
-    static ERROR_UnknownWordBreaker = SevError | 0x0009;
-    static Error_UnknownWordBreaker = (o) => m(this.ERROR_UnknownWordBreaker, `Unknown word breaker: ${def(o.spec)}`);
-    static ERROR_UnsupportedScriptOverride = SevError | 0x000A;
-    static Error_UnsupportedScriptOverride = (o) => m(this.ERROR_UnsupportedScriptOverride, `Unsupported script override: ${def(o.option)}`);
-}
-;
-/**
- * A ModelCompilerError should be thrown when an unrecoverable error occurs that
- * would block further compilation. It will be caught in the top-most compiler
- * API endpoint and converted into a callback message.
- */
-export class ModelCompilerError extends Error {
-    event;
-    constructor(event) {
-        super(event.message);
-        this.event = event;
-    }
-}
+import { CompilerErrorNamespace, CompilerErrorSeverity, CompilerMessageSpec, CompilerMessageDef as def, CompilerMessageSpecWithException } from "@keymanapp/common-types";
+const Namespace = CompilerErrorNamespace.ModelCompiler;
+// const SevInfo = CompilerErrorSeverity.Info | Namespace;
+const SevHint = CompilerErrorSeverity.Hint | Namespace;
+// const SevWarn = CompilerErrorSeverity.Warn | Namespace;
+const SevError = CompilerErrorSeverity.Error | Namespace;
+const SevFatal = CompilerErrorSeverity.Fatal | Namespace;
+const m = (code, message) => ({
+    ...CompilerMessageSpec(code, message),
+    line: ModelCompilerMessageContext.line,
+    filename: ModelCompilerMessageContext.filename,
+});
+const m_e = (code, message, exceptionVar) => ({
+    ...CompilerMessageSpecWithException(code, message, exceptionVar),
+    line: ModelCompilerMessageContext.line,
+    filename: ModelCompilerMessageContext.filename,
+});
+/**
+ * @internal
+ */
+export class ModelCompilerMessageContext {
+    // Context added to all messages
+    static line;
+    static filename;
+}
+/**
+ * @internal
+ */
+export class ModelCompilerMessages {
+    static FATAL_UnexpectedException = SevFatal | 0x0001;
+    static Fatal_UnexpectedException = (o) => m_e(this.FATAL_UnexpectedException, null, o.e ?? 'unknown error');
+    static HINT_MixedNormalizationForms = SevHint | 0x0002;
+    static Hint_MixedNormalizationForms = (o) => m(this.HINT_MixedNormalizationForms, `“${def(o.wordform)}” is not in Unicode NFC. Automatically converting to NFC.`);
+    static HINT_DuplicateWordInSameFile = SevHint | 0x0003;
+    static Hint_DuplicateWordInSameFile = (o) => m(this.HINT_DuplicateWordInSameFile, `duplicate word “${def(o.wordform)}” found in same file; summing counts`);
+    static ERROR_UnimplementedModelFormat = SevError | 0x0004;
+    static Error_UnimplementedModelFormat = (o) => m(this.ERROR_UnimplementedModelFormat, `Unimplemented model format: ${def(o.format)}`);
+    static ERROR_UnknownModelFormat = SevError | 0x0005;
+    static Error_UnknownModelFormat = (o) => m(this.ERROR_UnknownModelFormat, `Unimplemented model format: ${def(o.format)}`);
+    static ERROR_NoDefaultExport = SevError | 0x0006;
+    static Error_NoDefaultExport = () => m(this.ERROR_NoDefaultExport, `Model source does have a default export. Did you remember to write \`export default source;\`?`);
+    static ERROR_SearchTermToKeyMustBeExplicitlySpecified = SevError | 0x0007;
+    static Error_SearchTermToKeyMustBeExplicitlySpecified = () => m(this.ERROR_SearchTermToKeyMustBeExplicitlySpecified, "searchTermToKey must be explicitly specified");
+    static ERROR_UTF16BEUnsupported = SevError | 0x0008;
+    static Error_UTF16BEUnsupported = () => m(this.ERROR_UTF16BEUnsupported, 'UTF-16BE is unsupported');
+    static ERROR_UnknownWordBreaker = SevError | 0x0009;
+    static Error_UnknownWordBreaker = (o) => m(this.ERROR_UnknownWordBreaker, `Unknown word breaker: ${def(o.spec)}`);
+    static ERROR_UnsupportedScriptOverride = SevError | 0x000A;
+    static Error_UnsupportedScriptOverride = (o) => m(this.ERROR_UnsupportedScriptOverride, `Unsupported script override: ${def(o.option)}`);
+}
+;
+/**
+ * A ModelCompilerError should be thrown when an unrecoverable error occurs that
+ * would block further compilation. It will be caught in the top-most compiler
+ * API endpoint and converted into a callback message.
+ */
+export class ModelCompilerError extends Error {
+    event;
+    constructor(event) {
+        super(event.message);
+        this.event = event;
+    }
+}
 //# sourceMappingURL=model-compiler-messages.js.map