@keymanapp/kmc-model 17.0.85-alpha

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

@@ -0,0 +1,56 @@
+/// <reference types="@keymanapp/models-types" />
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export declare function defaultSearchTermToKey(wordform: string): string;
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export declare function defaultCasedSearchTermToKey(wordform: string, applyCasing: CasingFunction): string;
+/**
+ * Specifies default casing behavior for lexical models when `languageUsesCasing` is
+ * set to true.
+ * @param casing One of 'lower' (lowercased), 'upper' (uppercased), or 'initial'.
+ *
+ * 'initial' is designed to cover cases like sentence-initial & proper noun capitalization in English.
+ * This may be overwritten as appropriate in model-specific implementations.
+ * @param text The text to be modified.
+ */
+export declare function defaultApplyCasing(casing: CasingForm, text: string): string;
+//# sourceMappingURL=model-defaults.d.ts.map

package/build/src/model-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-defaults.d.ts","sourceRoot":"","sources":["../../src/model-defaults.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAW/D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,GAAG,MAAM,CAiBjG;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA2B3E"}

package/build/src/model-defaults.js

@@ -0,0 +1,106 @@
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export function defaultSearchTermToKey(wordform) {
+    return wordform
+        .normalize('NFKD')
+        // Remove any combining diacritics (if input is in NFKD)
+        .replace(/[\u0300-\u036F]/g, '')
+        // Replace directional quotation marks with plain apostrophes
+        .replace(/‘/, "'")
+        .replace(/’/, "'")
+        // Also double-quote marks.
+        .replace(/“/, '"')
+        .replace(/”/, '"');
+}
+/**
+ * Converts wordforms into an indexable form. It does this by
+ * normalizing the letter case of characters INDIVIDUALLY (to disregard
+ * context-sensitive case transformations), normalizing to NFKD form,
+ * and removing common diacritical marks.
+ *
+ * This is a very speculative implementation, that might work with
+ * your language. We don't guarantee that this will be perfect for your
+ * language, but it's a start.
+ *
+ * This uses String.prototype.normalize() to convert normalize into NFKD.
+ * NFKD neutralizes some funky distinctions, e.g., ꬲ, ｅ, e should all be the
+ * same character; plus, it's an easy way to separate a Latin character from
+ * its diacritics; Even then, orthographies regularly use code points
+ * that, under NFKD normalization, do NOT decompose appropriately for your
+ * language (e.g., SENĆOŦEN, Plains Cree in syllabics).
+ *
+ * Use this in early iterations of the model. For a production lexical model,
+ * you will probably write/generate your own key function, tailored to your
+ * language. There is a chance the default will work properly out of the box.
+ */
+export function defaultCasedSearchTermToKey(wordform, applyCasing) {
+    // While this is a bit WET, as the basic `defaultSearchTermToKey` exists and performs some of
+    // the same functions, repetition is the easiest way to allow the function to be safely compiled
+    // with ease by use of `.toString()`.
+    return Array.from(wordform
+        .normalize('NFKD')
+        // Remove any combining diacritics (if input is in NFKD)
+        .replace(/[\u0300-\u036F]/g, '')) // end of `Array.from`
+        .map(function (c) { return applyCasing('lower', c); })
+        .join('')
+        // Replace directional quotation marks with plain apostrophes
+        .replace(/‘/, "'")
+        .replace(/’/, "'")
+        // Also double-quote marks.
+        .replace(/“/, '"')
+        .replace(/”/, '"');
+}
+/**
+ * Specifies default casing behavior for lexical models when `languageUsesCasing` is
+ * set to true.
+ * @param casing One of 'lower' (lowercased), 'upper' (uppercased), or 'initial'.
+ *
+ * 'initial' is designed to cover cases like sentence-initial & proper noun capitalization in English.
+ * This may be overwritten as appropriate in model-specific implementations.
+ * @param text The text to be modified.
+ */
+export function defaultApplyCasing(casing, text) {
+    switch (casing) {
+        case 'lower':
+            return text.toLowerCase();
+        case 'upper':
+            return text.toUpperCase();
+        case 'initial':
+            var headCode = text.charCodeAt(0);
+            // The length of the first code unit, as measured in code points.
+            var headUnitLength = 1;
+            // Is the first character a high surrogate, indicating possible use of UTF-16
+            // surrogate pairs?  Also, is the string long enough for there to BE a pair?
+            if (text.length > 1 && headCode >= 0xD800 && headCode <= 0xDBFF) {
+                // It's possible, so now we check for low surrogates.
+                var lowSurrogateCode = text.charCodeAt(1);
+                if (lowSurrogateCode >= 0xDC00 && lowSurrogateCode <= 0xDFFF) {
+                    // We have a surrogate pair; this pair is the 'first' character.
+                    headUnitLength++;
+                }
+            }
+            // Capitalizes the first code unit of the string, leaving the rest intact.
+            return text.substring(0, headUnitLength).toUpperCase() // head - uppercased
+                .concat(text.substring(headUnitLength)); // tail - lowercased
+    }
+}
+//# sourceMappingURL=model-defaults.js.map

