@fw-components/formula-editor 2.0.3-formula-editor.2 → 2.0.7-cline-formulaeditor.0

package/dist/formula-editor/src/parser.js

@@ -0,0 +1,461 @@
+import Big from "big.js";
+import { Expectation, Queue, Stack } from "./helpers.js";
+import { Recommender } from "./recommendor.js";
+export class Parser {
+    static { this.MAX_FORMULA_LENGTH = 1000; }
+    static { this.CACHE_SIZE = 100; }
+    constructor(variables, minSuggestionLen) {
+        this._parseCache = new Map();
+        this._rpnCache = new Map();
+        this.mathematicalOperators = new Set(["^", "+", "-", "*", "/", "sin", "cos", "tan", "sqrt", "log"]);
+        this.constants = new Map([
+            ["pi", Math.PI],
+            ["e", Math.E]
+        ]);
+        this.operatorPrecedence = {
+            "^": 3,
+            "/": 2,
+            "*": 2,
+            "+": 1,
+            "-": 1,
+        };
+        this.variables = variables;
+        this._recommender = new Recommender(this.variables, minSuggestionLen);
+    }
+    clearCacheIfNeeded() {
+        if (this._parseCache.size > Parser.CACHE_SIZE) {
+            const entriesToDelete = Array.from(this._parseCache.keys())
+                .slice(0, Math.floor(Parser.CACHE_SIZE / 2));
+            entriesToDelete.forEach(key => this._parseCache.delete(key));
+        }
+        if (this._rpnCache.size > Parser.CACHE_SIZE) {
+            const entriesToDelete = Array.from(this._rpnCache.keys())
+                .slice(0, Math.floor(Parser.CACHE_SIZE / 2));
+            entriesToDelete.forEach(key => this._rpnCache.delete(key));
+        }
+    }
+    parseInput(formula, prevCurPos = null, recommendation = null) {
+        // Check formula length
+        if (formula.length > Parser.MAX_FORMULA_LENGTH) {
+            return {
+                recommendations: null,
+                formattedContent: null,
+                formattedString: null,
+                newCursorPosition: prevCurPos ?? -1,
+                errorString: `Formula length exceeds maximum limit of ${Parser.MAX_FORMULA_LENGTH} characters`
+            };
+        }
+        // Check cache for exact matches without recommendation
+        const cacheKey = `${formula}-${prevCurPos}`;
+        if (!recommendation && this._parseCache.has(cacheKey)) {
+            return { ...this._parseCache.get(cacheKey) };
+        }
+        let tokens = formula.match(/'[^']*'|\d+|[A-Za-z_][A-Za-z0-9_]*|[-+(),*^/:?\s]|sin|cos|tan|sqrt|log/g);
+        // Stores the positions of opening parentheses. This allows us to
+        // show "Unclosed parenthesis error" for positions which are far behind
+        // our current token
+        let parentheses = new Stack();
+        // The HTML formatted string which we eventually show on the view.
+        let formattedString = ``;
+        // The expectation that we have for the current token.
+        let expectation = Expectation.VARIABLE;
+        // Position of the current token in the formula string.
+        let currentPosition = 0;
+        // Previous 'token' (not a space or a new line) that we just encountered.
+        let previousToken = "";
+        let currentTokens = "";
+        // The object that we return as the output of the parsing result.
+        let parseOutput = {
+            recommendations: null,
+            formattedContent: null,
+            formattedString: null,
+            newCursorPosition: prevCurPos ?? -1,
+            errorString: null,
+        };
+        if (!formula.trim()) {
+            if (recommendation) {
+                formattedString = `<span class="wysiwygInternals">${recommendation}</span>`;
+                currentPosition += recommendation.length;
+                const parser = new DOMParser();
+                const doc = parser.parseFromString(formattedString, "text/html");
+                parseOutput.formattedContent = doc.querySelector("body");
+                parseOutput.formattedString = formattedString;
+                parseOutput.newCursorPosition = recommendation.length;
+                return parseOutput;
+            }
+        }
+        tokens?.forEach((token) => {
+            // It is a number if it's in the defined variables, constants, or
+            // it's a valid number literal.
+            let isNumber = this.variables.has(token) || this.constants.has(token) || !Number.isNaN(Number(token)), isOperator = this.mathematicalOperators.has(token), isSpace = token.trim() == "", isBracket = token == "(" || token == ")";
+            // We don't really want anything for the spaces, other than simply
+            // adding them back to the view.
+            if (isSpace) {
+                formattedString = `${formattedString}${token}`;
+                currentPosition += token.length;
+                return;
+            }
+            // If the cursor position is 'inside` the current token:
+            //
+            // 1. If we've got a recommendation to add, simply replace the
+            //    word with the recommendation.
+            // 2. Ask the recommendor to fetch recommendations for this specific
+            //    token/word.
+            if (currentPosition <= prevCurPos &&
+                currentPosition + token.length >= prevCurPos) {
+                // If a recommendation was provided, replace the correspoding
+                // word with it and move the cursor forward, accordingly.
+                if (recommendation) {
+                    // Since we are sure that the recommendation will always correspond
+                    // to a variable.
+                    isNumber = true;
+                    if (this.mathematicalOperators.has(token)) {
+                        recommendation = token + recommendation;
+                    }
+                    // If the new cursor length somehow becomes larger than the
+                    // length of the formula string, setting the caret to that
+                    // length will move the caret to the start. Although this overflow
+                    // won't happen, but still, this check prevents that.
+                    parseOutput.newCursorPosition = Math.min(parseOutput.newCursorPosition +
+                        recommendation.length -
+                        token.length, formula.length + recommendation.length - token.length);
+                    token = recommendation;
+                    recommendation = null;
+                }
+                // Fetch recommendations nonetheless.
+                parseOutput.recommendations =
+                    this._recommender.getRecommendation(token);
+            }
+            let tokenClassName = "";
+            // Don't check for errors if an error has already been encountered.
+            if (expectation != Expectation.UNDEFINED) {
+                // Unnecessary closing parenthesis
+                if (parentheses.isEmpty() && token == ")") {
+                    parseOutput.errorString = `Unexpected ')' at position ${currentPosition}`;
+                    tokenClassName += " error";
+                    expectation = Expectation.UNDEFINED;
+                }
+                // Operator or ) after an operator. Eg: `23 / *` or `23 / )`
+                // Unary `+` and `-` are not an error as they might represent
+                // a positive or negative number respectively. But they will still
+                // be an error if the formula ends with them.
+                else if (expectation == Expectation.VARIABLE &&
+                    !isNumber &&
+                    token != "(" &&
+                    !((token == "-" || token == "+") &&
+                        (!currentTokens.trim() || this.mathematicalOperators.has(previousToken)))) {
+                    parseOutput.errorString = `Expected variable/number at position ${currentPosition}`;
+                    tokenClassName += " error";
+                    expectation = Expectation.UNDEFINED;
+                }
+                // Number/Variable after the same. Eg: `a a` or `420 420`.
+                // Having a ) is fine. Eg: `23)` might be representing `(23 + 23)
+                else if (expectation == Expectation.OPERATOR &&
+                    !isOperator &&
+                    token != ")") {
+                    parseOutput.errorString = `Expected mathematical operator at position ${currentPosition}`;
+                    tokenClassName += " error";
+                    expectation = Expectation.UNDEFINED;
+                }
+                // Unknown symbol/variable/word
+                else if (!(isNumber || isOperator || isBracket)) {
+                    parseOutput.errorString = `Unknown word at position ${currentPosition}`;
+                    tokenClassName += " error";
+                    expectation = Expectation.UNDEFINED;
+                }
+                // The case of division by zero. Since we can't know if an expression evaluates
+                // to zero or not, that case can only be handled during calculation.
+                else if (isNumber &&
+                    previousToken == "/" &&
+                    (this.variables.get(token) == 0 || Number(token) == 0)) {
+                    parseOutput.errorString = `Division by zero at position ${currentPosition}`;
+                    tokenClassName += " error";
+                    expectation = Expectation.UNDEFINED;
+                }
+                // Empty brackets. Default might be takn as 0, but that will only make sense
+                // in addition and subtraction and not in other operators, so making this
+                // case an error makes more sense.
+                else if (previousToken == "(" && token == ")") {
+                    parseOutput.errorString = `Empty brackets at position ${currentPosition}`;
+                    tokenClassName += " error";
+                    expectation = Expectation.UNDEFINED;
+                }
+            }
+            // Setting the expectation for the next token, if we have not encountered an
+            // error already.
+            if (expectation != Expectation.UNDEFINED) {
+                if (token == "(" || isOperator) {
+                    expectation = Expectation.VARIABLE;
+                }
+                else if (token == ")" || isNumber) {
+                    expectation = Expectation.OPERATOR;
+                }
+            }
+            if (token == "(") {
+                parentheses.push(currentPosition);
+                tokenClassName += " bracket";
+            }
+            else if (token == ")") {
+                parentheses.pop();
+                tokenClassName += " bracket";
+            }
+            else if (isOperator) {
+                tokenClassName += " operator";
+            }
+            else if (expectation == Expectation.UNDEFINED) {
+                tokenClassName += " error";
+            }
+            // Since not using ShadowDOM, having these specific class names will prevent
+            // name collision.
+            formattedString = `${formattedString}<span class="wysiwygInternals ${tokenClassName}">${token}</span>`;
+            currentPosition += token.length;
+            previousToken = token;
+            currentTokens += token;
+        });
+        if (recommendation) {
+            parseOutput.newCursorPosition = Math.min(parseOutput.newCursorPosition +
+                recommendation.length, formula.length + recommendation.length);
+            formattedString = `${formattedString}<span class="wysiwygInternals">${recommendation}</span>`;
+        }
+        // If the formula ends with a mathematical operator, or has unclosed `(`
+        if (this.mathematicalOperators.has(previousToken)) {
+            // parseOutput.errorString = "Unexpected ending of formula.";
+            parseOutput.recommendations = Array.from(this.variables.keys());
+        }
+        else if (!parentheses.isEmpty()) {
+            parseOutput.errorString = `Unclosed '(' at position: ${parentheses.top()}`;
+        }
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(formattedString, "text/html");
+        parseOutput.formattedContent = doc.querySelector("body");
+        parseOutput.formattedString = formattedString;
+        // Cache the result if no recommendation was used
+        if (!recommendation) {
+            this._parseCache.set(cacheKey, { ...parseOutput });
+            this.clearCacheIfNeeded();
+        }
+        return parseOutput;
+    }
+    buildRPN(formula) {
+        // Check cache
+        if (this._rpnCache.has(formula)) {
+            const cached = this._rpnCache.get(formula);
+            return cached ? cached.clone() : null;
+        }
+        if (this.parseInput(formula).errorString) {
+            return null;
+        }
+        const tokens = formula
+            .match(/'[^']*'|\d+|[A-Za-z_][A-Za-z0-9_]*|[-+(),*^/:?\s]/g)
+            ?.filter((el) => !/\s+/.test(el) && el !== "");
+        // Handling the special case of unary `-` and `+`.
+        let previousToken = "";
+        let carriedToken = null;
+        const parsedTokens = [];
+        let currentTokens = "";
+        for (const token of tokens) {
+            if ((token == "+" || token == "-") &&
+                (!currentTokens.trim() || this.mathematicalOperators.has(previousToken))) {
+                carriedToken = token;
+            }
+            else if (carriedToken) {
+                parsedTokens.push(carriedToken + token);
+                carriedToken = null;
+            }
+            else {
+                parsedTokens.push(token);
+            }
+            previousToken = token;
+            currentTokens += token;
+        }
+        /**
+         * Shunting Yard Algorithm (EW Dijkstra)
+         */
+        const operatorStack = new Stack();
+        const outputQueue = new Queue();
+        for (const token of parsedTokens) {
+            if (token == "(") {
+                operatorStack.push("(");
+            }
+            else if (token == ")") {
+                while (operatorStack.top() != "(") {
+                    outputQueue.enqueue(operatorStack.pop());
+                }
+                operatorStack.pop();
+            }
+            else if (this.mathematicalOperators.has(token)) {
+                while (this.mathematicalOperators.has(operatorStack.top()) &&
+                    this.operatorPrecedence[token] <=
+                        this.operatorPrecedence[operatorStack.top()]) {
+                    outputQueue.enqueue(operatorStack.pop());
+                }
+                operatorStack.push(token);
+            }
+            else if (!Number.isNaN(token) && token != "") {
+                outputQueue.enqueue(token);
+            }
+        }
+        while (operatorStack.top()) {
+            outputQueue.enqueue(operatorStack.pop());
+        }
+        // Cache the result
+        this._rpnCache.set(formula, outputQueue ? outputQueue.clone() : null);
+        this.clearCacheIfNeeded();
+        return outputQueue;
+    }
+    addParentheses(formula) {
+        const rpn = this.buildRPN(formula);
+        if (!rpn) {
+            return null;
+        }
+        const lexedRPN = [];
+        while (!rpn.isEmpty()) {
+            lexedRPN.push(rpn.dequeue());
+        }
+        // Stores the operators that we encounter in the RPN
+        let operatorStack = new Stack();
+        // Stores the `results`, which are essentially individual groups
+        // of tokens showing a meaningful value.
+        let resultStack = new Stack();
+        lexedRPN.forEach((symbol) => {
+            let parsedLeftExpression, parsedRightExpression;
+            // If we encounter a number or a variable in the RPN, it is itself
+            // a calculated entity (say a result in itself), needs no modification
+            // and can be directly put into the result stack.
+            if (this.variables.has(symbol) ||
+                (!isNaN(parseFloat(symbol)) && isFinite(parseFloat(symbol)))) {
+                resultStack.push(symbol);
+                operatorStack.push(null);
+            }
+            // If it is not a number/variable then it is an operator. We will
+            // take out previous operators from the `operatorStack`, compare
+            // them with the current one, adds brackets accordingly to the `results`
+            // around it, and then finally add it to the `operatorStack` for
+            // future reference.
+            else if (Object.keys(this.operatorPrecedence).includes(symbol)) {
+                let [rightExpression, leftExpression, operatorA, operatorB] = [
+                    resultStack.pop(),
+                    resultStack.pop(),
+                    operatorStack.pop(),
+                    operatorStack.pop(),
+                ];
+                // The conditions that govern when to show a parenthesis.
+                if (this.operatorPrecedence[operatorB] <=
+                    this.operatorPrecedence[symbol] ||
+                    (this.operatorPrecedence[operatorB] ===
+                        this.operatorPrecedence[symbol] &&
+                        ["/", "-"].includes(symbol))) {
+                    parsedLeftExpression = `(${leftExpression})`;
+                }
+                else {
+                    parsedLeftExpression = leftExpression;
+                }
+                if (this.operatorPrecedence[operatorA] <=
+                    this.operatorPrecedence[symbol] ||
+                    (this.operatorPrecedence[operatorA] ===
+                        this.operatorPrecedence[symbol] &&
+                        ["/", "-"].includes(symbol))) {
+                    parsedRightExpression = `(${rightExpression})`;
+                }
+                else {
+                    parsedRightExpression = rightExpression;
+                }
+                // The bracket included expression is now itself a `result`
+                resultStack.push(`${parsedLeftExpression} ${symbol} ${parsedRightExpression}`);
+                operatorStack.push(symbol);
+            }
+            else
+                throw `${symbol} is not a recognized symbol`;
+        });
+        if (!resultStack.isEmpty()) {
+            return resultStack.pop();
+        }
+        else
+            throw `${lexedRPN} is not a correct RPN`;
+    }
+    evaluateFunction(name, value) {
+        switch (name) {
+            case 'sin': return Math.sin(value);
+            case 'cos': return Math.cos(value);
+            case 'tan': return Math.tan(value);
+            case 'sqrt':
+                if (value < 0)
+                    throw new Error('Cannot calculate square root of negative number');
+                return Math.sqrt(value);
+            case 'log':
+                if (value <= 0)
+                    throw new Error('Cannot calculate logarithm of non-positive number');
+                return Math.log(value);
+            default: throw new Error(`Unknown function: ${name}`);
+        }
+    }
+    calculate(formula) {
+        let rpn = this.buildRPN(formula);
+        let calculationResult = {
+            result: undefined,
+            errorString: null,
+        };
+        if (!rpn) {
+            return calculationResult;
+        }
+        let calcStack = new Stack();
+        while (!rpn.isEmpty()) {
+            const frontItem = rpn.dequeue();
+            if (!this.mathematicalOperators.has(frontItem)) {
+                calcStack.push(Big(Number.parseFloat(this.variables.get(frontItem)?.toString() ?? frontItem)));
+            }
+            else {
+                let operator = frontItem;
+                let numB = calcStack.pop();
+                let numA = calcStack.pop();
+                try {
+                    // Handle constants
+                    if (this.constants.has(frontItem)) {
+                        calcStack.push(Big(this.constants.get(frontItem)));
+                        continue;
+                    }
+                    // Handle functions
+                    if (['sin', 'cos', 'tan', 'sqrt', 'log'].includes(frontItem)) {
+                        const value = calcStack.pop();
+                        try {
+                            calcStack.push(Big(this.evaluateFunction(frontItem, parseFloat(value.toString()))));
+                        }
+                        catch (error) {
+                            calculationResult.errorString = error.message;
+                            return calculationResult;
+                        }
+                        continue;
+                    }
+                    switch (operator) {
+                        case "+":
+                            calcStack.push(Big(numA).add(Big(numB)));
+                            break;
+                        case "-":
+                            calcStack.push(Big(numA).sub(Big(numB)));
+                            break;
+                        case "*":
+                            calcStack.push(Big(numA).mul(Big(numB)));
+                            break;
+                        case "/":
+                            if (parseFloat(Big(numB).toString()) == 0) {
+                                calculationResult.errorString = "Division by zero encountered";
+                                return calculationResult;
+                            }
+                            calcStack.push(Big(numA).div(Big(numB)));
+                            break;
+                        // Big.js doesn't support exponentiating a Big to a Big, which
+                        // is obvious due to performance overheads. Use this case with care.
+                        case "^":
+                            calcStack.push(Big(numA).pow(parseFloat(Big(numB).toString())));
+                    }
+                }
+                catch (error) {
+                    calculationResult.errorString = error;
+                    return calculationResult;
+                }
+            }
+        }
+        calculationResult.result = parseFloat(calcStack.top().toString());
+        return calculationResult;
+    }
+}

