@keymanapp/kmc-ldml 18.0.16-alpha → 18.0.18-alpha

package/build/src/compiler/tran.js

@@ -1,354 +1,383 @@
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="46f9c4ca-55de-57da-8da0-b5a03e066ae1")}catch(e){}}();
-import { constants } from "@keymanapp/ldml-keyboard-constants";
-import { KMXPlus, VariableParser, MarkerParser, util } from '@keymanapp/common-types';
-import { SectionCompiler } from "./section-compiler.js";
-var Bksp = KMXPlus.Bksp;
-var Tran = KMXPlus.Tran;
-var TranReorder = KMXPlus.TranReorder;
-var TranTransform = KMXPlus.TranTransform;
-import { verifyValidAndUnique } from "../util/util.js";
-import { CompilerMessages } from "./messages.js";
-import { SubstitutionUse } from "./substitution-tracker.js";
-export class TransformCompiler extends SectionCompiler {
-    static validateSubstitutions(keyboard, st) {
-        keyboard?.transforms?.forEach(transforms => transforms.transformGroup.forEach(transformGroup => {
-            transformGroup.transform?.forEach(({ to, from }) => {
-                st.addSetAndStringSubtitution(SubstitutionUse.consume, from);
-                st.addSetAndStringSubtitution(SubstitutionUse.emit, to);
-                const mapFrom = VariableParser.CAPTURE_SET_REFERENCE.exec(from);
-                const mapTo = VariableParser.MAPPED_SET_REFERENCE.exec(to || '');
-                if (mapFrom) {
-                    // add the 'from' as a match
-                    st.set.add(SubstitutionUse.consume, [mapFrom[1]]);
-                }
-                if (mapTo) {
-                    // add the 'from' as a match
-                    st.set.add(SubstitutionUse.emit, [mapTo[1]]);
-                }
-            });
-            transformGroup.reorder?.forEach(({ before }) => {
-                st.addStringSubstitution(SubstitutionUse.consume, before);
-            });
-        }));
-        return true;
-    }
-    type;
-    constructor(source, callbacks) {
-        super(source, callbacks);
-    }
-    validate() {
-        const reportMessage = this.callbacks.reportMessage.bind(this.callbacks);
-        let valid = true;
-        const transforms = this?.keyboard3?.transforms;
-        if (transforms) {
-            const types = transforms.map(({ type }) => type);
-            if (!verifyValidAndUnique(types, types => reportMessage(CompilerMessages.Error_DuplicateTransformsType({ types })), new Set(['simple', 'backspace']), types => reportMessage(CompilerMessages.Error_InvalidTransformsType({ types })))) {
-                valid = false;
-            }
-            // check for mixed groups
-            let mixed = false;
-            let empty = false;
-            transforms.forEach(({ transformGroup }) => transformGroup.forEach((transformGroup) => {
-                if (transformGroup.reorder?.length && transformGroup.transform?.length) {
-                    mixed = true;
-                }
-                if (!transformGroup.reorder?.length && !transformGroup.transform?.length) {
-                    empty = true;
-                }
-            }));
-            if (mixed) {
-                valid = false;
-                reportMessage(CompilerMessages.Error_MixedTransformGroup()); // report this once
-            }
-            if (empty) {
-                valid = false;
-                reportMessage(CompilerMessages.Error_EmptyTransformGroup()); // report this once
-            }
-            // TODO-LDML: linting here should check for identical from, but this involves a double-parse which is ugly
-            // TODO-LDML: unicodesets means that either we fully parse them and verify conflicting rules or the linting is imperfect
-        }
-        return valid;
-    }
-    /* c8 ignore next 4 */
-    /** allocate a new TranBase subclass */
-    newTran() {
-        throw Error(`Internal Error: newTran() not implemented`);
-    }
-    compileTransforms(sections, transforms) {
-        let result = this.newTran();
-        if (transforms?.transformGroup) {
-            for (let transformGroup of transforms.transformGroup) {
-                const tg = this.compileTransformGroup(sections, transformGroup);
-                if (!tg)
-                    return null; //error
-                result.groups.push(tg);
-            }
-        }
-        return result;
-    }
-    compileTransformGroup(sections, transformGroup) {
-        if (transformGroup.reorder.length && transformGroup.transform.length) {
-            /* c8 ignore next 2 */
-            // should have been caught by validate
-            throw Error(`Internal error: transformGroup has both reorder and transform elements.`);
-        }
-        else if (transformGroup.reorder.length) {
-            return this.compileReorderTranGroup(sections, transformGroup.reorder);
-        }
-        else if (transformGroup.transform.length) {
-            return this.compileTransformTranGroup(sections, transformGroup.transform);
-        }
-        else {
-            /* c8 ignore next */
-            throw Error(`Internal error: transformGroup has neither reorder nor transform elements.`);
-        }
-    }
-    compileTransformTranGroup(sections, transforms) {
-        const result = {
-            type: constants.tran_group_type_transform,
-            transforms: transforms.map(transform => this.compileTransform(sections, transform)),
-            reorders: [],
-        };
-        if (result.transforms.includes(null))
-            return null;
-        return result;
-    }
-    compileTransform(sections, transform) {
-        let result = new TranTransform();
-        let cookedFrom = transform.from;
-        cookedFrom = sections.vars.substituteStrings(cookedFrom, sections);
-        const mapFrom = VariableParser.CAPTURE_SET_REFERENCE.exec(cookedFrom);
-        const mapTo = VariableParser.MAPPED_SET_REFERENCE.exec(transform.to || '');
-        if (mapFrom && mapTo) { // TODO-LDML: error cases
-            result.mapFrom = sections.strs.allocString(mapFrom[1]); // var name
-            result.mapTo = sections.strs.allocString(mapTo[1]); // var name
-        }
-        else {
-            result.mapFrom = sections.strs.allocString(''); // TODO-LDML
-            result.mapTo = sections.strs.allocString(''); // TODO-LDML
-        }
-        cookedFrom = sections.vars.substituteSetRegex(cookedFrom, sections);
-        // add in markers. idempotent if no markers.
-        cookedFrom = sections.vars.substituteMarkerString(cookedFrom, true);
-        // check for incorrect \uXXXX escapes
-        cookedFrom = this.checkEscapes(cookedFrom); // check for \uXXXX escapes before normalizing
-        if (cookedFrom === null)
-            return null; // error
-        // unescape from \u{} form to plain, or in some cases \uXXXX / \UXXXXXXXX for core
-        cookedFrom = util.unescapeStringToRegex(cookedFrom);
-        // check for denormalized ranges
-        cookedFrom = this.checkRanges(cookedFrom); // check before normalizing
-        if (!sections?.meta?.normalizationDisabled) {
-            // nfd here.
-            cookedFrom = MarkerParser.nfd_markers(cookedFrom, true);
-        }
-        // Verify that the regex is syntactically valid
-        try {
-            new RegExp(cookedFrom, 'ug');
-        }
-        catch (e) {
-            this.callbacks.reportMessage(CompilerMessages.Error_UnparseableTransformFrom({ from: transform.from, message: e.message }));
-            return null; // error
-        }
-        // cookedFrom is cooked above, since there's some special treatment
-        result.from = sections.strs.allocString(cookedFrom, {
-            unescape: false,
-        }, sections);
-        // 'to' is handled via allocString
-        result.to = sections.strs.allocString(transform.to, {
-            stringVariables: true,
-            markers: true,
-            unescape: true,
-            nfd: true,
-        }, sections);
-        return result;
-    }
-    compileReorderTranGroup(sections, reorders) {
-        const result = {
-            type: constants.tran_group_type_reorder,
-            transforms: [],
-            reorders: reorders.map(reorder => this.compileReorder(sections, reorder)),
-        };
-        if (result.reorders.includes(null))
-            return null; // if any of the reorders returned null, fail the entire group.
-        return result;
-    }
-    compileReorder(sections, reorder) {
-        let result = new TranReorder();
-        if (reorder.from && this.checkEscapes(reorder.from) === null) {
-            return null; // error'ed
-        }
-        if (reorder.before && this.checkEscapes(reorder.before) === null) {
-            return null; // error'ed
-        }
-        result.elements = sections.elem.allocElementString(sections, reorder.from, reorder.order, reorder.tertiary, reorder.tertiaryBase, reorder.preBase);
-        result.before = sections.elem.allocElementString(sections, reorder.before);
-        if (!result.elements || !result.before) {
-            return null; // already error'ed
-        }
-        else {
-            return result;
-        }
-    }
-    compile(sections) {
-        for (let t of this.keyboard3.transforms) {
-            if (t.type == this.type) {
-                // compile only the transforms of the correct type
-                return this.compileTransforms(sections, t);
-            }
-        }
-        return this.newTran(); // empty: nothing of this type found.
-    }
-    get dependencies() {
-        const defaults = new Set([
-            constants.section.elem,
-            constants.section.list,
-            constants.section.meta,
-            constants.section.strs,
-            constants.section.uset,
-            constants.section.vars,
-        ]);
-        defaults.delete(this.id);
-        return defaults;
-    }
-    /**
-     * Analyze reorders and regexes for \uXXXX escapes.
-     * The LDML spec requires \u{XXXX} format.
-     * @param cookedFrom the original string
-     * @returns the original string, or null if an error was reported
-     */
-    checkEscapes(cookedFrom) {
-        if (!cookedFrom)
-            return cookedFrom;
-        // should not follow marker prefix, nor marker prefix with range
-        const anyQuad = /(?<!\\uffff\\u0008(?:\[[0-9a-fA-F\\u-]*)?)\\u([0-9a-fA-F]{4})/g;
-        for (const [, sub] of cookedFrom.matchAll(anyQuad)) {
-            const s = util.unescapeOne(sub);
-            if (s !== '\uffff' && s !== '\u0008') { // markers
-                this.callbacks.reportMessage(CompilerMessages.Error_InvalidQuadEscape({ cp: s.codePointAt(0) }));
-                return null; // exit on the first error
-            }
-        }
-        return cookedFrom;
-    }
-    /**
-     * Analyze character classes such as '[a-z]' for denormalized characters.
-     * Escapes non-NFD characters as hex escapes.
-     * @param cookedFrom input regex string
-     * @returns updated 'from' string
-     */
-    checkRanges(cookedFrom) {
-        if (!cookedFrom)
-            return cookedFrom;
-        // extract all of the potential ranges - but don't match any-markers!
-        const anyRange = /(?<!\\uffff\\u0008)\[([^\]]+)\]/g;
-        const ranges = cookedFrom.matchAll(anyRange);
-        if (!ranges)
-            return cookedFrom;
-        // extract inner members of a range (inside the [])
-        const rangeRegex = /(\\u\{[0-9a-fA-F]\}{1,6}|.)-(\\u\{[0-9a-fA-F]\}{1,6}|.)|./g;
-        const rangeExplicit = new util.NFDAnalyzer();
-        const rangeImplicit = new util.NFDAnalyzer();
-        /** process an explicit entry */
-        function processExplicit(s) {
-            if (s.startsWith('\\u{')) {
-                s = util.unescapeString(s);
-            }
-            rangeExplicit.add(s);
-            return s;
-        }
-        for (const [, sub] of ranges) {
-            const subRanges = sub.matchAll(rangeRegex);
-            for (const [all, start, end] of subRanges) {
-                if (!start && !end) {
-                    // explicit single char
-                    processExplicit(all); // matched one char
-                }
-                else {
-                    // start-end range - get explicit start and end chars
-                    const s = processExplicit(start);
-                    const sch = s.codePointAt(0);
-                    const e = processExplicit(end);
-                    const ech = e.codePointAt(0);
-                    // now, process the inner chars, not including explicit
-                    for (let n = sch; n < ech; n++) {
-                        // add inner text
-                        rangeImplicit.add(String.fromCodePoint(n));
-                    }
-                }
-            }
-        }
-        // analyze ranges
-        let needCooking = false;
-        const explicitSet = rangeExplicit.analyze()?.get(util.BadStringType.denormalized);
-        if (explicitSet) {
-            this.callbacks.reportMessage(CompilerMessages.Warn_CharClassExplicitDenorm({ lowestCh: explicitSet.values().next().value }));
-            needCooking = true;
-        }
-        else {
-            // don't analyze the implicit set of THIS range, if explicit is already problematic
-            const implicitSet = rangeImplicit.analyze()?.get(util.BadStringType.denormalized);
-            if (implicitSet) {
-                this.callbacks.reportMessage(CompilerMessages.Hint_CharClassImplicitDenorm({ lowestCh: implicitSet.values().next().value }));
-                needCooking = true;
-            }
-        }
-        // do we need to fixup the ranges?
-        // don't do this unless we flagged issues above
-        if (needCooking) {
-            // if we get here, there are some ranges with troublesome chars.
-            // we work around this by escaping all chars
-            function cookOne(s) {
-                if (s === '^') {
-                    return s; // syntax
-                }
-                else if (s.startsWith('\\u{') || s.startsWith('\\u')) {
-                    return s; // already escaped
-                }
-                else {
-                    return util.escapeRegexChar(s);
-                }
-            }
-            return cookedFrom.replaceAll(anyRange, (ignored1, sub) => {
-                return '[' + sub.replaceAll(rangeRegex, (all, start, end) => {
-                    if (!start && !end) {
-                        // explicit single char
-                        return cookOne(all); // matched one char
-                    }
-                    else {
-                        return cookOne(start) + '-' + cookOne(end);
-                    }
-                }) + ']';
-            });
-        }
-        return cookedFrom; // no change
-    }
-}
-export class TranCompiler extends TransformCompiler {
-    constructor(source, callbacks) {
-        super(source, callbacks);
-        this.type = 'simple';
-    }
-    newTran() {
-        return new Tran();
-    }
-    get id() {
-        return constants.section.tran;
-    }
-}
-;
-export class BkspCompiler extends TransformCompiler {
-    constructor(source, callbacks) {
-        super(source, callbacks);
-        this.type = 'backspace';
-    }
-    newTran() {
-        return new Bksp();
-    }
-    get id() {
-        return constants.section.bksp;
-    }
-}
-;
-//# debugId=46f9c4ca-55de-57da-8da0-b5a03e066ae1
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{},n=(new Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="0167fbd9-6012-5d87-8d47-1fec054a30bc")}catch(e){}}();
+import { constants } from "@keymanapp/ldml-keyboard-constants";
+import { KMXPlus, VariableParser, MarkerParser, util } from '@keymanapp/common-types';
+import { SectionCompiler } from "./section-compiler.js";
+var Bksp = KMXPlus.Bksp;
+var Tran = KMXPlus.Tran;
+var TranReorder = KMXPlus.TranReorder;
+var TranTransform = KMXPlus.TranTransform;
+import { verifyValidAndUnique } from "../util/util.js";
+import { CompilerMessages } from "./messages.js";
+import { SubstitutionUse } from "./substitution-tracker.js";
+export class TransformCompiler extends SectionCompiler {
+    static validateSubstitutions(keyboard, st) {
+        keyboard?.transforms?.forEach(transforms => transforms.transformGroup.forEach(transformGroup => {
+            transformGroup.transform?.forEach(({ to, from }) => {
+                st.addSetAndStringSubtitution(SubstitutionUse.consume, from);
+                st.addSetAndStringSubtitution(SubstitutionUse.emit, to);
+                const mapFrom = VariableParser.CAPTURE_SET_REFERENCE.exec(from);
+                const mapTo = VariableParser.MAPPED_SET_REFERENCE.exec(to || '');
+                if (mapFrom) {
+                    // add the 'from' as a match
+                    st.set.add(SubstitutionUse.consume, [mapFrom[1]]);
+                }
+                if (mapTo) {
+                    // add the 'from' as a match
+                    st.set.add(SubstitutionUse.emit, [mapTo[1]]);
+                }
+            });
+            transformGroup.reorder?.forEach(({ before }) => {
+                st.addStringSubstitution(SubstitutionUse.consume, before);
+            });
+        }));
+        return true;
+    }
+    type;
+    constructor(source, callbacks) {
+        super(source, callbacks);
+    }
+    validate() {
+        const reportMessage = this.callbacks.reportMessage.bind(this.callbacks);
+        let valid = true;
+        const transforms = this?.keyboard3?.transforms;
+        if (transforms) {
+            const types = transforms.map(({ type }) => type);
+            if (!verifyValidAndUnique(types, types => reportMessage(CompilerMessages.Error_DuplicateTransformsType({ types })), new Set(['simple', 'backspace']), types => reportMessage(CompilerMessages.Error_InvalidTransformsType({ types })))) {
+                valid = false;
+            }
+            // check for mixed groups
+            let mixed = false;
+            let empty = false;
+            transforms.forEach(({ transformGroup }) => transformGroup.forEach((transformGroup) => {
+                if (transformGroup.reorder?.length && transformGroup.transform?.length) {
+                    mixed = true;
+                }
+                if (!transformGroup.reorder?.length && !transformGroup.transform?.length) {
+                    empty = true;
+                }
+            }));
+            if (mixed) {
+                valid = false;
+                reportMessage(CompilerMessages.Error_MixedTransformGroup()); // report this once
+            }
+            if (empty) {
+                valid = false;
+                reportMessage(CompilerMessages.Error_EmptyTransformGroup()); // report this once
+            }
+            // TODO-LDML: linting here should check for identical from, but this involves a double-parse which is ugly
+            // TODO-LDML: unicodesets means that either we fully parse them and verify conflicting rules or the linting is imperfect
+        }
+        return valid;
+    }
+    /* c8 ignore next 4 */
+    /** allocate a new TranBase subclass */
+    newTran() {
+        throw Error(`Internal Error: newTran() not implemented`);
+    }
+    compileTransforms(sections, transforms) {
+        let result = this.newTran();
+        if (transforms?.transformGroup) {
+            for (let transformGroup of transforms.transformGroup) {
+                const tg = this.compileTransformGroup(sections, transformGroup);
+                if (!tg)
+                    return null; //error
+                result.groups.push(tg);
+            }
+        }
+        return result;
+    }
+    compileTransformGroup(sections, transformGroup) {
+        if (transformGroup.reorder.length && transformGroup.transform.length) {
+            /* c8 ignore next 2 */
+            // should have been caught by validate
+            throw Error(`Internal error: transformGroup has both reorder and transform elements.`);
+        }
+        else if (transformGroup.reorder.length) {
+            return this.compileReorderTranGroup(sections, transformGroup.reorder);
+        }
+        else if (transformGroup.transform.length) {
+            return this.compileTransformTranGroup(sections, transformGroup.transform);
+        }
+        else {
+            /* c8 ignore next */
+            throw Error(`Internal error: transformGroup has neither reorder nor transform elements.`);
+        }
+    }
+    compileTransformTranGroup(sections, transforms) {
+        const result = {
+            type: constants.tran_group_type_transform,
+            transforms: transforms.map(transform => this.compileTransform(sections, transform)),
+            reorders: [],
+        };
+        if (result.transforms.includes(null))
+            return null;
+        return result;
+    }
+    compileTransform(sections, transform) {
+        let result = new TranTransform();
+        let cookedFrom = transform.from;
+        // check for incorrect \uXXXX escapes. Do this before substituting markers or sets.
+        cookedFrom = this.checkEscapes(cookedFrom); // check for \uXXXX escapes before normalizing
+        cookedFrom = sections.vars.substituteStrings(cookedFrom, sections, true);
+        const mapFrom = VariableParser.CAPTURE_SET_REFERENCE.exec(cookedFrom);
+        const mapTo = VariableParser.MAPPED_SET_REFERENCE.exec(transform.to || '');
+        if (mapFrom && mapTo) { // TODO-LDML: error cases
+            result.mapFrom = sections.strs.allocString(mapFrom[1]); // var name
+            result.mapTo = sections.strs.allocString(mapTo[1]); // var name
+        }
+        else {
+            result.mapFrom = sections.strs.allocString('');
+            result.mapTo = sections.strs.allocString('');
+        }
+        if (cookedFrom === null)
+            return null; // error
+        // the set substution will not produce raw markers `\m{...}` but they will already be in sentinel form.
+        cookedFrom = sections.vars.substituteSetRegex(cookedFrom, sections);
+        // add in markers. idempotent if no markers.
+        cookedFrom = sections.vars.substituteMarkerString(cookedFrom, true);
+        // unescape from \u{} form to plain, or in some cases \uXXXX / \UXXXXXXXX for core
+        cookedFrom = util.unescapeStringToRegex(cookedFrom);
+        // check for denormalized ranges
+        cookedFrom = this.checkRanges(cookedFrom); // check before normalizing
+        if (!sections?.meta?.normalizationDisabled) {
+            // nfd here.
+            cookedFrom = MarkerParser.nfd_markers(cookedFrom, true);
+        }
+        // perform regex validation
+        if (!this.isValidRegex(cookedFrom, transform.from)) {
+            return null;
+        }
+        // cookedFrom is cooked above, since there's some special treatment
+        result.from = sections.strs.allocString(cookedFrom, {
+            unescape: false,
+        }, sections);
+        // 'to' is handled via allocString
+        result.to = sections.strs.allocString(transform.to, {
+            stringVariables: true,
+            markers: true,
+            unescape: true,
+            nfd: true,
+        }, sections);
+        return result;
+    }
+    /**
+     * Validate the final regex
+     * @param cookedFrom the regex to use, missing the trailing '$'
+     * @param from the original from - for error reporting
+     * @returns true if OK
+     */
+    isValidRegex(cookedFrom, from) {
+        // check for any unescaped dollar sign here
+        if (/(?<!\\)(?:\\\\)*\$/.test(cookedFrom)) {
+            this.callbacks.reportMessage(CompilerMessages.Error_IllegalTransformDollarsign({ from }));
+            return false;
+        }
+        // Verify that the regex is syntactically valid
+        try {
+            const rg = new RegExp(cookedFrom + '$', 'ug');
+            // Tests against the regex:
+            // does it match an empty string?
+            if (rg.test('')) {
+                this.callbacks.reportMessage(CompilerMessages.Error_TransformFromMatchesNothing({ from }));
+                return false;
+            }
+        }
+        catch (e) {
+            // We're exposing the internal regex error message here.
+            // In the future, CLDR plans to expose the EBNF for the transform,
+            // at which point we would have more precise validation prior to getting to this point.
+            this.callbacks.reportMessage(CompilerMessages.Error_UnparseableTransformFrom({ from, message: e.message }));
+            return false;
+        }
+        return true;
+    }
+    compileReorderTranGroup(sections, reorders) {
+        const result = {
+            type: constants.tran_group_type_reorder,
+            transforms: [],
+            reorders: reorders.map(reorder => this.compileReorder(sections, reorder)),
+        };
+        if (result.reorders.includes(null))
+            return null; // if any of the reorders returned null, fail the entire group.
+        return result;
+    }
+    compileReorder(sections, reorder) {
+        let result = new TranReorder();
+        if (reorder.from && this.checkEscapes(reorder.from) === null) {
+            return null; // error'ed
+        }
+        if (reorder.before && this.checkEscapes(reorder.before) === null) {
+            return null; // error'ed
+        }
+        result.elements = sections.elem.allocElementString(sections, reorder.from, reorder.order, reorder.tertiary, reorder.tertiaryBase, reorder.preBase);
+        result.before = sections.elem.allocElementString(sections, reorder.before);
+        if (!result.elements || !result.before) {
+            return null; // already error'ed
+        }
+        else {
+            return result;
+        }
+    }
+    compile(sections) {
+        for (let t of this.keyboard3.transforms) {
+            if (t.type == this.type) {
+                // compile only the transforms of the correct type
+                return this.compileTransforms(sections, t);
+            }
+        }
+        return this.newTran(); // empty: nothing of this type found.
+    }
+    get dependencies() {
+        const defaults = new Set([
+            constants.section.elem,
+            constants.section.list,
+            constants.section.meta,
+            constants.section.strs,
+            constants.section.uset,
+            constants.section.vars,
+        ]);
+        defaults.delete(this.id);
+        return defaults;
+    }
+    /**
+     * Analyze reorders and regexes for \uXXXX escapes.
+     * The LDML spec requires \u{XXXX} format.
+     * @param cookedFrom the original string
+     * @returns the original string, or null if an error was reported
+     */
+    checkEscapes(cookedFrom) {
+        if (!cookedFrom)
+            return cookedFrom;
+        // should not follow marker prefix, nor marker prefix with range
+        const anyQuad = /(?<!\\uffff\\u0008(?:\[[0-9a-fA-F\\u-]*)?)\\u([0-9a-fA-F]{4})/g;
+        for (const [, sub] of cookedFrom.matchAll(anyQuad)) {
+            const s = util.unescapeOne(sub);
+            if (s !== '\uffff' && s !== '\u0008') { // markers
+                this.callbacks.reportMessage(CompilerMessages.Error_InvalidQuadEscape({ cp: s.codePointAt(0) }));
+                return null; // exit on the first error
+            }
+        }
+        return cookedFrom;
+    }
+    /**
+     * Analyze character classes such as '[a-z]' for denormalized characters.
+     * Escapes non-NFD characters as hex escapes.
+     * @param cookedFrom input regex string
+     * @returns updated 'from' string
+     */
+    checkRanges(cookedFrom) {
+        if (!cookedFrom)
+            return cookedFrom;
+        // extract all of the potential ranges - but don't match any-markers!
+        const anyRange = /(?<!\\uffff\\u0008)\[([^\]]+)\]/g;
+        const ranges = cookedFrom.matchAll(anyRange);
+        if (!ranges)
+            return cookedFrom;
+        // extract inner members of a range (inside the [])
+        const rangeRegex = /(\\u\{[0-9a-fA-F]\}{1,6}|.)-(\\u\{[0-9a-fA-F]\}{1,6}|.)|./g;
+        const rangeExplicit = new util.NFDAnalyzer();
+        const rangeImplicit = new util.NFDAnalyzer();
+        /** process an explicit entry */
+        function processExplicit(s) {
+            if (s.startsWith('\\u{')) {
+                s = util.unescapeString(s);
+            }
+            rangeExplicit.add(s);
+            return s;
+        }
+        for (const [, sub] of ranges) {
+            const subRanges = sub.matchAll(rangeRegex);
+            for (const [all, start, end] of subRanges) {
+                if (!start && !end) {
+                    // explicit single char
+                    processExplicit(all); // matched one char
+                }
+                else {
+                    // start-end range - get explicit start and end chars
+                    const s = processExplicit(start);
+                    const sch = s.codePointAt(0);
+                    const e = processExplicit(end);
+                    const ech = e.codePointAt(0);
+                    // now, process the inner chars, not including explicit
+                    for (let n = sch; n < ech; n++) {
+                        // add inner text
+                        rangeImplicit.add(String.fromCodePoint(n));
+                    }
+                }
+            }
+        }
+        // analyze ranges
+        let needCooking = false;
+        const explicitSet = rangeExplicit.analyze()?.get(util.BadStringType.denormalized);
+        if (explicitSet) {
+            this.callbacks.reportMessage(CompilerMessages.Warn_CharClassExplicitDenorm({ lowestCh: explicitSet.values().next().value }));
+            needCooking = true;
+        }
+        else {
+            // don't analyze the implicit set of THIS range, if explicit is already problematic
+            const implicitSet = rangeImplicit.analyze()?.get(util.BadStringType.denormalized);
+            if (implicitSet) {
+                this.callbacks.reportMessage(CompilerMessages.Hint_CharClassImplicitDenorm({ lowestCh: implicitSet.values().next().value }));
+                needCooking = true;
+            }
+        }
+        // do we need to fixup the ranges?
+        // don't do this unless we flagged issues above
+        if (needCooking) {
+            // if we get here, there are some ranges with troublesome chars.
+            // we work around this by escaping all chars
+            function cookOne(s) {
+                if (s === '^') {
+                    return s; // syntax
+                }
+                else if (s.startsWith('\\u{') || s.startsWith('\\u')) {
+                    return s; // already escaped
+                }
+                else {
+                    return util.escapeRegexChar(s);
+                }
+            }
+            return cookedFrom.replaceAll(anyRange, (ignored1, sub) => {
+                return '[' + sub.replaceAll(rangeRegex, (all, start, end) => {
+                    if (!start && !end) {
+                        // explicit single char
+                        return cookOne(all); // matched one char
+                    }
+                    else {
+                        return cookOne(start) + '-' + cookOne(end);
+                    }
+                }) + ']';
+            });
+        }
+        return cookedFrom; // no change
+    }
+}
+export class TranCompiler extends TransformCompiler {
+    constructor(source, callbacks) {
+        super(source, callbacks);
+        this.type = 'simple';
+    }
+    newTran() {
+        return new Tran();
+    }
+    get id() {
+        return constants.section.tran;
+    }
+}
+;
+export class BkspCompiler extends TransformCompiler {
+    constructor(source, callbacks) {
+        super(source, callbacks);
+        this.type = 'backspace';
+    }
+    newTran() {
+        return new Bksp();
+    }
+    get id() {
+        return constants.section.bksp;
+    }
+}
+;
 //# sourceMappingURL=tran.js.map
+//# debugId=0167fbd9-6012-5d87-8d47-1fec054a30bc