package/build/src/model-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-defaults.js","sourceRoot":"","sources":["../../src/model-defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAAgB;IACrD,OAAO,QAAQ;SACV,SAAS,CAAC,MAAM,CAAC;QAClB,wDAAwD;SACvD,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC;QAChC,6DAA6D;SAC5D,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;SACjB,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;QAClB,2BAA2B;SAC1B,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;SACjB,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,2BAA2B,CAAC,QAAgB,EAAE,WAA2B;IACvF,6FAA6F;IAC7F,gGAAgG;IAChG,qCAAqC;IACrC,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ;SACnB,SAAS,CAAC,MAAM,CAAC;QAClB,wDAAwD;SACvD,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CACjC,CAAC,sBAAsB;SACvB,GAAG,CAAC,UAAS,CAAC,IAAI,OAAO,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA,CAAA,CAAC,CAAC;SAClD,IAAI,CAAC,EAAE,CAAC;QACT,6DAA6D;SAC5D,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;SACjB,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;QAClB,2BAA2B;SAC1B,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC;SACjB,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAkB,EAAE,IAAY;IACjE,QAAO,MAAM,EAAE;QACb,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAC5B,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAC5B,KAAK,SAAS;YACZ,IAAI,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAClC,iEAAiE;YACjE,IAAI,cAAc,GAAG,CAAC,CAAC;YAEvB,6EAA6E;YAC7E,4EAA4E;YAC5E,IAAG,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,EAAE;gBAC9D,qDAAqD;gBACrD,IAAI,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;gBAE1C,IAAG,gBAAgB,IAAI,MAAM,IAAI,gBAAgB,IAAI,MAAM,EAAE;oBAC3D,gEAAgE;oBAChE,cAAc,EAAE,CAAC;iBAClB;aACF;YAED,0EAA0E;YAC1E,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC,oBAAoB;iBACnE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAQ,oBAAoB;KAC9E;AACH,CAAC"}

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