package/dist/formula-editor/src/recommendor.js

@@ -0,0 +1,18 @@
+import { matchSorter } from 'match-sorter';
+export class Recommender {
+    constructor(variables, minSuggestionLen) {
+        this._minimumSuggestionLength = minSuggestionLen > 0 ? minSuggestionLen : 1;
+        this.variableList = Array.from(variables.keys());
+    }
+    getRecommendation(word) {
+        if (word.length < this._minimumSuggestionLength) {
+            return null;
+        }
+        const recommendations = matchSorter(this.variableList, word);
+        if (recommendations.length === 0 ||
+            (recommendations.length === 1 && recommendations[0] === word)) {
+            return null;
+        }
+        return recommendations;
+    }
+}

package/dist/formula-editor/src/styles/formula-editor-styles.js

@@ -0,0 +1,149 @@
+import { css } from "lit";
+export const FormulaEditorStyles = css `
+
+  .formula-editor-label {
+    display: block;
+    font-size: var(--fe-label-font-size, 0.8rem);
+    color: var(--fe-label-color, #515151);
+    margin-bottom: var(--fe-label-margin-bottom, 1px);
+  }
+
+  :host {
+    display: block;
+    position: relative;
+  }
+
+  #wysiwyg-editor {
+    display: inline-block;
+    padding: var(--fe-padding, 8px);
+    caret-color: var(--fe-caret-color, #fff);
+    color: var(--fe-text-color, #f7f1ff);
+    line-height: 1.1;
+    width:  var(--fe-width, 100%);
+    height: var(--fe-height, 60%);
+    border-radius: var(--fe-border-radius, 4px);
+    overflow: auto;
+    border: var(--fe-border, 2px solid black);
+    border-bottom: var(--fe-border-bottom, 0px solid black);
+    outline: none;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+    white-space: pre-wrap;
+    background-color: var(--fe-background-color, #222222);
+    margin: 0px;
+    box-sizing: border-box;
+    /* position: relative; */
+  }
+
+  #wysiwyg-editor:empty:before {
+  content: attr(placeholder);
+  color: var(--fe-placeholder-color,grey);
+  pointer-events: none;
+  }
+
+  #wysiwyg-editor:focus {
+    border-color: var(--fe-focus-border-color, #7c5dfa);
+    box-shadow: 0 0 0 2px var(--fe-focus-shadow-color, rgba(124, 93, 250, 0.2));
+  }
+
+  /* Responsive styles */
+  @media (max-width: 768px) {
+    #wysiwyg-editor {
+      font-size: var(--fe-mobile-font-size, 14px);
+      padding: var(--fe-mobile-padding, 6px);
+    }
+  }
+
+  .wysiwygInternals.error {
+    text-decoration: underline;
+    -webkit-text-decoration-color: var(--fe-err-underline-color, #fc514f);
+    text-decoration-color: var(--fe-err-underline-color, #fc514f);
+    -webkit-text-decoration-style: wavy;
+    text-decoration-style: wavy;
+    /* text-decoration-thickness: 1px; */
+    text-decoration-color: var(--fe-err-underline-color, red);
+  }
+
+  .wysiwygInternals.bracket {
+    color: var(--fe-bracket-color, #fc514f);
+    transition: color 0.2s ease;
+  }
+
+  .wysiwygInternals.operator {
+    font-weight: bold;
+    color: var(--fe-operator-color, #fc618d);
+    transition: color 0.2s ease;
+  }
+
+  .wysiwygInternals.variable {
+    color: var(--fe-variable-color, #fc618d);
+    transition: color 0.2s ease;
+  }
+
+  .wysiwygInternals.function {
+    color: var(--fe-function-color, #82aaff);
+    font-style: italic;
+    transition: color 0.2s ease;
+  }
+
+  .wysiwygInternals.constant {
+    color: var(--fe-constant-color, #c3e88d);
+    font-weight: 500;
+    transition: color 0.2s ease;
+  }
+
+  /* High contrast mode support */
+  @media (forced-colors: active) {
+    .wysiwygInternals.error {
+      forced-color-adjust: none;
+      text-decoration-color: CanvasText;
+    }
+    
+    #wysiwyg-editor:focus {
+      outline: 2px solid Highlight;
+    }
+  }
+
+  .error-message {
+    color: var(--fe-error-color, #fc514f);
+    background-color: var(--fe-error-background, rgba(252, 81, 79, 0.1));
+    padding: var(--fe-error-padding, 8px);
+    border-radius: var(--fe-error-border-radius, 4px);
+    margin-top: var(--fe-error-margin-top, 4px);
+    animation: fadeIn 0.2s ease;
+    font-size: var(--fe-error-font-size, 0.8rem);
+    margin-top: var(--fe-error-margin-top, 4px);
+    min-height: var(--fe-error-min-height, 1.2em);
+  }
+
+  @keyframes fadeIn {
+    from {
+      opacity: 0;
+      transform: translateY(-4px);
+    }
+    to {
+      opacity: 1;
+      transform: translateY(0);
+    }
+  }
+
+  /* Loading state */
+  .loading::after {
+    content: '';
+    position: absolute;
+    right: 8px;
+    top: 50%;
+    transform: translateY(-50%);
+    width: 12px;
+    height: 12px;
+    border: 2px solid var(--fe-loading-color, #fc618d);
+    border-radius: 50%;
+    border-top-color: transparent;
+    animation: spin 0.8s linear infinite;
+  }
+
+  @keyframes spin {
+    to {
+      transform: translateY(-50%) rotate(360deg);
+    }
+  }
+`;

package/dist/formula-editor/src/sub-components/operator-input.js

@@ -0,0 +1,24 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { LitElement, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { Operator } from "../helpers/types";
+let OperatorInput = class OperatorInput extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.operator = Operator.NONE;
+    }
+    render() {
+        return html `<span> ${this.operator} </span>`;
+    }
+};
+__decorate([
+    property()
+], OperatorInput.prototype, "operator", void 0);
+OperatorInput = __decorate([
+    customElement("operator-input")
+], OperatorInput);