add initial marp implementation with sample content and build configuration

node_modules/speech-rule-engine/mjs/speech_generator/abstract_speech_generator.d.ts

@@ -0,0 +1,24 @@
+import * as EnrichAttr from '../enrich_mathml/enrich_attr.js';
+import { AxisMap } from '../rule_engine/dynamic_cstr.js';
+import { RebuildStree } from '../walker/rebuild_stree.js';
+import { SpeechGenerator } from './speech_generator.js';
+export declare abstract class AbstractSpeechGenerator implements SpeechGenerator {
+    modality: EnrichAttr.Attribute;
+    private rebuilt_;
+    private options_;
+    abstract getSpeech(node: Element, xml: Element, root?: Element): string;
+    getRebuilt(): RebuildStree;
+    setRebuilt(rebuilt: RebuildStree): void;
+    computeRebuilt(xml: Element, force?: boolean): RebuildStree;
+    setOptions(options: AxisMap): void;
+    setOption(key: string, value: string): void;
+    getOptions(): {
+        [key: string]: string;
+    };
+    generateSpeech(_node: Node, xml: Element): string;
+    nextRules(): void;
+    nextStyle(id: string): void;
+    private nextStyle_;
+    getLevel(depth: string): string;
+    getActionable(actionable: number): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/abstract_speech_generator.js

@@ -0,0 +1,107 @@
+import { setup as EngineSetup } from '../common/engine_setup.js';
+import * as EnrichAttr from '../enrich_mathml/enrich_attr.js';
+import { RebuildStree } from '../walker/rebuild_stree.js';
+import * as SpeechGeneratorUtil from './speech_generator_util.js';
+import * as EngineConst from '../common/engine_const.js';
+import { LOCALE } from '../l10n/locale.js';
+import { ClearspeakPreferences } from '../speech_rules/clearspeak_preferences.js';
+export class AbstractSpeechGenerator {
+    constructor() {
+        this.modality = EnrichAttr.addPrefix('speech');
+        this.rebuilt_ = null;
+        this.options_ = {};
+    }
+    getRebuilt() {
+        return this.rebuilt_;
+    }
+    setRebuilt(rebuilt) {
+        this.rebuilt_ = rebuilt;
+    }
+    computeRebuilt(xml, force = false) {
+        if (!this.rebuilt_ || force) {
+            this.rebuilt_ = new RebuildStree(xml);
+        }
+        return this.rebuilt_;
+    }
+    setOptions(options) {
+        this.options_ = options || {};
+        this.modality = EnrichAttr.addPrefix(this.options_.modality || 'speech');
+    }
+    setOption(key, value) {
+        const options = this.getOptions();
+        options[key] = value;
+        this.setOptions(options);
+    }
+    getOptions() {
+        return this.options_;
+    }
+    generateSpeech(_node, xml) {
+        if (!this.rebuilt_) {
+            this.rebuilt_ = new RebuildStree(xml);
+        }
+        EngineSetup(this.options_);
+        return SpeechGeneratorUtil.computeMarkup(this.getRebuilt().xml);
+    }
+    nextRules() {
+        const options = this.getOptions();
+        if (options.modality !== 'speech') {
+            return;
+        }
+        const prefs = ClearspeakPreferences.getLocalePreferences();
+        if (!prefs[options.locale]) {
+            return;
+        }
+        EngineConst.DOMAIN_TO_STYLES[options.domain] = options.style;
+        options.domain =
+            options.domain === 'mathspeak' ? 'clearspeak' : 'mathspeak';
+        options.style = EngineConst.DOMAIN_TO_STYLES[options.domain];
+        this.setOptions(options);
+    }
+    nextStyle(id) {
+        this.setOption('style', this.nextStyle_(this.getRebuilt().nodeDict[id]));
+    }
+    nextStyle_(node) {
+        const { modality: modality, domain: domain, style: style } = this.getOptions();
+        if (modality !== 'speech') {
+            return style;
+        }
+        if (domain === 'mathspeak') {
+            const styles = ['default', 'brief', 'sbrief'];
+            const index = styles.indexOf(style);
+            if (index === -1) {
+                return style;
+            }
+            return index >= styles.length - 1 ? styles[0] : styles[index + 1];
+        }
+        if (domain === 'clearspeak') {
+            const prefs = ClearspeakPreferences.getLocalePreferences();
+            const loc = prefs['en'];
+            if (!loc) {
+                return 'default';
+            }
+            const smart = ClearspeakPreferences.relevantPreferences(node);
+            const current = ClearspeakPreferences.findPreference(style, smart);
+            const options = loc[smart].map(function (x) {
+                return x.split('_')[1];
+            });
+            const index = options.indexOf(current);
+            if (index === -1) {
+                return style;
+            }
+            const next = index >= options.length - 1 ? options[0] : options[index + 1];
+            const result = ClearspeakPreferences.addPreference(style, smart, next);
+            return result;
+        }
+        return style;
+    }
+    getLevel(depth) {
+        return LOCALE.MESSAGES.navigate.LEVEL + ' ' + depth;
+    }
+    getActionable(actionable) {
+        return actionable
+            ? actionable < 0
+                ? LOCALE.MESSAGES.navigate.EXPANDABLE
+                : LOCALE.MESSAGES.navigate.COLLAPSIBLE
+            : '';
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/adhoc_speech_generator.d.ts

@@ -0,0 +1,4 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export declare class AdhocSpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node: Element, xml: Element): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/adhoc_speech_generator.js

@@ -0,0 +1,8 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export class AdhocSpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node, xml) {
+        const speech = this.generateSpeech(node, xml);
+        node.setAttribute(this.modality, speech);
+        return speech;
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/color_generator.d.ts

@@ -0,0 +1,10 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export declare class ColorGenerator extends AbstractSpeechGenerator {
+    modality: any;
+    contrast: any;
+    private static visitStree_;
+    getSpeech(node: Element, _xml: Element): string;
+    generateSpeech(node: Element, xml: Element | string): string;
+    private colorLeaves_;
+    private colorLeave_;
+}

node_modules/speech-rule-engine/mjs/speech_generator/color_generator.js

@@ -0,0 +1,84 @@
+import * as DomUtil from '../common/dom_util.js';
+import { addPrefix } from '../enrich_mathml/enrich_attr.js';
+import { ContrastPicker } from '../highlighter/color_picker.js';
+import { RebuildStree } from '../walker/rebuild_stree.js';
+import * as WalkerUtil from '../walker/walker_util.js';
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export class ColorGenerator extends AbstractSpeechGenerator {
+    constructor() {
+        super(...arguments);
+        this.modality = addPrefix('foreground');
+        this.contrast = new ContrastPicker();
+    }
+    static visitStree_(tree, leaves, ignore) {
+        if (!tree.childNodes.length) {
+            if (!ignore[tree.id]) {
+                leaves.push(tree.id);
+            }
+            return;
+        }
+        if (tree.contentNodes.length) {
+            if (tree.type === 'punctuated') {
+                tree.contentNodes.forEach((x) => (ignore[x.id] = true));
+            }
+            if (tree.role !== 'implicit') {
+                leaves.push(tree.contentNodes.map((x) => x.id));
+            }
+        }
+        if (tree.childNodes.length) {
+            if (tree.role === 'implicit') {
+                const factors = [];
+                let rest = [];
+                for (const child of tree.childNodes) {
+                    const tt = [];
+                    ColorGenerator.visitStree_(child, tt, ignore);
+                    if (tt.length <= 2) {
+                        factors.push(tt.shift());
+                    }
+                    rest = rest.concat(tt);
+                }
+                leaves.push(factors);
+                rest.forEach((x) => leaves.push(x));
+                return;
+            }
+            tree.childNodes.forEach((x) => ColorGenerator.visitStree_(x, leaves, ignore));
+        }
+    }
+    getSpeech(node, _xml) {
+        return WalkerUtil.getAttribute(node, this.modality);
+    }
+    generateSpeech(node, xml) {
+        if (!this.getRebuilt()) {
+            this.setRebuilt(new RebuildStree(DomUtil.parseInput(xml)));
+        }
+        this.colorLeaves_(node);
+        return WalkerUtil.getAttribute(node, this.modality);
+    }
+    colorLeaves_(node) {
+        const leaves = [];
+        ColorGenerator.visitStree_(this.getRebuilt().streeRoot, leaves, {});
+        for (const id of leaves) {
+            const color = this.contrast.generate();
+            let success = false;
+            if (Array.isArray(id)) {
+                success = id
+                    .map((x) => this.colorLeave_(node, x, color))
+                    .reduce((x, y) => x || y, false);
+            }
+            else {
+                success = this.colorLeave_(node, id.toString(), color);
+            }
+            if (success) {
+                this.contrast.increment();
+            }
+        }
+    }
+    colorLeave_(node, id, color) {
+        const aux = WalkerUtil.getBySemanticId(node, id);
+        if (aux) {
+            aux.setAttribute(this.modality, color);
+            return true;
+        }
+        return false;
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/direct_speech_generator.d.ts

@@ -0,0 +1,4 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export declare class DirectSpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node: Element, _xml: Element): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/direct_speech_generator.js

@@ -0,0 +1,7 @@
+import * as WalkerUtil from '../walker/walker_util.js';
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export class DirectSpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node, _xml) {
+        return WalkerUtil.getAttribute(node, this.modality);
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/dummy_speech_generator.d.ts

@@ -0,0 +1,4 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export declare class DummySpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(_node: Element, _xml: Element): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/dummy_speech_generator.js

@@ -0,0 +1,6 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export class DummySpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(_node, _xml) {
+        return '';
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/node_speech_generator.d.ts

@@ -0,0 +1,4 @@
+import { TreeSpeechGenerator } from './tree_speech_generator.js';
+export declare class NodeSpeechGenerator extends TreeSpeechGenerator {
+    getSpeech(node: Element, _xml: Element): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/node_speech_generator.js

@@ -0,0 +1,8 @@
+import * as WalkerUtil from '../walker/walker_util.js';
+import { TreeSpeechGenerator } from './tree_speech_generator.js';
+export class NodeSpeechGenerator extends TreeSpeechGenerator {
+    getSpeech(node, _xml) {
+        super.getSpeech(node, _xml);
+        return WalkerUtil.getAttribute(node, this.modality);
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/speech_generator.d.ts

@@ -0,0 +1,18 @@
+import { Attribute } from '../enrich_mathml/enrich_attr.js';
+import { AxisMap } from '../rule_engine/dynamic_cstr.js';
+import { RebuildStree } from '../walker/rebuild_stree.js';
+export interface SpeechGenerator {
+    modality: Attribute;
+    getSpeech(node: Element, xml: Element, root?: Element): string;
+    generateSpeech(node: Element, xml: Element): string;
+    getRebuilt(): RebuildStree;
+    setRebuilt(rebuilt: RebuildStree): void;
+    computeRebuilt(xml: Element, force?: boolean): RebuildStree;
+    setOptions(options: AxisMap): void;
+    setOption(key: string, value: string): void;
+    getOptions(): AxisMap;
+    nextRules(): void;
+    nextStyle(id: string): void;
+    getActionable(actionable: number): string;
+    getLevel(depth: string): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/speech_generator.js

@@ -0,0 +1 @@
+export {};

node_modules/speech-rule-engine/mjs/speech_generator/speech_generator_factory.d.ts

@@ -0,0 +1,2 @@
+import { SpeechGenerator } from './speech_generator.js';
+export declare function generator(type: string): SpeechGenerator;

node_modules/speech-rule-engine/mjs/speech_generator/speech_generator_factory.js

@@ -0,0 +1,20 @@
+import { AdhocSpeechGenerator } from './adhoc_speech_generator.js';
+import { ColorGenerator } from './color_generator.js';
+import { DirectSpeechGenerator } from './direct_speech_generator.js';
+import { DummySpeechGenerator } from './dummy_speech_generator.js';
+import { NodeSpeechGenerator } from './node_speech_generator.js';
+import { SummarySpeechGenerator } from './summary_speech_generator.js';
+import { TreeSpeechGenerator } from './tree_speech_generator.js';
+export function generator(type) {
+    const constructor = generatorMapping[type] || generatorMapping.Direct;
+    return constructor();
+}
+const generatorMapping = {
+    Adhoc: () => new AdhocSpeechGenerator(),
+    Color: () => new ColorGenerator(),
+    Direct: () => new DirectSpeechGenerator(),
+    Dummy: () => new DummySpeechGenerator(),
+    Node: () => new NodeSpeechGenerator(),
+    Summary: () => new SummarySpeechGenerator(),
+    Tree: () => new TreeSpeechGenerator()
+};

node_modules/speech-rule-engine/mjs/speech_generator/speech_generator_util.d.ts

@@ -0,0 +1,14 @@
+import { AuditoryDescription } from '../audio/auditory_description.js';
+import { SemanticNode } from '../semantic_tree/semantic_node.js';
+export declare function computeSpeech(xml: Element): AuditoryDescription[];
+export declare function computeMarkup(tree: Element): string;
+export declare function recomputeMarkup(semantic: SemanticNode): string;
+export declare function addSpeech(mml: Element, semantic: SemanticNode, snode: Element): void;
+export declare function addModality(mml: Element, semantic: SemanticNode, modality: string): void;
+export declare function addPrefix(mml: Element, semantic: SemanticNode): void;
+export declare function retrievePrefix(semantic: SemanticNode): string;
+export declare function connectMactions(node: Element, mml: Element, stree: Element): void;
+export declare function connectAllMactions(mml: Element, stree: Element): void;
+export declare function retrieveSummary(node: Element, options?: {
+    [key: string]: string;
+}): string;

node_modules/speech-rule-engine/mjs/speech_generator/speech_generator_util.js

@@ -0,0 +1,143 @@
+import * as AuralRendering from '../audio/aural_rendering.js';
+import * as DomUtil from '../common/dom_util.js';
+import * as XpathUtil from '../common/xpath_util.js';
+import { Attribute } from '../enrich_mathml/enrich_attr.js';
+import { SpeechRuleEngine } from '../rule_engine/speech_rule_engine.js';
+import { SemanticTree } from '../semantic_tree/semantic_tree.js';
+import * as WalkerUtil from '../walker/walker_util.js';
+export function computeSpeech(xml) {
+    return SpeechRuleEngine.getInstance().evaluateNode(xml);
+}
+function recomputeSpeech(semantic) {
+    const tree = SemanticTree.fromNode(semantic);
+    return computeSpeech(tree.xml());
+}
+export function computeMarkup(tree) {
+    const descrs = computeSpeech(tree);
+    return AuralRendering.markup(descrs);
+}
+export function recomputeMarkup(semantic) {
+    const descrs = recomputeSpeech(semantic);
+    return AuralRendering.markup(descrs);
+}
+export function addSpeech(mml, semantic, snode) {
+    const sxml = DomUtil.querySelectorAllByAttrValue(snode, 'id', semantic.id.toString())[0];
+    const speech = sxml
+        ? AuralRendering.markup(computeSpeech(sxml))
+        : recomputeMarkup(semantic);
+    mml.setAttribute(Attribute.SPEECH, speech);
+}
+export function addModality(mml, semantic, modality) {
+    const markup = recomputeMarkup(semantic);
+    mml.setAttribute(modality, markup);
+}
+export function addPrefix(mml, semantic) {
+    const speech = retrievePrefix(semantic);
+    if (speech) {
+        mml.setAttribute(Attribute.PREFIX, speech);
+    }
+}
+export function retrievePrefix(semantic) {
+    const descrs = computePrefix(semantic);
+    return AuralRendering.markup(descrs);
+}
+function computePrefix(semantic) {
+    const tree = SemanticTree.fromRoot(semantic);
+    const nodes = XpathUtil.evalXPath('.//*[@id="' + semantic.id + '"]', tree.xml());
+    let node = nodes[0];
+    if (nodes.length > 1) {
+        node = nodeAtPosition(semantic, nodes) || node;
+    }
+    return node
+        ? SpeechRuleEngine.getInstance().runInSetting({
+            modality: 'prefix',
+            domain: 'default',
+            style: 'default',
+            strict: true,
+            speech: true
+        }, function () {
+            return SpeechRuleEngine.getInstance().evaluateNode(node);
+        })
+        : [];
+}
+function nodeAtPosition(semantic, nodes) {
+    const node = nodes[0];
+    if (!semantic.parent) {
+        return node;
+    }
+    const path = [];
+    while (semantic) {
+        path.push(semantic.id);
+        semantic = semantic.parent;
+    }
+    const pathEquals = function (xml, path) {
+        while (path.length &&
+            path.shift().toString() === xml.getAttribute('id') &&
+            xml.parentNode &&
+            xml.parentNode.parentNode) {
+            xml = xml.parentNode.parentNode;
+        }
+        return !path.length;
+    };
+    for (let i = 0, xml; (xml = nodes[i]); i++) {
+        if (pathEquals(xml, path.slice())) {
+            return xml;
+        }
+    }
+    return node;
+}
+export function connectMactions(node, mml, stree) {
+    const mactions = DomUtil.querySelectorAll(mml, 'maction');
+    for (let i = 0, maction; (maction = mactions[i]); i++) {
+        const aid = maction.getAttribute('id');
+        const span = DomUtil.querySelectorAllByAttrValue(node, 'id', aid)[0];
+        if (!span) {
+            continue;
+        }
+        const lchild = maction.childNodes[1];
+        const mid = lchild.getAttribute(Attribute.ID);
+        let cspan = WalkerUtil.getBySemanticId(node, mid);
+        if (cspan && cspan.getAttribute(Attribute.TYPE) !== 'dummy') {
+            continue;
+        }
+        cspan = span.childNodes[0];
+        if (cspan.getAttribute('sre-highlighter-added')) {
+            continue;
+        }
+        const pid = lchild.getAttribute(Attribute.PARENT);
+        if (pid) {
+            cspan.setAttribute(Attribute.PARENT, pid);
+        }
+        cspan.setAttribute(Attribute.TYPE, 'dummy');
+        cspan.setAttribute(Attribute.ID, mid);
+        cspan.setAttribute('role', 'treeitem');
+        cspan.setAttribute('aria-level', lchild.getAttribute('aria-level'));
+        const cst = DomUtil.querySelectorAllByAttrValue(stree, 'id', mid)[0];
+        cst.setAttribute('alternative', mid);
+    }
+}
+export function connectAllMactions(mml, stree) {
+    const mactions = DomUtil.querySelectorAll(mml, 'maction');
+    for (let i = 0, maction; (maction = mactions[i]); i++) {
+        const lchild = maction.childNodes[1];
+        const mid = lchild.getAttribute(Attribute.ID);
+        const cst = DomUtil.querySelectorAllByAttrValue(stree, 'id', mid)[0];
+        cst.setAttribute('alternative', mid);
+    }
+}
+export function retrieveSummary(node, options = {}) {
+    const descrs = computeSummary(node, options);
+    return AuralRendering.markup(descrs);
+}
+function computeSummary(node, options = {}) {
+    const preOption = options.locale ? { locale: options.locale } : {};
+    return node
+        ? SpeechRuleEngine.getInstance().runInSetting(Object.assign(preOption, {
+            modality: 'summary',
+            strict: false,
+            speech: true
+        }), function () {
+            return SpeechRuleEngine.getInstance().evaluateNode(node);
+        })
+        : [];
+}

node_modules/speech-rule-engine/mjs/speech_generator/summary_speech_generator.d.ts

@@ -0,0 +1,4 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export declare class SummarySpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node: Element, _xml: Element): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/summary_speech_generator.js

@@ -0,0 +1,14 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+import * as SpeechGeneratorUtil from './speech_generator_util.js';
+import { setup as EngineSetup } from '../common/engine_setup.js';
+import { Attribute } from '../enrich_mathml/enrich_attr.js';
+export class SummarySpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node, _xml) {
+        EngineSetup(this.getOptions());
+        const id = node.getAttribute(Attribute.ID);
+        const snode = this.getRebuilt().streeRoot.querySelectorAll((x) => x.id.toString() === id)[0];
+        SpeechGeneratorUtil.addModality(node, snode, this.modality);
+        const speech = node.getAttribute(Attribute.SUMMARY);
+        return speech;
+    }
+}

node_modules/speech-rule-engine/mjs/speech_generator/tree_speech_generator.d.ts

@@ -0,0 +1,4 @@
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+export declare class TreeSpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node: Element, xml: Element, root?: Element): string;
+}

node_modules/speech-rule-engine/mjs/speech_generator/tree_speech_generator.js

@@ -0,0 +1,31 @@
+import { Attribute } from '../enrich_mathml/enrich_attr.js';
+import * as WalkerUtil from '../walker/walker_util.js';
+import { AbstractSpeechGenerator } from './abstract_speech_generator.js';
+import * as SpeechGeneratorUtil from './speech_generator_util.js';
+export class TreeSpeechGenerator extends AbstractSpeechGenerator {
+    getSpeech(node, xml, root = null) {
+        if (this.getRebuilt()) {
+            SpeechGeneratorUtil.connectMactions(node, xml, this.getRebuilt().xml);
+        }
+        const speech = this.generateSpeech(node, xml);
+        const nodes = this.getRebuilt().nodeDict;
+        for (const [key, snode] of Object.entries(nodes)) {
+            const innerMml = WalkerUtil.getBySemanticId(xml, key);
+            const innerNode = WalkerUtil.getBySemanticId(node, key) ||
+                (root && WalkerUtil.getBySemanticId(root, key));
+            if (!innerMml || !innerNode) {
+                continue;
+            }
+            if (!this.modality || this.modality === Attribute.SPEECH) {
+                SpeechGeneratorUtil.addSpeech(innerNode, snode, this.getRebuilt().xml);
+            }
+            else {
+                SpeechGeneratorUtil.addModality(innerNode, snode, this.modality);
+            }
+            if (this.modality === Attribute.SPEECH) {
+                SpeechGeneratorUtil.addPrefix(innerNode, snode);
+            }
+        }
+        return speech;
+    }
+}