@@ -0,0 +1,71 @@
+/// <reference types="@keymanapp/models-types" />
+import { LexicalModelSource, WordformToKeySpec } from "./lexical-model.js";
+/**
+ * Processes certain defined model behaviors in such a way that the needed closures
+ * may be safely compiled to a JS file and loaded within the LMLayer.
+ *
+ * This is accomplished by writing out a 'pseudoclosure' within the model's IIFE,
+ * then used to build _actual_ closures at LMLayer load time.  This 'pseudoclosure'
+ * will very closely match the organizational patterns of this class in order to
+ * facilitate the maintenance of this approach.
+ */
+export declare class ModelDefinitions {
+    static readonly COMPILED_NAME = "definitions";
+    /**
+     * A closure fully implementing the model's defined `applyCasing` behavior with
+     * the function parameter preset to the version-appropriate default.
+     * `defaults.applyCasing` is captured as part of the closure.
+     *
+     * During compilation of some models (such as Trie-based wordlist templated models),
+     * this closure will be directly used as part of searchTermToKey.
+     *
+     * In compiled code, this will instead be defined in-line as an autogenerated closure
+     * using the other properties of the pseudoclosure.
+     */
+    applyCasing?: CasingFunction;
+    /**
+     * A closure fully implementing the model's defined `searchTermToKey` behavior
+     * based upon the model's specified casing rules.  The `applyCasing` closure is
+     * itself captured within this closure.
+     *
+     * During compilation of some models (such as Trie-based wordlist templated models),
+     * this closure will be directly utilized when compiling the lexicon.
+     *
+     * In compiled code, this will instead be defined in-line as an autogenerated closure
+     * using the other properties of the pseudoclosure.
+     */
+    searchTermToKey?: WordformToKeySpec;
+    /**
+     * Contains embedded 'default' implementations that may be needed for
+     * closures in the compiled version, annotated with the current version
+     * of Developer.
+     */
+    private defaults;
+    /**
+     * Contains the model-specific definitions specified in the model's source.
+     *
+     * These definitions may expect `defaults.applyCasing` as a parameter in
+     * their final closures.
+     */
+    private model;
+    constructor(modelSource: LexicalModelSource);
+    /**
+     * Writes out a compiled JS version of the pseudoclosure, preserving all function
+     * implementations.
+     *
+     * This should be written to the file within the same IIFE as the model but BEFORE
+     * the model itself, as the model will need to refer to the definitions herein.
+     */
+    compileDefinitions(): string;
+    /**
+     * Compiles the model-options entry for `searchTermToKey` in reference to the
+     * compiled pseudoclosure.
+     */
+    compileSearchTermToKey(): string;
+    /**
+     * Compiles the model-options entry for `applyCasing` in reference to the
+     * compiled pseudoclosure.
+     */
+    compileApplyCasing(): string;
+}
+//# sourceMappingURL=model-definitions.d.ts.map

package/build/src/model-definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-definitions.d.ts","sourceRoot":"","sources":["../../src/model-definitions.ts"],"names":[],"mappings":";AAMA,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE3E;;;;;;;;GAQG;AACH,qBAAa,gBAAgB;IAC3B,MAAM,CAAC,QAAQ,CAAC,aAAa,iBAAiB;IAC9C;;;;;;;;;;OAUG;IACH,WAAW,CAAC,EAAE,cAAc,CAAC;IAE7B;;;;;;;;;;OAUG;IACH,eAAe,CAAC,EAAE,iBAAiB,CAAC;IAEpC;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAKd;IAEF;;;;;OAKG;IACH,OAAO,CAAC,KAAK,CAGN;gBAEK,WAAW,EAAE,kBAAkB;IAsD3C;;;;;;OAMG;IACH,kBAAkB,IAAI,MAAM;IAuE5B;;;OAGG;IACH,sBAAsB,IAAI,MAAM;IAMhC;;;OAGG;IACH,kBAAkB,IAAI,MAAM;CAI7B"}

package/build/src/model-definitions.js

