npm - @cocreate/calculate - Versions diffs - 1.15.0 → 1.16.0 - Mend

@cocreate/calculate 1.15.0 → 1.16.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -1,3 +1,17 @@
+# [1.16.0](https://github.com/CoCreate-app/CoCreate-calculate/compare/v1.15.0...v1.16.0) (2025-04-11)
+### Bug Fixes
+* sanitize and  calulate expressionbs ([0710efb](https://github.com/CoCreate-app/CoCreate-calculate/commit/0710efbdd72bdc563e387819e5a7c43a9d5bfb25))
+* update demo ([4d6f6b6](https://github.com/CoCreate-app/CoCreate-calculate/commit/4d6f6b60b68dcdefb1eae64939fde8eea0e45096))
+* update observer observe param to type and and attributeName to attributeFilter ([d50f013](https://github.com/CoCreate-app/CoCreate-calculate/commit/d50f013c0fb3de9e94bad052e11077da042ae223))
+### Features
+* **calculator:** Add mathematical expression evaluator ([89a3e61](https://github.com/CoCreate-app/CoCreate-calculate/commit/89a3e61c87b7cbcdd42a29583ddfbceafe611df8))
 # [1.15.0](https://github.com/CoCreate-app/CoCreate-calculate/compare/v1.14.7...v1.15.0) (2024-11-04)

package/demo/index.html CHANGED Viewed

@@ -1,30 +1,25 @@
 <!DOCTYPE html>
 <html lang="en">
-    <head>
-        <title>Calculate | CoCreateJS</title>
-        <!-- CoCreate Favicon -->
-        <link
-            rel="icon"
-            type="image/png"
-            sizes="32x32"
-            href="../assets/favicon.ico" />
-        <link rel="manifest" href="/manifest.webmanifest" />
-    </head>
-    <body>
-        <input class="we" key="total" id="id1" value="12" />
-        <input class="we" key="total" id="id2" value="13" />
-        <!--<input id="id3" value="14"><br><br><br>-->
+	<head>
+		<title>Calculate | CoCreateJS</title>
+		<!-- CoCreate Favicon -->
+		<link
+			rel="icon"
+			type="image/png"
+			sizes="32x32"
+			href="../assets/favicon.ico" />
+		<link rel="manifest" href="/manifest.webmanifest" />
+	</head>
+	<body>
+		<input value="12" calculate="$value * 100" />
+		<input class="class1" key="total" id="id1" value="12" />
+		<input class="class1" key="total" id="id2" value="13" />
-        <input id="te" calculate="{(#id1)} + {(#id2)}" />
-        <!--<input calculate="1 + 3 * 5">-->
-        <input calculate="{[key='total']} + 1" />
-        <h1 calculate="{[key='total']} + {(#te)}">sum</h1>
+		<input id="te" calculate="($selctor #id1) + ($selctor #id2)" />
+		<input calculate="($selctor [key='total']) + 1" />
+		<h1 calculate="($selctor [key='total']) + ($selctor .class1)">sum</h1>
-        <!--<h1 calculate="sum[.we]">sum</h1>-->
-        <!--<h1 calculate="1 + {(#id1)} * 5 + {(#id3)}/{(#id2)} + {(#id2)}"></h1>-->
-        <!--<h1 calculate="(({#id1} + {#id2})) * {#id3}"></h1>-->
-        <!--<script src="../dist/CoCreate-calculate.js"></script>-->
-        <script src="https://CoCreate.app/dist/CoCreate.js"></script>
-    </body>
+		<!--<script src="../dist/CoCreate-calculate.js"></script>-->
+		<script src="https://dev.CoCreate.app/dist/CoCreate.js"></script>
+	</body>
 </html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/calculate",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "description": "A handy vanilla JavaScript calculator, concatenate multiple elements containing integers & execute calculates. Can be used for creating  invoices,making payments & any kind of complex calculate. Easily configured using HTML5 attributes and/or JavaScript API.",
   "keywords": [
     "calculate",

package/src/index.js CHANGED Viewed

@@ -1,166 +1,945 @@
-import observer from '@cocreate/observer';
-import { getAttributes } from '@cocreate/utils';
+import observer from "@cocreate/observer";
+import { queryElements } from "@cocreate/utils";
 // import { renderValue } from '@cocreate/render';
-import '@cocreate/element-prototype';
+import "@cocreate/element-prototype";
 function init() {
-    let calculateElements = document.querySelectorAll('[calculate]');
-    initElements(calculateElements);
+	let calculateElements = document.querySelectorAll("[calculate]");
+	initElements(calculateElements);
 }
 function initElements(elements) {
-    for (let el of elements)
-        initElement(el);
+	for (let el of elements) initElement(el);
 }
-function initElement(element) {
-    let calculate = element.getAttribute('calculate');
-    if (calculate.includes('{{') || calculate.includes('{['))
-        return;
-    let selectors = getSelectors(calculate);
-    for (let i = 0; i < selectors.length; i++) {
-        // if (selectors[i].includes('{{')) return;
-        // initEvents(element, selectors[i]);
-        let inputs = document.querySelectorAll(selectors[i]);
-        for (let input of inputs) {
-            initEvent(element, input);
-        }
-        observer.init({
-            name: 'calculateSelectorInit',
-            observe: ['addedNodes'],
-            selector: selectors[i],
-            callback(mutation) {
-                initEvent(element, mutation.target);
-                setCalcationResult(element);
-            }
-        });
-    }
-    setCalcationResult(element);
+async function initElement(element) {
+	let calculate = element.getAttribute("calculate");
+	if (calculate.includes("{{") || calculate.includes("{[")) return;
+	let selectors = getSelectors(calculate);
+	for (let i = 0; i < selectors.length; i++) {
+		let inputs = queryElements({
+			element,
+			selector: selectors[i],
+			type: "selector"
+		});
+		for (let input of inputs) {
+			initEvent(element, input);
+		}
+		observer.init({
+			name: "calculateSelectorInit",
+			types: ["addedNodes"],
+			selector: selectors[i],
+			callback(mutation) {
+				initEvent(element, mutation.target);
+				setCalcationValue(element);
+			}
+		});
+	}
+	setCalcationValue(element);
 }
+/**
+ * Extracts selector strings starting with '$' from within parentheses in a given string.
+ * Ensures that the keyword (selector, closest, etc.) is followed by a word boundary.
+ * Returns an array of unique matching selector strings.
+ *
+ * @param {string} string The input string to search.
+ * @returns {string[]} An array of unique matching selector strings found.
+ */
 function getSelectors(string) {
-    let regex = /\{\((?:(?!\{\().)*?\)\}/;
-    let selectors = [];
-    let match;
-    while ((match = regex.exec(string)) !== null) {
-        // Extract the content inside the braces (excluding the leading '{(' and trailing ')}')
-        let selector = match[0].slice(2, -2);
-        if (selectors.indexOf(selector) === -1) {
-            selectors.push(selector);
-        }
-        // Replace the found match with an empty string to avoid reprocessing in the next iteration
-        string = string.replace(match[0], '');
-    }
-    return selectors;
+	if (!string) {
+		return []; // Return an empty array if input is null, undefined, or an empty string
+	}
+	// Regex provided by user: Finds parentheses, allows optional space,
+	// captures from '$' + keyword + word boundary + rest until ')'
+	const selectorRegex =
+		/\(\s*(\$(?:selector|closest|parent|next|previous|document|frame|top)\b[^)]*)\)/g;
+	const uniqueMatches = new Set();
+	let match;
+	// Use regex.exec() in a loop to find all matches
+	while ((match = selectorRegex.exec(string)) !== null) {
+		// match[1] contains the captured group (e.g., "$selector .button")
+		// Add the trimmed match to the Set. Duplicates are automatically ignored.
+		uniqueMatches.add(match[1].trim());
+		// Handle potential edge case with zero-length matches to prevent infinite loops
+		// Although less likely with this specific regex, it's good practice
+		if (match.index === selectorRegex.lastIndex) {
+			selectorRegex.lastIndex++;
+		}
+	}
+	return Array.from(uniqueMatches);
 }
-async function getValues(calculate) {
-    let selectors = getSelectors(calculate);
-    for (let i = 0; i < selectors.length; i++) {
-        let selector = selectors[i];
-        let value = null;
-        let inputs = document.querySelectorAll(selector);
-        for (let input of inputs) {
-            let val = null;
-            if (input.getValue)
-                val = Number(await input.getValue());
+// Map: Key = InputElement, Value = Array of Elements to update
+const initializedInputs = new Map();
+/**
+ * Associates an element to be updated with a specific input element.
+ * Attaches an 'input' event listener to the input element only once.
+ * When the input event fires, calls setCalcationValue for all associated elements.
+ *
+ * @param {HTMLElement} element The element that needs to be updated.
+ * @param {HTMLInputElement} input The input element that triggers the update.
+ */
+function initEvent(element, input) {
+	const calculteElements = initializedInputs.get(input);
+	if (calculteElements) {
+		calculteElements.add(element);
+		return;
+	}
+	initializedInputs.set(input, new Set([element]));
+	input.addEventListener("input", function () {
+		const elementsToUpdate = initializedInputs.get(input);
+		if (elementsToUpdate) {
+			for (const element of elementsToUpdate) {
+				setCalcationValue(element);
+			}
+		}
+	});
+}
-            if (!Number.isNaN(value)) {
-                value += val;
-            }
-        }
+async function setCalcationValue(element) {
+	let calString = await getValues(element);
+	element.setValue(calculate(calString));
+}
-        if (value != null && !Number.isNaN(value)) {
-            calculate = calculate.replaceAll('{(' + selector + ')}', value);
-        }
-    }
+async function getValues(element) {
+	let calculate = element.getAttribute("calculate");
+	let selectors = getSelectors(calculate);
+	for (let i = 0; i < selectors.length; i++) {
+		let value = 0; // Default to 0 for missing inputs
+		let inputs = queryElements({
+			// Ensure queryElements can be awaited if needed
+			element,
+			selector: selectors[i],
+			type: "selector"
+		});
+		for (let input of inputs) {
+			initEvent(element, input);
+			let val = null;
+			if (input.getValue) {
+				val = Number(await input.getValue());
+			}
+			if (!Number.isNaN(val)) {
+				value += val; // Accumulate valid numeric values
+			} else {
+				console.warn(
+					`Invalid value for selector "${selectors[i]}". Defaulting to 0.`
+				);
+			}
+		}
+		calculate = calculate.replaceAll(`(${selectors[i]})`, value);
+	}
+	return calculate;
+}
-    return calculate;
+// Defines mathematical constants available in expressions.
+const constants = { PI: Math.PI, E: Math.E };
+// Defines allowed mathematical functions and maps them to their JavaScript Math counterparts.
+const functions = {
+	abs: Math.abs,
+	ceil: Math.ceil,
+	floor: Math.floor,
+	round: Math.round,
+	max: Math.max, // Note: RPN evaluator assumes arity 2 for max/min
+	min: Math.min, // Note: RPN evaluator assumes arity 2 for max/min
+	pow: Math.pow,
+	sqrt: Math.sqrt,
+	log: Math.log, // Natural logarithm
+	sin: Math.sin,
+	cos: Math.cos,
+	tan: Math.tan
+};
+/**
+ * Tokenizer for Core Mathematical Expressions.
+ * Converts a mathematical expression string (without ternary operators) into an array of tokens.
+ * Each token is an object with 'type' and 'value'.
+ * Supported types: 'literal', 'identifier', 'operator', 'function', 'open_paren', 'close_paren', 'comma', 'unknown'.
+ *
+ * @param {string} expression - The mathematical expression string to tokenize.
+ * @returns {Array<object>} An array of token objects.
+ */
+function tokenizeCore(expression) {
+	const tokens = [];
+	// Regular expression to capture recognized patterns:
+	// 1: Numbers (integer or decimal)
+	// 2: Identifiers (variable names, function names, constants like PI) - starting with letter or _, followed by letters, numbers, or _
+	// 3: Multi-character comparison operators (>=, <=, ==, !=)
+	// 4: Single-character operators, parentheses, comma, or whitespace that might be part of an operator later (like '<' in '<=')
+	// 5: Whitespace sequences
+	const regex =
+		/(\d+(?:\.\d+)?)|([a-zA-Z_][a-zA-Z0-9_]*)|(>=|<=|==|!=)|([\+\-\*\/%^ \(\),<>])|(\s+)/g;
+	let match;
+	let lastToken = null; // Keep track of the previous token to help identify unary minus
+	let expectedIndex = 0; // Track the expected start index of the next token
+	// Iterate through all matches found by the regex in the expression string
+	while ((match = regex.exec(expression)) !== null) {
+		/* ... */ // Assume original complex logic might be here, focusing on the provided snippet
+		// Check for unrecognized character sequences between valid tokens
+		if (match.index !== expectedIndex) {
+			const gap = expression.substring(expectedIndex, match.index);
+			// Ignore gaps that are only whitespace
+			if (gap.trim() !== "") {
+				// Issue a warning for unrecognized characters, but attempt to continue tokenizing
+				console.warn(
+					`Invalid character sequence found near index ${expectedIndex}: '${gap}'`
+				);
+				// Note: Consider adding an 'error' or 'unknown_sequence' token type if needed for stricter parsing downstream
+			}
+		}
+		let tokenStr = match[0]; // The matched string
+		let token; // The token object to be created
+		// Group 5: Whitespace
+		if (match[5]) {
+			// Ignore whitespace; simply advance the expected index
+			expectedIndex = regex.lastIndex;
+			continue; // Move to the next match
+		}
+		// Group 1: Literal (Number)
+		if (match[1]) {
+			token = { type: "literal", value: parseFloat(tokenStr) };
+		}
+		// Group 2: Identifier (Constant or Function Name)
+		else if (match[2]) {
+			if (tokenStr in constants) {
+				// If it's a known constant, treat it as a literal value
+				token = { type: "literal", value: constants[tokenStr] };
+			} else if (tokenStr in functions) {
+				// If it's a known function name
+				token = { type: "function", value: tokenStr };
+			} else {
+				// If it's not a known constant or function
+				console.warn(`Unknown identifier: ${tokenStr}`);
+				// Create an 'unknown' token type. This allows the process to continue,
+				// but downstream functions (like Shunting-Yard or evaluator) should handle or ignore it.
+				token = { type: "unknown", value: tokenStr };
+			}
+		}
+		// Group 3: Comparison Operators (>=, <=, ==, !=)
+		else if (match[3]) {
+			token = {
+				type: "operator",
+				value: tokenStr,
+				precedence: 1, // Lower precedence than arithmetic operators
+				associativity: "left"
+			};
+		}
+		// Group 4: Other Operators/Punctuation (+, -, *, /, %, ^, (, ), ,, <, >)
+		else if (match[4]) {
+			tokenStr = tokenStr.trim(); // Remove surrounding whitespace if captured by the regex group
+			// This check should ideally not be needed if regex correctly excludes pure whitespace via group 5, but acts as a safeguard.
+			if (!tokenStr) {
+				expectedIndex = regex.lastIndex;
+				continue;
+			}
+			// Distinguish between unary minus and binary subtraction
+			if (tokenStr === "-") {
+				const isUnary =
+					lastToken === null || // Beginning of expression
+					["operator", "open_paren", "comma"].includes(
+						lastToken?.type
+					); // Following an operator, open parenthesis, or comma
+				token = isUnary
+					? {
+							// Unary minus
+							type: "operator",
+							value: "unary-", // Special value to distinguish from binary minus
+							precedence: 4, // Higher precedence than multiplication/division
+							associativity: "right"
+					  }
+					: {
+							// Binary minus (subtraction)
+							type: "operator",
+							value: "-",
+							precedence: 2, // Same precedence as addition
+							associativity: "left"
+					  };
+			} else if (tokenStr === "+") {
+				// Note: Unary plus is often ignored or handled implicitly, but could be tokenized similarly if needed.
+				token = {
+					type: "operator",
+					value: "+",
+					precedence: 2,
+					associativity: "left"
+				};
+			} else if (tokenStr === "*" || tokenStr === "/") {
+				token = {
+					type: "operator",
+					value: tokenStr,
+					precedence: 3,
+					associativity: "left"
+				};
+			} else if (tokenStr === "%") {
+				// Modulo operator
+				token = {
+					type: "operator",
+					value: tokenStr,
+					precedence: 3,
+					associativity: "left"
+				};
+			} else if (tokenStr === "^") {
+				// Exponentiation operator
+				token = {
+					type: "operator",
+					value: "^",
+					precedence: 5,
+					associativity: "right"
+				}; // Highest precedence, right-associative
+			} else if (tokenStr === ">" || tokenStr === "<") {
+				// Simple comparison operators
+				token = {
+					type: "operator",
+					value: tokenStr,
+					precedence: 1,
+					associativity: "left"
+				}; // Same low precedence as other comparisons
+			} else if (tokenStr === "(") {
+				token = { type: "open_paren", value: "(" };
+			} else if (tokenStr === ")") {
+				token = { type: "close_paren", value: ")" };
+			} else if (tokenStr === ",") {
+				// Comma, typically used as function argument separator
+				token = { type: "comma", value: "," };
+			} else {
+				// If the character is captured by group 4 but isn't handled above
+				console.warn(
+					`Unhandled punctuation/operator token: '${tokenStr}'`
+				);
+				// Mark as unknown
+				token = { type: "unknown", value: tokenStr };
+			}
+		} else {
+			// This block should theoretically not be reached if the regex covers all cases correctly.
+			// It acts as a fallback error indicator.
+			console.warn(
+				`Tokenizer internal regex error: No group matched near '${expression.substring(
+					expectedIndex
+				)}'`
+			);
+			// Optionally create an 'error' token or skip
+		}
+		// If a valid (or unknown) token was created, add it to the list
+		if (token) {
+			tokens.push(token);
+			lastToken = token; // Update lastToken for the next iteration's unary minus check
+		}
+		// Advance the expected starting position for the next token search
+		expectedIndex = regex.lastIndex;
+	}
+	// After the loop, check if the entire string was consumed by the tokenizer
+	if (expectedIndex < expression.length) {
+		const trailing = expression.substring(expectedIndex).trim();
+		// If there are non-whitespace characters remaining, they were not tokenized
+		if (trailing) {
+			console.warn(`Invalid trailing characters ignored: '${trailing}'`);
+		}
+	}
+	return tokens;
 }
-function initEvent(element, input) {
-    input.addEventListener('input', function () {
-        setCalcationResult(element);
-    });
-    // if (input.hasAttribute('calculate')) {
-    //     input.addEventListener('changedCalcValue', function(e) {
-    //         setCalcationResult(element);
-    //     });
-    // }
-    // setCalcationResult(element);
+/**
+ * Converts an infix token stream (from tokenizeCore) to a Reverse Polish Notation (RPN) queue.
+ * Implements the Shunting-yard algorithm. Does not handle ternary operators directly.
+ * Handles operator precedence and associativity, functions, and parentheses.
+ *
+ * @param {Array<object>} tokens - The array of token objects from tokenizeCore.
+ * @returns {Array<object>} An array of token objects arranged in RPN order.
+ */
+function shuntingYardCore(tokens) {
+	const outputQueue = []; // Stores the RPN output
+	const operatorStack = []; // Temporary stack for operators, functions, and parentheses
+	// Helper function to view the top element of a stack without removing it
+	const peek = (stack) => (stack.length > 0 ? stack[stack.length - 1] : null);
+	// Process each token from the input array
+	for (const token of tokens) {
+		// If the token is invalid or marked as unknown by the tokenizer, skip it.
+		if (!token || token.type === "unknown") {
+			console.warn(
+				`Shunting-Yard skipping unknown token: ${token?.value}`
+			);
+			continue;
+		}
+		/* ... */ // Assume original SY logic structure might be here
+		// Handle token based on its type
+		switch (token.type) {
+			case "literal":
+				// Literals (numbers) are immediately added to the output queue.
+				outputQueue.push(token);
+				break;
+			case "function":
+				// Functions are pushed onto the operator stack.
+				operatorStack.push(token);
+				break;
+			case "comma":
+				// Commas indicate separation of arguments in a function call.
+				// Pop operators from the stack to the output until an opening parenthesis is found.
+				while (peek(operatorStack)?.type !== "open_paren") {
+					const topOp = peek(operatorStack);
+					// If the stack becomes empty before finding '(', it implies mismatched parentheses or comma.
+					if (topOp === null) {
+						console.warn(
+							"Mismatched comma or parentheses detected during comma handling."
+						);
+						// Break to prevent infinite loop in error case. Consider throwing an error for stricter handling.
+						break;
+					}
+					outputQueue.push(operatorStack.pop());
+				}
+				// The '(' remains on the stack to mark the start of the arguments.
+				break;
+			case "operator":
+				// Handle operators based on precedence and associativity.
+				const currentOp = token;
+				let topOp = peek(operatorStack);
+				// While there's an operator on the stack with higher or equal precedence (considering associativity)...
+				while (
+					topOp?.type === "operator" &&
+					((currentOp.associativity === "left" &&
+						currentOp.precedence <= topOp.precedence) ||
+						(currentOp.associativity === "right" &&
+							currentOp.precedence < topOp.precedence))
+				) {
+					// Pop the operator from the stack to the output queue.
+					outputQueue.push(operatorStack.pop());
+					topOp = peek(operatorStack); // Check the new top operator
+				}
+				// Push the current operator onto the stack.
+				operatorStack.push(currentOp);
+				break;
+			case "open_paren":
+				// Opening parentheses are always pushed onto the operator stack.
+				operatorStack.push(token);
+				break;
+			case "close_paren":
+				// Closing parenthesis: process operators until the matching opening parenthesis.
+				let foundOpenParen = false;
+				while (peek(operatorStack)?.type !== "open_paren") {
+					const opToPop = operatorStack.pop();
+					// If the stack runs out before finding '(', parentheses are mismatched.
+					if (!opToPop) {
+						console.warn(
+							"Mismatched parentheses: Closing parenthesis found without matching open parenthesis."
+						);
+						// Break to prevent potential infinite loop if stack is empty.
+						break;
+					}
+					outputQueue.push(opToPop);
+				}
+				// If an opening parenthesis was found, pop it from the stack (it's not added to output).
+				if (peek(operatorStack)?.type === "open_paren") {
+					operatorStack.pop();
+					foundOpenParen = true;
+				} // Mismatch case already warned inside the loop
+				// If the token preceding the parenthesis pair was a function name, pop it to the output.
+				// This places the function after its arguments in RPN.
+				if (peek(operatorStack)?.type === "function") {
+					outputQueue.push(operatorStack.pop());
+				}
+				break;
+			default:
+				// Should not happen if tokenizer provides known types, but acts as a safeguard.
+				console.warn(
+					`Unknown token type encountered in Shunting-Yard: ${token.type}`
+				);
+		}
+	}
+	// After processing all tokens, pop any remaining operators/functions from the stack to the output queue.
+	while (peek(operatorStack) !== null) {
+		const op = operatorStack.pop();
+		// If an opening parenthesis is found here, it means parentheses were mismatched.
+		if (op.type === "open_paren") {
+			console.warn(
+				"Mismatched parentheses: Open parenthesis remaining on stack at the end."
+			);
+			// Continue processing other operators, but the RPN is likely invalid.
+		} else {
+			outputQueue.push(op);
+		}
+	}
+	return outputQueue; // Return the final RPN token queue.
 }
-async function setCalcationResult(element) {
-    const { object, isRealtime } = getAttributes(element);
-    let calString = await getValues(element.getAttribute('calculate'));
-    if (calString) {
-        let result = calculate(calString);
-        // TODO: input event below triggers save for all input elements but will not save for regular elements
-        if (element.setValue) {
-            element.setValue(result)
-            if (object && isRealtime && isRealtime !== "false") {
-                element.save(element);
-            }
-        }
-        else {
-            // if (element.value){
-            // }
-            // else {
-            element.innerHTML = result;
-            // }
-        }
-        let inputEvent = new CustomEvent('input', { bubbles: true });
-        Object.defineProperty(inputEvent, 'target', { writable: false, value: element });
-        element.dispatchEvent(inputEvent);
-        //. set custom event
-        // var event = new CustomEvent('changedCalcValue', {
-        //     bubbles: true,
-        // });
-        // element.dispatchEvent(event);
-    }
+/**
+ * Evaluates a Reverse Polish Notation (RPN) token queue generated by shuntingYardCore.
+ * Performs the actual calculations based on operators and function calls.
+ * Handles basic error conditions like stack underflow, division by zero, and unknown tokens.
+ * Returns the numerical result or null if evaluation fails.
+ *
+ * @param {Array<object>} rpnQueue - The array of token objects in RPN order.
+ * @returns {number | null} The calculated numerical result, or null if an error occurs.
+ */
+function evaluateRPNCore(rpnQueue) {
+	if (!rpnQueue || rpnQueue.length === 0) {
+		return null;
+	}
+	const evaluationStack = []; // Stack used to hold operands during RPN evaluation.
+	for (const token of rpnQueue) {
+		if (token.type === "literal") {
+			evaluationStack.push(token.value);
+		} else if (token.type === "operator") {
+			if (token.value === "unary-") {
+				if (evaluationStack.length < 1) {
+					console.warn(
+						`Stack underflow error during unary '-' operation.`
+					);
+					return null;
+				}
+				// Pop the operand, negate it, and push the result back.
+				evaluationStack.push(-evaluationStack.pop());
+			}
+			// Handle binary operators
+			else {
+				// Requires two operands on the stack.
+				if (evaluationStack.length < 2) {
+					console.warn(
+						`Stack underflow error during binary '${token.value}' operation.`
+					);
+					return null;
+				}
+				// Pop the top two operands. Note: the second operand (b) is popped first.
+				const b = evaluationStack.pop();
+				const a = evaluationStack.pop();
+				let result;
+				// Perform the operation based on the operator value.
+				switch (token.value) {
+					case "+":
+						result = a + b;
+						break;
+					case "-":
+						result = a - b;
+						break;
+					case "*":
+						result = a * b;
+						break;
+					case "/":
+						// Check for division by zero.
+						if (b === 0) {
+							console.warn("Division by zero encountered.");
+							return null;
+						}
+						result = a / b;
+						break;
+					case "%":
+						// Check for modulo by zero (JavaScript's % operator returns NaN in this case).
+						if (b === 0) {
+							console.warn("Modulo by zero encountered.");
+							return null; // Return null for consistency with division by zero.
+						}
+						result = a % b;
+						break;
+					case "^":
+						result = Math.pow(a, b);
+						break;
+					// Comparison operators return 1 for true, 0 for false, consistent with C-like behavior.
+					case ">":
+						result = a > b ? 1 : 0;
+						break;
+					case "<":
+						result = a < b ? 1 : 0;
+						break;
+					case ">=":
+						result = a >= b ? 1 : 0;
+						break;
+					case "<=":
+						result = a <= b ? 1 : 0;
+						break;
+					case "==":
+						result = a === b ? 1 : 0;
+						break; // Use strict equality
+					case "!=":
+						result = a !== b ? 1 : 0;
+						break; // Use strict inequality
+					default:
+						console.warn(
+							`Unknown operator encountered during evaluation: ${token.value}`
+						);
+						return null;
+				}
+				evaluationStack.push(result);
+			}
+		}
+		// If the token is a function call...
+		else if (token.type === "function") {
+			// Look up the function implementation (assuming 'functions' is a globally accessible object/map).
+			const func = functions[token.value];
+			if (!func) {
+				// If the function name is not found in the available functions.
+				console.warn(
+					`Unknown function encountered during evaluation: ${token.value}`
+				);
+				return null;
+			}
+			// Determine the expected number of arguments (arity) for the function.
+			// Note: Relying solely on func.length can be unreliable for functions with default parameters or rest parameters.
+			// This example uses a mix of func.length and hardcoded arity for common Math functions.
+			// A more robust implementation might store arity explicitly alongside the function definition.
+			let arity = func.length; // Default assumption based on function definition
+			// Explicitly define arity for functions where .length might be ambiguous or for built-ins.
+			// (Example adjustments - tailor these to the actual functions defined)
+			if (["max", "min", "pow"].includes(token.value)) arity = 2;
+			if (
+				[
+					"sqrt",
+					"abs",
+					"ceil",
+					"floor",
+					"round",
+					"log",
+					"sin",
+					"cos",
+					"tan"
+				].includes(token.value)
+			)
+				arity = 1;
+			// Add more overrides as needed for your specific function set.
+			// Check if there are enough operands on the stack for the function's arity.
+			if (evaluationStack.length < arity) {
+				console.warn(
+					`Stack underflow for function '${token.value}'. Need ${arity} args, found ${evaluationStack.length}.`
+				);
+				return null;
+			}
+			// Pop the required number of arguments from the stack.
+			const args = [];
+			for (let i = 0; i < arity; i++) {
+				args.push(evaluationStack.pop());
+			}
+			try {
+				// Call the function with the arguments. Since they were popped in reverse,
+				const functionResult = func(...args.reverse());
+				evaluationStack.push(functionResult);
+			} catch (funcError) {
+				// Catch errors that might occur during the function's execution (e.g., Math.log(-1) -> NaN, invalid inputs).
+				console.warn(
+					`Error executing function '${token.value}': ${funcError.message}`
+				);
+				return null;
+			}
+		} else {
+			// If a token type other than literal, operator, or function appears in the RPN queue.
+			// This might indicate an error in the RPN generation (Shunting-Yard).
+			console.warn(
+				`Unknown RPN token type encountered: ${token?.type} (Value: ${token?.value})`
+			);
+			return null;
+		}
+	}
+	// After processing all tokens, the evaluation stack should contain exactly one value: the final result.
+	if (evaluationStack.length !== 1) {
+		// If the stack size is not 1, it usually indicates an invalid expression or a bug in the RPN conversion/evaluation.
+		console.warn(
+			`Evaluation finished with invalid stack size: ${
+				evaluationStack.length
+			}. Contents: ${JSON.stringify(evaluationStack)}`
+		);
+		return null;
+	}
+	const finalResult = evaluationStack[0];
+	// Validate the final result to ensure it's a usable number.
+	// Allow 0 and 1 specifically, as they are valid results from boolean comparisons.
+	if (finalResult === 0 || finalResult === 1) {
+		return finalResult;
+	}
+	// Check if the result is a finite number (not NaN, Infinity, or -Infinity).
+	if (typeof finalResult !== "number" || !Number.isFinite(finalResult)) {
+		console.warn(
+			`Final evaluation result is not a valid finite number: ${finalResult}`
+		);
+		return null;
+	}
+	return finalResult;
+}
+/**
+ * Parses a string expression to find the components of a *top-level* ternary expression.
+ * Looks for the first '?' and its corresponding ':' at the same parenthesis nesting level.
+ * Returns an object with { condition, trueExpr, falseExpr } if found, otherwise null.
+ * Respects parentheses to avoid splitting nested ternaries incorrectly.
+ *
+ * @param {string} expression - The expression string to parse.
+ * @returns {{condition: string, trueExpr: string, falseExpr: string} | null} Object with parts or null.
+ */
+function parseTernary(expression) {
+	let parenLevel = 0; // Tracks nesting level of parentheses
+	let qIndex = -1; // Index of the top-level '?'
+	// First pass: Find the first '?' at parenthesis level 0.
+	for (let i = 0; i < expression.length; i++) {
+		const char = expression[i];
+		if (char === "(") {
+			parenLevel++;
+		} else if (char === ")") {
+			parenLevel--;
+		} else if (char === "?" && parenLevel === 0) {
+			// Found the '?' at the top level
+			qIndex = i;
+			break; // Stop searching once the first top-level '?' is found
+		}
+		// Error check: If parenLevel goes below 0, parentheses are mismatched.
+		if (parenLevel < 0) {
+			console.warn(
+				`Mismatched parentheses detected (too many ')') in ternary structure near index ${i}.`
+			);
+			return null; // Indicate parsing failure due to invalid structure
+		}
+	}
+	// If no top-level '?' was found, it's not a simple ternary structure at this level.
+	if (qIndex === -1) {
+		return null;
+	}
+	// Second pass: Find the corresponding ':' at level 0, starting *after* the '?'.
+	parenLevel = 0; // Reset parenthesis level counter for the colon search
+	let cIndex = -1; // Index of the top-level ':'
+	for (let i = qIndex + 1; i < expression.length; i++) {
+		const char = expression[i];
+		if (char === "(") {
+			parenLevel++;
+		} else if (char === ")") {
+			parenLevel--;
+		} else if (char === ":" && parenLevel === 0) {
+			// Found the matching ':' at the top level
+			cIndex = i;
+			break; // Stop searching
+		}
+		// Error check during colon search
+		if (parenLevel < 0) {
+			console.warn(
+				`Mismatched parentheses detected (too many ')') after '?' in ternary structure near index ${i}.`
+			);
+			return null; // Indicate parsing failure
+		}
+	}
+	// If no matching top-level ':' was found after the '?', the structure is invalid.
+	if (cIndex === -1) {
+		console.warn(
+			`Invalid ternary structure: No matching top-level ':' found for '?' at index ${qIndex}.`
+		);
+		return null;
+	}
+	// Extract the three parts of the ternary expression.
+	const condition = expression.substring(0, qIndex).trim();
+	const trueExpr = expression.substring(qIndex + 1, cIndex).trim();
+	const falseExpr = expression.substring(cIndex + 1).trim();
+	// Validate that none of the parts are empty after trimming.
+	if (!condition || !trueExpr || !falseExpr) {
+		console.warn(
+			`Invalid ternary structure: empty part detected in "${expression}". Condition: "${condition}", True: "${trueExpr}", False: "${falseExpr}".`
+		);
+		return null;
+	}
+	return { condition, trueExpr, falseExpr };
 }
-function calculate(string) {
-    if (/^[0-9+\-*/()%||?\s:=.]*$/.test(string))
-        return eval(string);
+/**
+ * Main entry point for evaluating a mathematical expression string.
+ * Handles nested ternary operators (`? :`) recursively with short-circuiting.
+ * For non-ternary expressions or sub-expressions, it uses the core engine:
+ * Tokenizer -> Shunting-Yard -> RPN Evaluator.
+ * Provides graceful handling of common errors, returning null on failure.
+ *
+ * @param {string | any} expression - The expression string to evaluate. Non-string inputs are converted.
+ * @returns {number | null} The final calculated result, or null if evaluation fails or the expression is invalid.
+ */
+function calculate(expression) {
+	// Store the original input, converting to string if necessary, for logging context.
+	const originalExpr =
+		typeof expression === "string" ? expression : String(expression);
+	try {
+		// Ensure we are working with a trimmed string.
+		let currentExpr =
+			typeof expression === "string" ? expression.trim() : "";
+		// Handle empty or whitespace-only expressions immediately.
+		if (!currentExpr) {
+			// Warning is optional here, depends if empty input is expected or an error.
+			// console.warn("Expression is empty or evaluates to empty string.");
+			return null; // Return null for empty expression.
+		}
+		/* --- Optional Step: Remove Fully Wrapping Parentheses ---
+		 * This simplifies parsing by removing redundant outer parentheses, e.g., "((1 + 2))" becomes "1 + 2".
+		 * It iteratively unwraps as long as the outermost characters are '(' and ')'
+		 * and they correctly balance across the entire contained expression.
+		 */
+		let unwrapped = false; // Flag to track if any unwrapping occurred (mainly for debugging)
+		while (currentExpr.startsWith("(") && currentExpr.endsWith(")")) {
+			let balance = 0;
+			let canUnwrap = true; // Assume it can be unwrapped unless proven otherwise
+			// Handle edge case like "()" which cannot be unwrapped to an empty string meaningfully here.
+			if (currentExpr.length <= 2) {
+				canUnwrap = false;
+				break;
+			}
+			// Check if the parentheses truly wrap the *entire* internal expression.
+			for (let i = 0; i < currentExpr.length; i++) {
+				if (currentExpr[i] === "(") balance++;
+				else if (currentExpr[i] === ")") balance--;
+				// If balance returns to 0 *before* the very last character,
+				// it means the parentheses don't wrap the whole thing, e.g., "(1) + (2)".
+				if (balance === 0 && i < currentExpr.length - 1) {
+					canUnwrap = false;
+					break;
+				}
+				// If balance goes negative at any point, parentheses are mismatched.
+				if (balance < 0) {
+					canUnwrap = false; // Should ideally be caught later, but good safeguard.
+					break;
+				}
+			}
+			// The final balance must also be 0 for the wrapping to be valid.
+			if (balance !== 0) {
+				canUnwrap = false;
+			}
+			// If the checks pass, perform the unwrap.
+			if (canUnwrap) {
+				currentExpr = currentExpr
+					.substring(1, currentExpr.length - 1)
+					.trim();
+				unwrapped = true;
+			} else {
+				// If cannot unwrap this layer, stop the unwrapping process.
+				break;
+			}
+		}
+		/* --- End Parenthesis Unwrapping --- */
+		// 1. Attempt to parse the current (potentially unwrapped) expression as a top-level ternary.
+		const ternaryParts = parseTernary(currentExpr);
+		// 2. If it successfully parsed as a ternary structure...
+		if (ternaryParts) {
+			// 2a. Recursively evaluate the condition part first.
+			const condResult = calculate(ternaryParts.condition);
+			// Handle cases where the condition itself fails to evaluate.
+			if (condResult === null) {
+				// Log a warning indicating the condition evaluation failed.
+				console.warn(
+					`Failed to evaluate ternary condition: "${ternaryParts.condition}" in context: "${originalExpr}". Defaulting to false branch.`
+				);
+				// Proceed as if the condition is false for robustness, evaluating the 'falseExpr'.
+				// Alternatively, could return null here to propagate the failure.
+				return calculate(ternaryParts.falseExpr);
+			}
+			// 2b. Short-circuiting: Evaluate *only* the required branch based on the condition result.
+			// The core evaluator returns 1 for true comparisons, 0 for false.
+			// Any non-zero number is treated as "truthy" here.
+			if (condResult) {
+				// Checks for truthiness (non-zero result)
+				return calculate(ternaryParts.trueExpr); // Evaluate the true branch recursively.
+			} else {
+				return calculate(ternaryParts.falseExpr); // Evaluate the false branch recursively.
+			}
+		}
+		// 3. If it's not a top-level ternary (or parseTernary returned null due to errors)...
+		else {
+			// Evaluate the expression using the standard core math engine pipeline.
+			const tokens = tokenizeCore(currentExpr);
+			const rpnQueue = shuntingYardCore(tokens);
+			// evaluateRPNCore handles internal errors (like division by zero, unknown tokens) and returns null on failure.
+			const result = evaluateRPNCore(rpnQueue);
+			return result; // Return the result (which could be a number or null).
+		}
+	} catch (error) {
+		// Catch any unexpected runtime errors during the calculation process.
+		const contextExpr =
+			originalExpr.length > 50
+				? originalExpr.substring(0, 47) + "..." // Truncate long expressions for logging
+				: originalExpr;
+		console.warn(
+			`Unexpected calculation error: ${error.message} (Expression context: "${contextExpr}")`,
+			error
+		);
+		return null;
+	}
 }
 observer.init({
-    name: 'CoCreateCalculateChangeValue',
-    observe: ['attributes'],
-    attributeName: ['calculate'],
-    callback(mutation) {
-        setCalcationResult(mutation.target);
-    }
+	name: "CoCreateCalculateChangeValue",
+	types: ["attributes"],
+	attributeFilter: ["calculate"],
+	callback(mutation) {
+		setCalcationValue(mutation.target);
+	}
 });
 observer.init({
-    name: 'CoCreateCalculateInit',
-    observe: ['addedNodes'],
-    selector: '[calculate]',
-    callback(mutation) {
-        initElement(mutation.target);
-    }
+	name: "CoCreateCalculateInit",
+	types: ["addedNodes"],
+	selector: "[calculate]",
+	callback(mutation) {
+		initElement(mutation.target);
+	}
 });
 init();