app/node_modules/speech-rule-engine/mjs/semantic_tree/semantic_pred.js

import { NamedSymbol, SemanticMap } from './semantic_attr.js';
import { SemanticRole, SemanticType, SemanticSecondary } from './semantic_meaning.js';
import { getEmbellishedInner } from './semantic_util.js';
export function isType(node, attr) {
    return node.type === attr;
}
function embellishedType(node, attr) {
    return node.embellished === attr;
}
export function isRole(node, attr) {
    return node.role === attr;
}
export function isAccent(node) {
    return (isType(node, SemanticType.FENCE) ||
        isType(node, SemanticType.PUNCTUATION) ||
        isType(node, SemanticType.OPERATOR) ||
        isType(node, SemanticType.RELATION));
}
export function isSimpleFunctionScope(node) {
    const children = node.childNodes;
    if (children.length === 0) {
        return true;
    }
    if (children.length > 1) {
        return false;
    }
    const child = children[0];
    if (child.type === SemanticType.INFIXOP) {
        if (child.role !== SemanticRole.IMPLICIT) {
            return false;
        }
        if (child.childNodes.some((x) => isType(x, SemanticType.INFIXOP))) {
            return false;
        }
    }
    return true;
}
export function isPrefixFunctionBoundary(node) {
    return ((isOperator(node) && !isRole(node, SemanticRole.DIVISION)) ||
        isType(node, SemanticType.APPL) ||
        isGeneralFunctionBoundary(node));
}
export function isBigOpBoundary(node) {
    return isOperator(node) || isGeneralFunctionBoundary(node);
}
export function isIntegralDxBoundary(firstNode, secondNode) {
    return (!!secondNode &&
        isType(secondNode, SemanticType.IDENTIFIER) &&
        SemanticMap.Secondary.has(firstNode.textContent, SemanticSecondary.D));
}
export function isIntegralDxBoundarySingle(node) {
    if (isType(node, SemanticType.IDENTIFIER)) {
        const firstChar = node.textContent[0];
        return (firstChar &&
            node.textContent[1] &&
            SemanticMap.Secondary.has(firstChar, SemanticSecondary.D));
    }
    return false;
}
export function isGeneralFunctionBoundary(node) {
    return isRelation(node) || isPunctuation(node);
}
export function isEmbellished(node) {
    if (node.embellished) {
        return node.embellished;
    }
    if (isEmbellishedType(node.type)) {
        return node.type;
    }
    return null;
}
function isEmbellishedType(type) {
    return (type === SemanticType.OPERATOR ||
        type === SemanticType.RELATION ||
        type === SemanticType.FENCE ||
        type === SemanticType.PUNCTUATION);
}
export function isOperator(node) {
    return (isType(node, SemanticType.OPERATOR) ||
        embellishedType(node, SemanticType.OPERATOR));
}
export function isRelation(node) {
    return (isType(node, SemanticType.RELATION) ||
        embellishedType(node, SemanticType.RELATION));
}
export function isPunctuation(node) {
    return (isType(node, SemanticType.PUNCTUATION) ||
        embellishedType(node, SemanticType.PUNCTUATION));
}
export function isFence(node) {
    return (isType(node, SemanticType.FENCE) ||
        embellishedType(node, SemanticType.FENCE));
}
export function isElligibleEmbellishedFence(node) {
    if (!node || !isFence(node)) {
        return false;
    }
    if (!node.embellished) {
        return true;
    }
    return recurseBaseNode(node);
}
function bothSide(node) {
    return (isType(node, SemanticType.TENSOR) &&
        (!isType(node.childNodes[1], SemanticType.EMPTY) ||
            !isType(node.childNodes[2], SemanticType.EMPTY)) &&
        (!isType(node.childNodes[3], SemanticType.EMPTY) ||
            !isType(node.childNodes[4], SemanticType.EMPTY)));
}
function recurseBaseNode(node) {
    if (!node.embellished) {
        return true;
    }
    if (bothSide(node)) {
        return false;
    }
    if (isRole(node, SemanticRole.CLOSE) && isType(node, SemanticType.TENSOR)) {
        return false;
    }
    if (isRole(node, SemanticRole.OPEN) &&
        (isType(node, SemanticType.SUBSCRIPT) ||
            isType(node, SemanticType.SUPERSCRIPT))) {
        return false;
    }
    return recurseBaseNode(node.childNodes[0]);
}
export function isTableOrMultiline(node) {
    return (!!node &&
        (isType(node, SemanticType.TABLE) || isType(node, SemanticType.MULTILINE)));
}
export function tableIsMatrixOrVector(node) {
    return (!!node && isFencedElement(node) && isTableOrMultiline(node.childNodes[0]));
}
export function isFencedElement(node) {
    return (!!node &&
        isType(node, SemanticType.FENCED) &&
        (isRole(node, SemanticRole.LEFTRIGHT) || isNeutralFence(node)) &&
        node.childNodes.length === 1);
}
export function tableIsCases(_table, prevNodes) {
    return (prevNodes.length > 0 &&
        isRole(prevNodes[prevNodes.length - 1], SemanticRole.OPENFENCE));
}
export function tableIsMultiline(table) {
    return table.childNodes.every(function (row) {
        const length = row.childNodes.length;
        return length <= 1;
    });
}
export function lineIsLabelled(line) {
    return (isType(line, SemanticType.LINE) &&
        line.contentNodes.length &&
        isRole(line.contentNodes[0], SemanticRole.LABEL));
}
export function isBinomial(table) {
    return table.childNodes.length === 2;
}
export function isLimitBase(node) {
    return (isType(node, SemanticType.LARGEOP) ||
        isType(node, SemanticType.LIMBOTH) ||
        isType(node, SemanticType.LIMLOWER) ||
        isType(node, SemanticType.LIMUPPER) ||
        (isType(node, SemanticType.FUNCTION) &&
            isRole(node, SemanticRole.LIMFUNC)) ||
        ((isType(node, SemanticType.OVERSCORE) ||
            isType(node, SemanticType.UNDERSCORE)) &&
            isLimitBase(node.childNodes[0])));
}
export function isSimpleFunctionHead(node) {
    return (node.type === SemanticType.IDENTIFIER ||
        node.role === SemanticRole.LATINLETTER ||
        node.role === SemanticRole.GREEKLETTER ||
        node.role === SemanticRole.OTHERLETTER);
}
export function singlePunctAtPosition(nodes, puncts, position) {
    return (puncts.length === 1 &&
        (nodes[position].type === SemanticType.PUNCTUATION ||
            nodes[position].embellished === SemanticType.PUNCTUATION) &&
        nodes[position] === puncts[0]);
}
export function isSimpleFunction(node) {
    return (isType(node, SemanticType.IDENTIFIER) &&
        isRole(node, SemanticRole.SIMPLEFUNC));
}
function isLeftBrace(node) {
    const leftBrace = ['{', '﹛', '｛'];
    return !!node && leftBrace.indexOf(node.textContent) !== -1;
}
function isRightBrace(node) {
    const rightBrace = ['}', '﹜', '｝'];
    return !!node && rightBrace.indexOf(node.textContent) !== -1;
}
export function isSetNode(node) {
    return (isLeftBrace(node.contentNodes[0]) && isRightBrace(node.contentNodes[1]));
}
const illegalSingleton = [
    SemanticType.PUNCTUATION,
    SemanticType.PUNCTUATED,
    SemanticType.RELSEQ,
    SemanticType.MULTIREL,
    SemanticType.TABLE,
    SemanticType.MULTILINE,
    SemanticType.CASES,
    SemanticType.INFERENCE
];
const scriptedElement = [
    SemanticType.LIMUPPER,
    SemanticType.LIMLOWER,
    SemanticType.LIMBOTH,
    SemanticType.SUBSCRIPT,
    SemanticType.SUPERSCRIPT,
    SemanticType.UNDERSCORE,
    SemanticType.OVERSCORE,
    SemanticType.TENSOR
];
export function isSingletonSetContent(node) {
    const type = node.type;
    if (illegalSingleton.indexOf(type) !== -1 ||
        (type === SemanticType.INFIXOP && node.role !== SemanticRole.IMPLICIT)) {
        return false;
    }
    if (type === SemanticType.FENCED) {
        return node.role === SemanticRole.LEFTRIGHT
            ? isSingletonSetContent(node.childNodes[0])
            : true;
    }
    if (scriptedElement.indexOf(type) !== -1) {
        return isSingletonSetContent(node.childNodes[0]);
    }
    return true;
}
function isNumber(node) {
    return (node.type === SemanticType.NUMBER &&
        (node.role === SemanticRole.INTEGER || node.role === SemanticRole.FLOAT));
}
export function isUnitCounter(node) {
    return (isNumber(node) ||
        node.role === SemanticRole.VULGAR ||
        node.role === SemanticRole.MIXED);
}
export function isPureUnit(node) {
    const children = node.childNodes;
    return (node.role === SemanticRole.UNIT &&
        (!children.length || children[0].role === SemanticRole.UNIT));
}
export function isUnitProduct(node) {
    const children = node.childNodes;
    return (node.type === SemanticType.INFIXOP &&
        (node.role === SemanticRole.MULTIPLICATION ||
            node.role === SemanticRole.IMPLICIT) &&
        children.length &&
        (isPureUnit(children[0]) || isUnitCounter(children[0])) &&
        node.childNodes.slice(1).every(isPureUnit));
}
export function isImplicit(node) {
    return (node.type === SemanticType.INFIXOP &&
        (node.role === SemanticRole.IMPLICIT ||
            (node.role === SemanticRole.UNIT &&
                !!node.contentNodes.length &&
                node.contentNodes[0].textContent === NamedSymbol.invisibleTimes)));
}
export function isImplicitOp(node) {
    return (node.type === SemanticType.INFIXOP && node.role === SemanticRole.IMPLICIT);
}
export function isNeutralFence(fence) {
    return (fence.role === SemanticRole.NEUTRAL || fence.role === SemanticRole.METRIC);
}
export function compareNeutralFences(fence1, fence2) {
    return (isNeutralFence(fence1) &&
        isNeutralFence(fence2) &&
        getEmbellishedInner(fence1).textContent ===
            getEmbellishedInner(fence2).textContent);
}
export function elligibleLeftNeutral(fence) {
    if (!isNeutralFence(fence)) {
        return false;
    }
    if (!fence.embellished) {
        return true;
    }
    if (fence.type === SemanticType.SUPERSCRIPT ||
        fence.type === SemanticType.SUBSCRIPT) {
        return false;
    }
    if (fence.type === SemanticType.TENSOR &&
        (fence.childNodes[3].type !== SemanticType.EMPTY ||
            fence.childNodes[4].type !== SemanticType.EMPTY)) {
        return false;
    }
    return true;
}
export function elligibleRightNeutral(fence) {
    if (!isNeutralFence(fence)) {
        return false;
    }
    if (!fence.embellished) {
        return true;
    }
    if (fence.type === SemanticType.TENSOR &&
        (fence.childNodes[1].type !== SemanticType.EMPTY ||
            fence.childNodes[2].type !== SemanticType.EMPTY)) {
        return false;
    }
    return true;
}
export function isMembership(element) {
    return [
        SemanticRole.ELEMENT,
        SemanticRole.NONELEMENT,
        SemanticRole.REELEMENT,
        SemanticRole.RENONELEMENT
    ].includes(element.role);
}