@@ -0,0 +1,189 @@
+import { defaultApplyCasing, defaultCasedSearchTermToKey, defaultSearchTermToKey } from "./model-defaults.js";
+import KEYMAN_VERSION from "@keymanapp/keyman-version";
+/**
+ * Processes certain defined model behaviors in such a way that the needed closures
+ * may be safely compiled to a JS file and loaded within the LMLayer.
+ *
+ * This is accomplished by writing out a 'pseudoclosure' within the model's IIFE,
+ * then used to build _actual_ closures at LMLayer load time.  This 'pseudoclosure'
+ * will very closely match the organizational patterns of this class in order to
+ * facilitate the maintenance of this approach.
+ */
+export class ModelDefinitions {
+    static COMPILED_NAME = 'definitions';
+    /**
+     * A closure fully implementing the model's defined `applyCasing` behavior with
+     * the function parameter preset to the version-appropriate default.
+     * `defaults.applyCasing` is captured as part of the closure.
+     *
+     * During compilation of some models (such as Trie-based wordlist templated models),
+     * this closure will be directly used as part of searchTermToKey.
+     *
+     * In compiled code, this will instead be defined in-line as an autogenerated closure
+     * using the other properties of the pseudoclosure.
+     */
+    applyCasing;
+    /**
+     * A closure fully implementing the model's defined `searchTermToKey` behavior
+     * based upon the model's specified casing rules.  The `applyCasing` closure is
+     * itself captured within this closure.
+     *
+     * During compilation of some models (such as Trie-based wordlist templated models),
+     * this closure will be directly utilized when compiling the lexicon.
+     *
+     * In compiled code, this will instead be defined in-line as an autogenerated closure
+     * using the other properties of the pseudoclosure.
+     */
+    searchTermToKey;
+    /**
+     * Contains embedded 'default' implementations that may be needed for
+     * closures in the compiled version, annotated with the current version
+     * of Developer.
+     */
+    defaults = {
+        version: KEYMAN_VERSION.VERSION_WITH_TAG
+    };
+    /**
+     * Contains the model-specific definitions specified in the model's source.
+     *
+     * These definitions may expect `defaults.applyCasing` as a parameter in
+     * their final closures.
+     */
+    model = {};
+    constructor(modelSource) {
+        // Determine the model's `applyCasing` function / implementation.
+        if (modelSource.languageUsesCasing) {
+            this.defaults.applyCasing = defaultApplyCasing;
+            if (modelSource.applyCasing) {
+                this.model.applyCasing = modelSource.applyCasing;
+                let _this = this;
+                // Since the defined casing function may expect to take our default implementation
+                // as a parameter, we can define the full implementation via closure capture.
+                this.applyCasing = function (casing, text) {
+                    return _this.model.applyCasing(casing, text, _this.defaults.applyCasing);
+                };
+            }
+            else {
+                this.applyCasing = this.defaults.applyCasing;
+            }
+        }
+        // START: if(model type uses keying)...
+        // Use the default search term to key function, if left unspecified.
+        if (modelSource.searchTermToKey) {
+            this.model.searchTermToKey = modelSource.searchTermToKey;
+        }
+        else if (modelSource.languageUsesCasing) {
+            // applyCasing is defined here.
+            // Unfortunately, this only works conceptually.  .toString on a closure
+            // does not result in proper compilation.
+            this.model.searchTermToKey = defaultCasedSearchTermToKey;
+        }
+        else if (modelSource.languageUsesCasing == false) {
+            this.model.searchTermToKey = defaultSearchTermToKey;
+        }
+        else {
+            // If languageUsesCasing is not defined, then we use pre-14.0 behavior,
+            // which expects a lowercased default.
+            this.model.searchTermToKey = defaultCasedSearchTermToKey;
+            // Needed to provide pre-14.0 default lowercasing as part of the
+            // search-term keying operation.
+            this.defaults.applyCasing = defaultApplyCasing;
+            // For compile-time use.
+            this.applyCasing = this.defaults.applyCasing;
+        }
+        let _this = this;
+        this.searchTermToKey = function (text) {
+            return _this.model.searchTermToKey(text, _this.applyCasing);
+        };
+        // END: if(model type uses keying)...
+    }
+    // ------------ end:  common compile-time / run-time code ---------------
+    // START:  handwritten compilation code (to accomplish the 'common' pattern defined above)
+    /**
+     * Writes out a compiled JS version of the pseudoclosure, preserving all function
+     * implementations.
+     *
+     * This should be written to the file within the same IIFE as the model but BEFORE
+     * the model itself, as the model will need to refer to the definitions herein.
+     */
+    compileDefinitions() {
+        let defn = '';
+        defn += `var ${PSEUDOCLOSURE} = {\n`;
+        // ----------------------
+        // START - the 'defaults', which are common within the same Developer version.
+        defn += `  defaults: {\n    version: "${this.defaults.version}"`;
+        // Only write out `applyCasing` if and when it is needed.
+        if (this.defaults.applyCasing) {
+            defn += `,\n    applyCasing: ${this.defaults.applyCasing.toString()}`;
+        }
+        // Finalizes `defaults`
+        defn += `\n  },`;
+        // END - the 'defaults'
+        // ----------------------
+        // START - model-specific definitions (when defined)
+        defn += `  model: {\n`;
+        defn += `    searchTermToKey: ${this.model.searchTermToKey.toString()}`;
+        if (this.model.applyCasing) {
+            defn += `,\n    applyCasing: ${this.model.applyCasing.toString()}`;
+        }
+        defn += `\n  }`;
+        // END - model-specific definitions
+        // ----------------------
+        // START - compiled closures.  Given those definitions, write out the
+        // pseudoclosure-referencing closures for the needed methods.
+        // We should be able to define these closures in-line with the object's
+        // initialization.  Worst-case, we simply move the definitions outside
+        // of the pseudoclosure's init and THEN define/assign these closures to
+        // the object, as references will be available then for sure.
+        if (this.model.applyCasing) {
+            // A major potential issue:  if the user wants to call extra custom functions that they've written.
+            //
+            // `applyCasing` recursion SHOULD be fine if they write `this.applyCasing() and forward all arguments
+            // appropriately, as it will be known as `applyCasing` on the runtime `this` (`model`) object.
+            //
+            // Similarly, as long as any helper functions are similarly compiled and stored as part of `model`,
+            // they should be accessible too.  The issue would be to actually allow use of extra custom funcs
+            // and include them as part of this object as part of compilation.
+            defn += `,\n  applyCasing: function(caseToApply, text) {
+        return ${PSEUDOCLOSURE}.model.applyCasing(caseToApply, text, ${PSEUDOCLOSURE}.defaults.applyCasing);
+      }`;
+        }
+        else if (this.defaults.applyCasing) {
+            // We can't directly assign from `.defaults`, as initialization-time field reads
+            // are not permitted within JS.  Function references, however, are valid.
+            defn += `,\n  applyCasing: function(caseToApply, text) {
+        return ${PSEUDOCLOSURE}.defaults.applyCasing(caseToApply, text);
+      }`;
+        }
+        // if(this.searchTermToKey) {
+        defn += `,\n  searchTermToKey: function(text) {
+      return ${PSEUDOCLOSURE}.model.searchTermToKey(text, ${PSEUDOCLOSURE}.applyCasing);
+    }`;
+        // }
+        // END - compiled closures.
+        // ----------------------
+        // Finalize the definition of... `definitions`.
+        defn += `\n};\n`;
+        return defn;
+    }
+    /**
+     * Compiles the model-options entry for `searchTermToKey` in reference to the
+     * compiled pseudoclosure.
+     */
+    compileSearchTermToKey() {
+        // Simply point the model to the constructed closure defined by `compilePseudoclosure`.
+        // See "START - compiled closures" section.
+        return `${PSEUDOCLOSURE}.searchTermToKey`;
+    }
+    /**
+     * Compiles the model-options entry for `applyCasing` in reference to the
+     * compiled pseudoclosure.
+     */
+    compileApplyCasing() {
+        // See "START - compiled closures" section.
+        return `${PSEUDOCLOSURE}.applyCasing`;
+    }
+}
+// Because it references the class field, this line must come afterward.
+const PSEUDOCLOSURE = ModelDefinitions.COMPILED_NAME;
+//# sourceMappingURL=model-definitions.js.map

