@teachinglab/omd 0.1.4 → 0.1.5

package/docs/api/omdTreeDiff.md

@@ -1,134 +1,170 @@
-
-# omdTreeDiff
-
-Implements a robust tree differencing algorithm to identify changes between two `omdNode` expression trees. Used by `omdStepVisualizerHighlighting` to provide visual feedback on how mathematical expressions transform from one step to the next.
-
-## Algorithm Overview
-
-`omdTreeDiff` uses a multi-stage approach:
-1. **Special Cases:** Attempts to identify common pedagogical patterns (like adding/subtracting the same value from both sides). If found, highlights those nodes.
-2. **Generate All Matches:** Finds all possible pairs of subtrees between the old and new expressions that are either structurally identical or semantically equivalent (e.g., `2+3` and `5`).
-3. **Select Optimal Set:** Selects the largest, non-overlapping set of matches, identifying the largest common sub-expressions between the two trees.
-4. **Identify Changes:** Any parts of the new tree that are *not* part of these optimal matches are considered changes and are returned for highlighting.
-5. **Educational Mode:** In educational mode, includes additional heuristics to highlight subtle simplifications that might not involve a direct structural change but are important for understanding the transformation.
-
-## Class: `omdTreeDiff`
-
-```javascript
-import { omdTreeDiff } from './omd/utils/omdTreeDiff.js';
-```
-
-
-## Static Methods
-
-
-### `findChangedNodes(oldEquation, newEquation, options)`
-
-Main entry point for the tree differencing algorithm. Compares two `omdEquationNode` instances (or any `omdNode` subtrees) and returns a list of nodes in the `newEquation` that have changed or are new.
-
-- **Parameters:**
-  - `oldEquation` {omdNode} - The root node of the previous expression tree.
-  - `newEquation` {omdNode} - The root node of the current expression tree.
-  - `options` {Object} (optional) - Configuration options:
-    - `educationalMode` {boolean} - If `true`, the diff algorithm will also highlight mathematically neutral changes that are pedagogically significant (e.g., removing `+ 0`). Default: `false`.
-- **Returns:** {Array<omdNode>} An array of `omdNode` instances from `newEquation` that should be highlighted.
-
----
-
-
-### `findEquationSpecialCases(oldEquation, newEquation)`
-
-Identifies specific equation-level transformation patterns, such as adding the same operation (e.g., `+ X` or `- X`) to both sides of an equation. Allows for more intuitive highlighting in common step-by-step solution scenarios.
-
-- **Parameters:**
-  - `oldEquation` {omdEquationNode} - The previous equation.
-  - `newEquation` {omdEquationNode} - The current equation.
-- **Returns:** {Array<omdNode>} An array of nodes to highlight for these special cases, or an empty array if no such pattern is found.
-
----
-
-
-### `diffSubtrees(oldTree, newTree, educationalMode)`
-
-Core recursive differencing method. Attempts to find an optimal matching between subtrees of the `oldTree` and `newTree`. Nodes in `newTree` that do not have a match in `oldTree` are considered changed.
-
-- **Parameters:**
-  - `oldTree` {omdNode} - The root of the old subtree.
-  - `newTree` {omdNode} - The root of the new subtree.
-  - `educationalMode` {boolean} - Same as in `findChangedNodes`.
-- **Returns:** {Array<omdNode>} An array of unmatched leaf nodes in `newTree`.
-
----
-
-
-### `findEducationalHighlights(oldTree, newTree, optimalMatches)`
-
-When `educationalMode` is enabled, identifies additional nodes to highlight for pedagogical reasons, even if they don't represent a structural change. Includes cases like the removal of additive/multiplicative identities or double negations.
-
-- **Parameters:**
-  - `oldTree` {omdNode} - The old expression tree.
-  - `newTree` {omdNode} - The new expression tree.
-  - `optimalMatches` {Array} - The list of optimally matched subtrees.
-- **Returns:** {Array<omdNode>} Additional nodes to highlight.
-
----
-
-
-### `findAllSubtreeMatches(oldTree, newTree)`
-
-Generates all possible subtree matches between two expression trees. A match is determined by structural or string equivalence.
-
-- **Parameters:**
-  - `oldTree` {omdNode} - The old expression tree.
-  - `newTree` {omdNode} - The new expression tree.
-- **Returns:** {Array<Object>} An array of match objects, each containing `oldNode`, `newNode`, `size`, `score`, and `type` of match.
-
----
-
-
-### `selectOptimalMatching(matches)`
-
-Given a list of all possible subtree matches, selects the optimal, non-overlapping set of matches. Uses a greedy approach, prioritizing larger and higher-scoring matches.
-
-- **Parameters:**
-  - `matches` {Array<Object>} - The array of potential matches from `findAllSubtreeMatches`.
-- **Returns:** {Array<Object>} The selected optimal matches.
-
----
-
-
-### `findUnmatchedLeafNodes(newTree, matches)`
-
-Identifies all leaf nodes in the `newTree` that are not covered by any of the `optimalMatches`. These are the nodes that represent the actual changes.
-
-- **Parameters:**
-  - `newTree` {omdNode} - The new expression tree.
-  - `matches` {Array<Object>} - The array of selected optimal matches.
-- **Returns:** {Array<omdNode>} An array of unmatched leaf nodes.
-
-
-## Internal Helper Methods
-
-- `_findCommonPrefix(str1, str2)`: Finds the longest common string prefix.
-- `getAllSubtrees(root)`: Recursively collects all subtrees from a given root node.
-- `calculateSimilarity(tree1, tree2)`: Determines the similarity score between two subtrees.
-- `treesStructurallyEqual(tree1, tree2)`: Checks for exact structural equality between two subtrees.
-- `getSubtreeSize(root)`: Calculates the number of nodes in a subtree.
-- `hasNodeOverlap(node, usedNodes)`: Checks if a node or its descendants overlap with a set of used nodes.
-- `markSubtreeAsUsed(root, usedNodes)`: Marks all nodes in a subtree as used.
-- `findUnmatchedOldNodes(oldTree, matches)`: Finds leaf nodes in the old tree that were removed.
-
-
-## How it Works
-
-See the Algorithm Overview above for a summary of the process. The class is designed for internal use by step visualizer components.
-
-### Example
-
-This class is typically used internally by `omdStepVisualizerHighlighting`.
-
-```javascript
-// Example of internal usage within omdStepVisualizerHighlighting:
-// const changedNodes = omdTreeDiff.findChangedNodes(previousEquation, currentEquation, { educationalMode: true });
-// changedNodes.forEach(node => node.setExplainHighlight(true));
-```
+# omdTreeDiff
+
+Implements a robust tree differencing algorithm to identify changes between two `omdNode` expression trees. This module is crucial for `omdStepVisualizerHighlighting`, providing precise visual feedback on how mathematical expressions transform from one step to the next.
+
+## Algorithm Overview
+
+`omdTreeDiff` uses a multi-stage approach to compare two expression trees (`oldEquation` and `newEquation`):
+
+1.  **Special Cases**: It first attempts to identify common pedagogical patterns (like adding/subtracting the same value from both sides, or simple identity/double negative simplifications). If found, these specific changes are highlighted directly.
+2.  **Optimal Subtree Matching**: If no special cases apply, it proceeds to find the largest, non-overlapping set of matched subtrees between the old and new expressions. A match can be either structurally identical or semantically equivalent (e.g., `2+3` and `5`).
+3.  **Identify Changes**: Any parts of the `newEquation` that are *not* part of these optimal matches are considered the actual changes and are returned for highlighting.
+4.  **Educational Mode**: When enabled, the algorithm includes additional heuristics to highlight subtle simplifications that might not involve a direct structural change but are important for understanding the transformation (e.g., removing `+ 0`).
+
+## Class Definition
+
+```javascript
+export class omdTreeDiff
+```
+
+This class is not meant to be instantiated. All its methods are static.
+
+## Static Methods
+
+### `findChangedNodes(oldEquation, newEquation, options)`
+
+Main entry point for the tree differencing algorithm. Compares two `omdEquationNode` instances (or any `omdNode` subtrees) and returns a list of nodes in the `newEquation` that have changed or are new.
+
+-   **`oldEquation`** (`omdNode`): The root node of the previous expression tree.
+-   **`newEquation`** (`omdNode`): The root node of the current expression tree.
+-   **`options`** (`object`, optional): Configuration options:
+    -   `educationalMode` (`boolean`): If `true`, the diff algorithm will also highlight mathematically neutral changes that are pedagogically significant (e.g., removing `+ 0`). Default: `false`.
+-   **Returns**: `Array<omdNode>` - An array of `omdNode` instances from `newEquation` that should be highlighted.
+
+### `findEquationSpecialCases(oldEquation, newEquation)`
+
+Identifies specific equation-level transformation patterns, such as adding/subtracting the same operation to both sides of an equation. This allows for more intuitive highlighting in common step-by-step solution scenarios.
+
+-   **`oldEquation`** (`omdEquationNode`): The previous equation.
+-   **`newEquation`** (`omdEquationNode`): The current equation.
+-   **Returns**: `Array<omdNode>` - An array of nodes to highlight for these special cases, or an empty array if no such pattern is found.
+
+### `diffSubtrees(oldTree, newTree, educationalMode)`
+
+Core recursive differencing method. It first checks for various pedagogical highlighting patterns (common prefix, variable preservation, type differences, subtraction patterns). If none apply, it falls back to finding an optimal matching between subtrees of the `oldTree` and `newTree`. Nodes in `newTree` that do not have a match in `oldTree` are considered changed.
+
+-   **`oldTree`** (`omdNode`): The root of the old subtree.
+-   **`newTree`** (`omdNode`): The root of the new subtree.
+-   **`educationalMode`** (`boolean`): Same as in `findChangedNodes`.
+-   **Returns**: `Array<omdNode>` - An array of unmatched leaf nodes in `newTree`.
+
+### `findEducationalHighlights(oldTree, newTree, optimalMatches)`
+
+When `educationalMode` is enabled, this method identifies additional nodes to highlight for pedagogical reasons, even if they don't represent a structural change. This includes cases like the removal of additive/multiplicative identities or double negations.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **`optimalMatches`** (`Array`): The list of optimally matched subtrees.
+-   **Returns**: `Array<omdNode>` - Additional nodes to highlight.
+
+### `findAdditiveIdentityChanges(oldTree, newTree)`
+
+Identifies changes related to the removal of additive identities (e.g., `+ 0` or `- 0`).
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for additive identity changes.
+
+### `findMultiplicativeIdentityChanges(oldTree, newTree)`
+
+Identifies changes related to the removal of multiplicative identities (e.g., `* 1` or `/ 1`).
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for multiplicative identity changes.
+
+### `findDoubleNegativeChanges(oldTree, newTree)`
+
+Identifies changes related to the simplification of double negatives (e.g., `--x` to `x`).
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for double negative removal.
+
+### `findCommonPrefixHighlights(oldTree, newTree)`
+
+Identifies highlighting patterns based on common prefixes between the string representations of the old and new trees. For example, if `"2x + 4"` becomes `"2x + 4 - 4"`, it highlights only the `"- 4"` part.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for common prefix patterns.
+
+### `findVariablePreservationHighlights(oldTree, newTree)`
+
+Identifies highlighting patterns where a variable term remains the same but associated constants change. For example, `"2x + 4"` becoming `"2x + 2"` should highlight only the changed constant.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for variable preservation patterns.
+
+### `findTypeDifferenceHighlights(oldTree, newTree)`
+
+Identifies highlighting patterns where the type of an expression changes significantly (e.g., a constant becoming a binary expression). In such cases, it highlights the new expression.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for type difference patterns.
+
+### `findSubtractionPatternHighlights(oldTree, newTree)`
+
+Identifies highlighting patterns specific to subtraction, where the old tree matches the left side of a new subtraction. For example, `"x + 2"` becoming `"x + 2 - 2"` should highlight only the `"- 2"` part.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<omdNode>` - Nodes to highlight for subtraction patterns.
+
+### `findAllSubtreeMatches(oldTree, newTree)`
+
+Generates all possible subtree matches between two expression trees. A match is determined by structural or string equivalence.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **Returns**: `Array<object>` - An array of match objects, each containing `oldNode`, `newNode`, `size`, `score`, and `type` of match.
+
+### `selectOptimalMatching(matches)`
+
+Given a list of all possible subtree matches, this method selects the optimal, non-overlapping set of matches. It uses a greedy approach, prioritizing larger and higher-scoring matches.
+
+-   **`matches`** (`Array<object>`): The array of potential matches from `findAllSubtreeMatches`.
+-   **Returns**: `Array<object>` - The selected optimal matches.
+
+### `findUnmatchedLeafNodes(newTree, matches)`
+
+Identifies all leaf nodes in the `newTree` that are not covered by any of the `optimalMatches`. These are the nodes that represent the actual changes.
+
+-   **`newTree`** (`omdNode`): The new expression tree.
+-   **`matches`** (`Array<object>`): The array of selected optimal matches.
+-   **Returns**: `Array<omdNode>` - An array of unmatched leaf nodes.
+
+### `findUnmatchedOldNodes(oldTree, matches)`
+
+Finds leaf nodes in the `oldTree` that are not covered by any match. These represent nodes that were removed or transformed.
+
+-   **`oldTree`** (`omdNode`): The old expression tree.
+-   **`matches`** (`Array<object>`): The array of selected optimal matches.
+-   **Returns**: `Array<omdNode>` - An array of unmatched leaf nodes from the old tree.
+
+## Internal Helper Methods
+
+-   **`_findCommonPrefix(str1, str2)`**: Finds the longest common string prefix between two strings.
+-   **`getAllSubtrees(root)`**: Recursively collects all subtrees from a given root node.
+-   **`calculateSimilarity(tree1, tree2)`**: Determines the similarity score between two subtrees, considering structural and string equivalence.
+-   **`treesStructurallyEqual(tree1, tree2)`**: Checks for exact structural equality between two subtrees.
+-   **`getSubtreeSize(root)`**: Calculates the number of nodes in a subtree.
+-   **`hasNodeOverlap(node, usedNodes)`**: Checks if a node or any of its descendants overlap with a set of already used nodes.
+-   **`markSubtreeAsUsed(root, usedNodes)`**: Marks all nodes in a subtree as used by adding them to a `Set`.
+-   **`debugPrintTree(node, depth)`**: A utility function for debugging that prints the structure of an `omdNode` tree to the console.
+
+## How it Works
+
+See the Algorithm Overview above for a summary of the process. The class is designed for internal use by step visualizer components.
+
+### Example
+
+This class is typically used internally by `omdStepVisualizerHighlighting`:
+
+```javascript
+// Example of internal usage within omdStepVisualizerHighlighting:
+// const changedNodes = omdTreeDiff.findChangedNodes(previousEquation, currentEquation, { educationalMode: true });
+// changedNodes.forEach(node => node.setExplainHighlight(true));
+```

package/docs/api/omdUnaryExpressionNode.md

@@ -1,174 +1,137 @@
-# omdUnaryExpressionNode
-
-Represents unary operations (like negation) in mathematical expressions (e.g., `-x`, `-(a + b)`). Handles rendering, layout, evaluation, and conversion to math.js AST.
-
-## Class: `omdUnaryExpressionNode extends omdNode`
-
-```javascript
-import { omdUnaryExpressionNode } from './omd/nodes/omdUnaryExpressionNode.js';
-```
-
-### Constructor
-
-```javascript
-new omdUnaryExpressionNode(ast)
-```
-
-**Parameters:**
-- `ast` {Object} - The AST node containing:
-  - `args`: Array with exactly 1 operand AST node
-  - `op`: Operator symbol (e.g., '-')
-  - `fn`: Operation name (e.g., 'unaryMinus')
-
-**Description:**
-Creates a node representing a unary operation (like negation) on an expression. Throws an error if the AST does not have exactly one argument.
-
-### Properties
-
-Inherits all properties from [omdNode](./omdNode.md), plus:
-
-#### `op`
-- **Type:** [omdOperatorNode](./omdOperatorNode.md)
-- **Description:** The unary operator node (e.g., '-')
-
-#### `operand`
-- **Type:** [omdNode](./omdNode.md)
-- **Description:** The expression being operated on
-
-#### `operation`
-- **Type:** string
-- **Description:** The operation name (e.g., 'unaryMinus')
-
-### Methods
-
-Inherits all methods from [omdNode](./omdNode.md), plus:
-
-#### `createOperatorNode(ast)`
-Internal method to create operator node.
-- `ast` {Object} - The AST with operator info
-- **Returns:** omdOperatorNode
-
----
-
-#### `createExpressionNode(ast)`
-Internal method to create operand node.
-- `ast` {Object} - The AST for the operand
-- **Returns:** omdNode
-
----
-
-#### `computeDimensions()`
-Calculates dimensions of expression.
-- Computes dimensions of operator and operand
-- Sets total width and height
-- No extra spacing for unary minus
-
----
-
-#### `updateLayout()`
-Updates positions of elements.
-- Centers operator and operand vertically
-- Places operator before operand
-
----
-
-#### `clone()`
-Creates a deep clone of the expression node, including operator and operand, and preserves provenance.
-- **Returns:** omdUnaryExpressionNode - New instance with:
-  - Cloned AST data
-  - Preserved background rectangle
-  - Cloned operator and operand
-  - Rebuilt argument list
-  - Original node's ID added to provenance array
-
----
-
-#### `toMathJSNode()`
-Converts to math.js AST format.
-- **Returns:** Object - A math.js-compatible AST node with:
-  - `type`: "OperatorNode"
-  - `op`: Operator symbol
-  - `fn`: Operation name
-  - `args`: [operand AST]
-  - `id`: Node ID
-  - `provenance`: Provenance array
-
----
-
-#### `toString()`
-Convert to string representation.
-- Adds parentheses if needed
-- **Returns:** string - Format: "-operand" or "-(operand)"
-
----
-
-#### `needsParentheses()`
-Check if operand needs parentheses.
-- **Returns:** boolean - True if operand is binary expression
-
----
-
-#### `evaluate(variables)`
-Evaluate the expression.
-- `variables` {Object} - Variable name to value mapping
-- **Returns:** number - Negated value for '-', same value for '+'
-- **Returns:** NaN if operand can't be evaluated
-
----
-
-#### `simplify()`
-Attempt to simplify expression using the central simplification engine.
-- **Returns:** Object with:
-  - `success`: Whether simplified
-  - `newRoot`: Simplified expression
-  - `message`: Description of changes
-
-### Static Methods
-
-#### `fromString(expressionString)`
-Create node from string.
-- `expressionString` {string} - Expression with unary operation
-- **Returns:** omdUnaryExpressionNode
-- **Throws:** Error if not unary minus operation or if parsing fails
-
-### Example
-
-```javascript
-// Create from AST
-const node = new omdUnaryExpressionNode({
-  type: 'OperatorNode',
-  op: '-',
-  fn: 'unaryMinus',
-  args: [
-    { type: 'SymbolNode', name: 'x' }
-  ]
-});
-
-// Complex operand
-const complex = new omdUnaryExpressionNode({
-  type: 'OperatorNode',
-  op: '-',
-  fn: 'unaryMinus',
-  args: [{
-    type: 'OperatorNode',
-    op: '+',
-    fn: 'add',
-    args: [
-      { type: 'SymbolNode', name: 'x' },
-      { type: 'ConstantNode', value: 1 }
-    ]
-  }]
-});
-
-// Render with proper spacing
-node.setFontSize(24);
-node.computeDimensions();
-node.updateLayout();
-```
-
-### See Also
-
-- [omdNode](./omdNode.md) - Parent class
-- [omdOperatorNode](./omdOperatorNode.md) - For operator symbol
-- [omdBinaryExpressionNode](./omdBinaryExpressionNode.md) - For complex operands
-- [omdConstantNode](./omdConstantNode.md) - For numeric operands
+# omdUnaryExpressionNode
+
+Represents unary operations (like negation) in mathematical expressions (e.g., `-x`, `-(a + b)`). This node handles rendering, layout, evaluation, and conversion to math.js AST for expressions with a single operand.
+
+## Class Definition
+
+```javascript
+export class omdUnaryExpressionNode extends omdNode
+```
+
+## Constructor
+
+### `new omdUnaryExpressionNode(ast)`
+
+Creates a new `omdUnaryExpressionNode` instance.
+
+-   **`ast`** (`object`): The math.js AST node for the unary operation. It must contain:
+    -   `args`: An array with exactly one operand AST node.
+    -   `op`: The operator symbol (e.g., `'-'`, `'+'`).
+    -   `fn`: The operation name (e.g., `'unaryMinus'`, `'unaryPlus'`).
+
+During construction, it creates an `omdOperatorNode` for the unary operator and an `omdNode` for the operand. It throws an error if the AST does not have exactly one argument.
+
+## Static Methods
+
+### `fromString(expressionString)`
+
+Creates an `omdUnaryExpressionNode` from a string representation of a unary expression. Requires `window.math` (math.js) to be available globally for parsing.
+
+-   **`expressionString`** (`string`): The unary expression as a string (e.g., `"-x"`, `"-(a+b)"`).
+-   **Returns**: `omdUnaryExpressionNode` - A new instance.
+-   **Throws**: `Error` if `math.js` is not available, if the string cannot be parsed, or if it does not represent a valid unary minus operation.
+
+## Public Properties
+
+-   **`op`** (`omdOperatorNode`): The `omdOperatorNode` representing the unary operator (e.g., `-`).
+-   **`operand`** (`omdNode`): The `omdNode` representing the expression being operated on.
+-   **`operation`** (`string`): The name of the operation (e.g., `'unaryMinus'`).
+
+## Public Methods
+
+### `computeDimensions()`
+
+Calculates the dimensions of the unary expression node. It sums the widths of the operator and the operand to get the total width. The height is the maximum of the operator's and operand's heights. No extra spacing is added between the unary operator and its operand.
+
+-   **Overrides**: `omdNode.computeDimensions()`.
+
+### `updateLayout()`
+
+Updates the layout of the unary expression node. It positions the operator to the left and the operand to its right, both vertically centered within the node's total height.
+
+-   **Overrides**: `omdNode.updateLayout()`.
+
+### `clone()`
+
+Creates a deep, structural clone of the unary expression node, including its `op` and `operand` nodes. The cloned node's `provenance` array is updated to include the original node's ID.
+
+-   **Returns**: `omdUnaryExpressionNode` - A new, identical instance of the unary expression node.
+
+### `toMathJSNode()`
+
+Converts the `omdUnaryExpressionNode` back into its math.js AST representation. It creates an `OperatorNode` with the unary operator and the converted operand AST.
+
+-   **Returns**: `object` - A math.js `OperatorNode` for the unary operation. The returned object also includes a `clone` method for compatibility.
+
+### `toString()`
+
+Converts the unary expression node to its string representation. It adds parentheses around the operand if `needsParentheses()` returns `true` (e.g., for binary expressions).
+
+-   **Returns**: `string` - Format: `"-operand"` or `"-(operand)"`.
+
+### `needsParentheses()`
+
+Checks if the operand needs to be wrapped in parentheses when converted to a string. This is typically `true` if the operand is a binary expression, to maintain correct order of operations.
+
+-   **Returns**: `boolean` - `true` if parentheses are required around the operand.
+
+### `evaluate(variables)`
+
+Evaluates the unary expression. It evaluates the `operand` and then applies the unary operation (e.g., negation for `'-'`).
+
+-   **`variables`** (`object`): A map of variable names to their numeric values.
+-   **Returns**: `number` - The result of the unary operation, or `NaN` if the operand cannot be evaluated to a number.
+
+## Internal Methods
+
+-   **`createOperatorNode(ast)`**: Creates an `omdOperatorNode` for the unary operator from its AST, setting its parent to this node.
+-   **`createExpressionNode(ast)`**: Creates an `omdNode` instance for the operand from its AST, setting its parent to this node.
+
+## Example
+
+```javascript
+import { omdUnaryExpressionNode } from '@teachinglab/omd';
+import * as math from 'mathjs';
+
+// Create from AST: -x
+const node = new omdUnaryExpressionNode({
+  type: 'OperatorNode',
+  op: '-',
+  fn: 'unaryMinus',
+  args: [
+    { type: 'SymbolNode', name: 'x' }
+  ]
+});
+
+// Create from AST: -(x + 1)
+const complex = new omdUnaryExpressionNode({
+  type: 'OperatorNode',
+  op: '-',
+  fn: 'unaryMinus',
+  args: [{
+    type: 'OperatorNode',
+    op: '+',
+    fn: 'add',
+    args: [
+      { type: 'SymbolNode', name: 'x' },
+      { type: 'ConstantNode', value: 1 }
+    ]
+  }]
+});
+
+// Render and layout
+node.setFontSize(24);
+node.initialize();
+
+// Add to an SVG container to display
+// const svgContainer = new jsvgContainer();
+// svgContainer.addChild(node);
+// document.body.appendChild(svgContainer.svgObject);
+```
+
+## See Also
+
+-   [`omdNode`](./omdNode.md) - Parent class.
+-   [`omdOperatorNode`](./omdOperatorNode.md) - For the operator symbol.
+-   [`omdBinaryExpressionNode`](./omdBinaryExpressionNode.md) - Often used for complex operands within a unary expression.
+-   [`omdConstantNode`](./omdConstantNode.md) - For numeric operands.