package/build/src/model-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-definitions.js","sourceRoot":"","sources":["../../src/model-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAClB,2BAA2B,EAC3B,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAEpC,OAAO,cAAc,MAAM,2BAA2B,CAAC;AAGvD;;;;;;;;GAQG;AACH,MAAM,OAAO,gBAAgB;IAC3B,MAAM,CAAU,aAAa,GAAG,aAAa,CAAC;IAC9C;;;;;;;;;;OAUG;IACH,WAAW,CAAkB;IAE7B;;;;;;;;;;OAUG;IACH,eAAe,CAAqB;IAEpC;;;;OAIG;IACK,QAAQ,GAGZ;QACF,OAAO,EAAE,cAAc,CAAC,gBAAgB;KACzC,CAAC;IAEF;;;;;OAKG;IACK,KAAK,GAGT,EAAE,CAAC;IAEP,YAAY,WAA+B;QACzC,iEAAiE;QACjE,IAAG,WAAW,CAAC,kBAAkB,EAAE;YACjC,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,kBAAkB,CAAC;YAE/C,IAAG,WAAW,CAAC,WAAW,EAAE;gBAC1B,IAAI,CAAC,KAAK,CAAC,WAAW,GAAG,WAAW,CAAC,WAAW,CAAC;gBACjD,IAAI,KAAK,GAAG,IAAI,CAAC;gBAEjB,kFAAkF;gBAClF,6EAA6E;gBAC7E,IAAI,CAAC,WAAW,GAAG,UAAS,MAAkB,EAAE,IAAY;oBAC1D,OAAO,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;gBAC3E,CAAC,CAAC;aACH;iBAAM;gBACL,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;aAC9C;SACF;QAED,uCAAuC;QAEvC,oEAAoE;QACpE,IAAG,WAAW,CAAC,eAAe,EAAE;YAC9B,IAAI,CAAC,KAAK,CAAC,eAAe,GAAG,WAAW,CAAC,eAAe,CAAC;SAC1D;aAAM,IAAG,WAAW,CAAC,kBAAkB,EAAE;YACxC,+BAA+B;YAC/B,uEAAuE;YACvE,yCAAyC;YACzC,IAAI,CAAC,KAAK,CAAC,eAAe,GAAG,2BAA2B,CAAC;SAC1D;aAAM,IAAG,WAAW,CAAC,kBAAkB,IAAI,KAAK,EAAE;YACjD,IAAI,CAAC,KAAK,CAAC,eAAe,GAAG,sBAAsB,CAAC;SACrD;aAAM;YACL,uEAAuE;YACvE,sCAAsC;YACtC,IAAI,CAAC,KAAK,CAAC,eAAe,GAAG,2BAA2B,CAAC;YACzD,gEAAgE;YAChE,gCAAgC;YAChC,IAAI,CAAC,QAAQ,CAAC,WAAW,GAAG,kBAAkB,CAAC;YAC/C,wBAAwB;YACxB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;SAC9C;QAED,IAAI,KAAK,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,eAAe,GAAG,UAAS,IAAY;YAC1C,OAAO,KAAK,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QAC9D,CAAC,CAAA;QAED,qCAAqC;IACvC,CAAC;IAED,yEAAyE;IAEzE,0FAA0F;IAE1F;;;;;;OAMG;IACH,kBAAkB;QAChB,IAAI,IAAI,GAAW,EAAE,CAAC;QACtB,IAAI,IAAI,OAAO,aAAa,QAAQ,CAAA;QAEpC,yBAAyB;QACzB,8EAA8E;QAC9E,IAAI,IAAI,gCAAgC,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,CAAC;QAEjE,yDAAyD;QACzD,IAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE;YAC5B,IAAI,IAAI,uBAAuB,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC;SACvE;QAED,uBAAuB;QACvB,IAAI,IAAI,QAAQ,CAAC;QACjB,uBAAuB;QAEvB,yBAAyB;QACzB,oDAAoD;QACpD,IAAI,IAAI,cAAc,CAAC;QACvB,IAAI,IAAI,wBAAwB,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,CAAC;QAExE,IAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;YACzB,IAAI,IAAI,uBAAuB,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,EAAE,CAAC;SACpE;QACD,IAAI,IAAI,OAAO,CAAA;QACf,mCAAmC;QAEnC,yBAAyB;QACzB,qEAAqE;QACrE,6DAA6D;QAE7D,uEAAuE;QACvE,sEAAsE;QACtE,uEAAuE;QACvE,6DAA6D;QAC7D,IAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;YACzB,mGAAmG;YACnG,EAAE;YACF,qGAAqG;YACrG,8FAA8F;YAC9F,EAAE;YACF,mGAAmG;YACnG,iGAAiG;YACjG,kEAAkE;YAClE,IAAI,IAAI;iBACG,aAAa,yCAAyC,aAAa;QAC5E,CAAC;SACJ;aAAM,IAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE;YACnC,gFAAgF;YAChF,yEAAyE;YACzE,IAAI,IAAI;iBACG,aAAa;QACtB,CAAC;SACJ;QAED,6BAA6B;QAC7B,IAAI,IAAI;eACG,aAAa,gCAAgC,aAAa;MACnE,CAAC;QACH,IAAI;QAEJ,2BAA2B;QAE3B,yBAAyB;QACzB,+CAA+C;QAC/C,IAAI,IAAI,QAAQ,CAAC;QAEjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,sBAAsB;QACpB,uFAAuF;QACvF,2CAA2C;QAC3C,OAAO,GAAG,aAAa,kBAAkB,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,kBAAkB;QAChB,2CAA2C;QAC3C,OAAO,GAAG,aAAa,cAAc,CAAC;IACxC,CAAC;;AAGH,wEAAwE;AACxE,MAAM,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC"}

package/build/src/script-overrides-decorator.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@keymanapp/models-types" />
+import { OverrideScriptDefaults } from "./lexical-model.js";
+export declare function decorateWithScriptOverrides(breaker: WordBreakingFunction, option: OverrideScriptDefaults): (phrase: string) => Span[];
+//# sourceMappingURL=script-overrides-decorator.d.ts.map

package/build/src/script-overrides-decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-overrides-decorator.d.ts","sourceRoot":"","sources":["../../src/script-overrides-decorator.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,sBAAsB,YAgB/D,MAAM,KAAG,IAAI,EAAE,CAwDxD"}

package/build/src/script-overrides-decorator.js

@@ -0,0 +1,63 @@
+export function decorateWithScriptOverrides(breaker, option) {
+    if (option !== 'break-words-at-spaces') {
+        throw new Error(`Unsupported script override: ${option}`);
+    }
+    /**
+     * Matches if when a span contains a Southeast-Asian letter or mark anywhere.
+     * This makes it a candidate for joining.
+     *
+     * See: tools/create-override-script-regexp.ts for how this RegExp was
+     * generated.
+     *
+     * Last updated for Unicode 13.0.0.
+     */
+    const HAS_SOUTHEAST_ASIAN_LETTER = /[\u0E01-\u0E3A\u0E40-\u0E4E\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0EDC-\u0EDF\u1000-\u103F\u1050-\u108F\u109A-\u109D\u1780-\u17D3\u17D7\u17DC\u17DD\u30A1-\u30FA\u30FC-\u30FF]/;
+    return function enhancedBreaker(phrase) {
+        let originalSpans = breaker(phrase);
+        if (originalSpans.length === 0) {
+            return [];
+        }
+        let outputSpans = [originalSpans.shift()];
+        for (let currentSpan of originalSpans) {
+            let previousSpan = lastFrom(outputSpans);
+            if (spansAreBackToBack(previousSpan, currentSpan) &&
+                hasSouthEastAsianLetter(previousSpan) &&
+                hasSouthEastAsianLetter(currentSpan)) {
+                // previous span SHOULD be joined with current!
+                outputSpans[outputSpans.length - 1] = concatenateSpans(previousSpan, currentSpan);
+            }
+            else {
+                outputSpans.push(currentSpan);
+            }
+        }
+        return outputSpans;
+    };
+    function hasSouthEastAsianLetter(span) {
+        return HAS_SOUTHEAST_ASIAN_LETTER.test(span.text);
+    }
+    /**
+     * Returns true when the spans are contiguous.
+     * Order matters when calling this function!
+     */
+    function spansAreBackToBack(former, latter) {
+        return former.end === latter.start;
+    }
+    function concatenateSpans(former, latter) {
+        if (latter.start !== former.end) {
+            throw new Error(`Cannot concatenate non-contiguous spans: ${JSON.stringify(former)}/${JSON.stringify(latter)}`);
+        }
+        return {
+            start: former.start,
+            end: latter.end,
+            length: former.length + latter.length,
+            text: former.text + latter.text
+        };
+    }
+    /**
+     * Get the last element from the array.
+     */
+    function lastFrom(array) {
+        return array[array.length - 1];
+    }
+}
+//# sourceMappingURL=script-overrides-decorator.js.map

package/build/src/script-overrides-decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-overrides-decorator.js","sourceRoot":"","sources":["../../src/script-overrides-decorator.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,2BAA2B,CAAC,OAA6B,EAAE,MAA8B;IACvG,IAAI,MAAM,KAAK,uBAAuB,EAAE;QACtC,MAAM,IAAI,KAAK,CAAC,gCAAgC,MAAM,EAAE,CAAC,CAAA;KAC1D;IAED;;;;;;;;OAQG;IACH,MAAM,0BAA0B,GAAG,0OAA0O,CAAC;IAE9Q,OAAO,SAAS,eAAe,CAAC,MAAc;QAC5C,IAAI,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;QAEpC,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE;YAC9B,OAAO,EAAE,CAAC;SACX;QAED,IAAI,WAAW,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC;QAC1C,KAAK,IAAI,WAAW,IAAI,aAAa,EAAE;YACrC,IAAI,YAAY,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;YAEzC,IAAI,kBAAkB,CAAC,YAAY,EAAE,WAAW,CAAC;gBAC7C,uBAAuB,CAAC,YAAY,CAAC;gBACrC,uBAAuB,CAAC,WAAW,CAAC,EACtC;gBACA,+CAA+C;gBAC/C,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,gBAAgB,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;aACnF;iBAAM;gBACL,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC/B;SACF;QAED,OAAO,WAAW,CAAC;IACrB,CAAC,CAAA;IAED,SAAS,uBAAuB,CAAC,IAAU;QACzC,OAAO,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpD,CAAC;IAED;;;OAGG;IACH,SAAS,kBAAkB,CAAC,MAAY,EAAE,MAAY;QACpD,OAAO,MAAM,CAAC,GAAG,KAAK,MAAM,CAAC,KAAK,CAAC;IACrC,CAAC;IAED,SAAS,gBAAgB,CAAC,MAAY,EAAE,MAAY;QAClD,IAAI,MAAM,CAAC,KAAK,KAAK,MAAM,CAAC,GAAG,EAAE;YAC/B,MAAM,IAAI,KAAK,CAAC,4CAA4C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;SACjH;QAED,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM;YACrC,IAAI,EAAE,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI;SAChC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,SAAS,QAAQ,CAAI,KAAU;QAC7B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACjC,CAAC;AACH,CAAC"}

package/build/test/helpers/index.d.ts

@@ -0,0 +1,69 @@
+import { LogMessage, KeymanCompilerError } from '../../src/model-compiler-errors.js';
+export interface CompilationResult {
+    hasSyntaxError: boolean;
+    modelConstructorName: string;
+    error: Error;
+    exportedModel: object;
+}
+/**
+ * Builds a path to the fixture with the given path components.
+ *
+ * e.g., makePathToFixture('example.qaa.trivial')
+ * e.g., makePathToFixture('example.qaa.trivial', 'model.ts')
+ *
+ * @param components One or more path components.
+ */
+export declare function makePathToFixture(...components: string[]): string;
+/**
+ * Given source code of a model (as produced by the compiler), this evaluates
+ * it!
+ *
+ * That way, you can determine if the source code was syntactically-valid,
+ * whether it raise an exception during construction, and you can even inspect
+ * the resultant LexicalModel for yourself!
+ *
+ * @param code
+ */
+export declare function compileModelSourceCode(code: string): {
+    error: Error;
+    exportedModel: object;
+    hasSyntaxError: boolean;
+    modelConstructorName: string;
+};
+/**
+ * Enables one to query log messages after they have been logged.
+ */
+export declare class LogHoarder {
+    private messages;
+    /**
+     * Get rid of all log messages seen.
+     */
+    clear(): void;
+    /**
+     * Hoards a log message for later perusal.
+     */
+    handleLog(log: LogMessage): void;
+    /**
+     * Has an error message with this code been witnessed?
+     */
+    hasSeenCode(code: KeymanCompilerError): boolean;
+    /**
+     * Have any warnings been logged?
+     */
+    hasSeenWarnings(): boolean;
+    /**
+     * Overrides the global log handler, allowing one to browse log messages
+     * later.
+     *
+     * Remember to uninstall the log handler afterwards!
+     */
+    install(): this;
+    /**
+     * Return the log message handler to its default.
+     *
+     * Note: You MUST uninstall the hoarder after use!
+     * It's recommended you put this in an afterEach() callback.
+     */
+    uninstall(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/test/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../test/helpers/index.ts"],"names":[],"mappings":"AAQA,OAAO,EAAC,UAAU,EAAE,mBAAmB,EAA0D,MAAM,oCAAoC,CAAC;AAE5I,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,OAAO,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACF,wBAAgB,iBAAiB,CAAC,GAAG,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAElE;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM;;;;;EAkFlD;AAED;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAoB;IAEpC;;OAEG;IACH,KAAK;IAIL;;OAEG;IACH,SAAS,CAAC,GAAG,EAAE,UAAU;IAIzB;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO;IAI/C;;OAEG;IACH,eAAe,IAAI,OAAO;IAM1B;;;;;OAKG;IACH,OAAO,IAAI,IAAI;IAKf;;;;;OAKG;IACH,SAAS;CAGV"}