feat: updated to jsdelivr

Author: arnog

docs/compute-engine/01-introduction.md

@@ -8,12 +8,12 @@ description: The Compute Engine is a JavaScript/TypeScript library for symbolic
 sidebar_class_name: "compass-icon"
 ---
 
-<HeroImage path="/img/hero/compute-engine.jpg" >
+<HeroImage path="/img/hand-gears.jpg" >
 # Compute Engine
 </HeroImage>
 
 <Intro>
-The **Compute Engine** is a JavaScript/TypeScript library for symbolic
+A JavaScript/TypeScript library for symbolic
 computing and numeric evaluation of mathematical expressions.
 </Intro>
 
@@ -99,16 +99,23 @@ Compute Engine module from a CDN using an `import` statement.
 
 ```html
 <script type="module">
-  import { ComputeEngine } from 
-    "https://unpkg.com/@cortex-js/compute-engine?module";
+  import { ComputeEngine } from "https://esm.run/@cortex-js/compute-engine";
 
   const ce = new ComputeEngine();
   ce.parse("e^{i\\pi}").evaluate().print();
   // ➔ "-1"
 </script>
 ```
 
-The ESM (module) version is also available in the npm package in `dist/compute-engine.min.esm.js` 
+Alternatively, you can use the **unpkg** CDN to load the module:
+
+```js
+  import { ComputeEngine } from 
+    "https://unpkg.com/@cortex-js/compute-engine?module";
+```
+
+
+The ESM (module) version is also available in the npm package in `/compute-engine.min.esm.js` 
 
 
 ### Using Vintage JavaScript
@@ -121,11 +128,11 @@ version by using a `<script>` tag.
 For example, WebPack 4 does not support the optional chaining operator, using 
 the UMD version will make use of polyfills as necessary.
 
-The UMD version is also available in the npm package in `dist/compute-engine.min.js` 
+The UMD version is also available in the npm package in `/compute-engine.min.js` 
 
 
 ```html
-<script src="//unpkg.com/@cortex-js/compute-engine"></script>
+<script src="https://cdn.jsdelivr.net/npm/@cortex-js/compute-engine/compute-engine.min.js"></script>
 <script>
   window.onload = function() {
     const ce = new ComputeEngine.ComputeEngine();
@@ -135,10 +142,17 @@ The UMD version is also available in the npm package in `dist/compute-engine.min
 </script>
 ```
 
+Alternatively, you can use the **unpkg** CDN to load the module:
+
+```html
+<script src="//unpkg.com/@cortex-js/compute-engine"></script>
+```
+
+
 ### Other Versions
 
 A non-minified module which may be useful for debugging is available in
-the npm package as `dist/compute-engine.esm.js`.
+the npm package as `/compute-engine.esm.js`.
 
 ## MathJSON Standard Library
 

docs/compute-engine/03-guide-expressions.md

@@ -300,28 +300,27 @@ function itself is pure, and all its arguments are pure as well.
 
 ## Checking the Kind of Expression
 
-To identify if an expression is a number, symbol, function or string
-use the following boolean expressions:
+To identify if an expression is a number literal, symbol, function expression 
+or string use the following boolean expressions:
 
 <div className="symbols-table first-column-header">
 
-| Kind           | Boolean Expression                                     |
-| :------------- | :----------------------------------------------------- |
-| **Number**     | `expr.isNumberLiteral`                           |
-| **Symbol**     | `expr.symbol !== null` |
-| **Function**   | `expr.ops !== null`                                    |
-| **String**     | `expr.string !== null`  |
+| Kind           | Boolean Expression                  |
+| :------------- | :---------------------------------- |
+| **Number**     | `expr.isNumberLiteral`              |
+| **Symbol**     | `expr.symbol !== null`              |
+| **Function**   | `expr.isFunctionExpression`         |
+| **String**     | `expr.string !== null`              |
 
 </div>
 
-The value of `expr.numericValue` may be:
-
-- `typeof expr.numericValue === "number"`: the expression is a JavaScript number
-- otherwise, the property is a `NumericValue` object.
-
 **To access a the value of an expression as a JavaScript primitive**, use
 `expr.value`. The result is a JavaScript primitive, such as a number, string or
-boolean.
+boolean. When converting to a number, the result may have lost precision if the
+original expression had more than 15 digits of precision. Note that `expr.value`
+is equivalent to `expr.valueOf()`.
+
+
 
 **To access the value of an expression as a JavaScript number**, use
 `expr.re`. The result is the real part of the number, as a JavaScript number, 

docs/compute-engine/04-guide-symbols.md

@@ -6,19 +6,6 @@ date: Last Modified
 toc: true
 ---
 
-<script type="module">{`
-  window.addEventListener("DOMContentLoaded", () => 
-    import("//unpkg.com/@cortex-js/compute-engine?module").then((ComputeEngine) => {
-      globalThis.ce = new ComputeEngine.ComputeEngine();
-      const playgrounds = [...document.querySelectorAll("code-playground")];
-      for (const playground of playgrounds) {
-        playground.autorun = 1000; // delay in ms
-        playground.run();
-      }
-    })
-);
-`}</script>
-
 
 <Intro>
 A **symbol** is an identifier representing a named mathematical object. It 

docs/compute-engine/05-guide-canonical-form.md

@@ -223,29 +223,18 @@ canonical form that is closer to the user input.
 **To get the non-canonical form**, use `ce.box(expr, { canonical: false })` or
 `ce.parse(s, { canonical: false })`.
 
-```js example
-const expr = ce.parse("2(0+x\\times x-1)", {canonical: false});
-console.log(expr.json);
-// ➔ ["InvisibleOperator", 
-//      2,
-//      ["Delimiter",
-//        ["Sequence", ["Add", 0, ["Subtract", ["Multiply","x","x"],1]]]
-//      ]
-//   ]
+```live
+console.log(ce.parse("2(0+x\\times x-1)", {canonical: false}).json);
 ```
 
 **To get the full canonical form**, use `ce.box(expr, { canonical: true })` or
 `ce.parse(s, { canonical: true })`. The `canonical` option can be omitted
 as it is `true` by default.
 
-```js example
-const expr = ce.parse("2(0+x\\times x-1)", 
-  {canonical: true}
-).print();
-// ➔ ["Multiply", 2, ["Subtract", ["Square", "x"], 1]]
+```live
+console.log(ce.parse("2(0+x\\times x-1)", {canonical: true}).json);
 
-const expr = ce.parse("2(0+x\\times x-1)").print();
-// ➔ ["Multiply", 2, ["Subtract", ["Square", "x"], 1]]
+console.log(ce.parse("2(0+x\\times x-1)").json);
 ```
 
 **To get a custom canonical form of an expression**, use the
@@ -257,12 +246,10 @@ and `ce.parse()`.
 
 **To order the arguments in a canonical order**, use `ce.box(expr, { canonical: "Order" })` or `ce.parse(s, { canonical: "Order" })`.
 
-```js example
-const expr = ce.parse("0+1+x+2+\\sqrt{5}", 
+```live
+ce.parse("0+1+x+2+\\sqrt{5}", 
   {canonical: "Order"}
-);
-expr.print();
-// ➔ ["Add", ["Sqrt", 5], "x", 0, 1, 2]
+).print();
 ```
 
 Note in particular that the `0` is preserved in the expression, which is not
@@ -274,17 +261,14 @@ expression. See the documentation of
 
 For example:
 
-```js example
-const latex = "2(0+x\\times x-1)";
+```live
+const latex = "3(2+x)";
 ce.parse(latex, {canonical: false}).print();
-// -> ["InvisibleOperator",2,["Delimiter",["Sequence",["Add",0,["Subtract",["Multiply","x","x"],1]]]]]
 
 ce.parse(latex, {canonical: ["InvisibleOperator"]}).print();
-// -> ["Multiply",2,["Add",0,["Subtract",["Multiply","x","x"],1]]]
 
 ce.parse(latex, 
   {canonical: ["InvisibleOperator", "Add", "Order", ]}
-);
-// -> ["Multiply",2,["Subtract",["Multiply","x","x"],1]]
+).print();
 ```
 

docs/compute-engine/06-guide-augmenting.md

@@ -242,7 +242,7 @@ ce.assign("double",ce.parse("x \\mapsto 2x"));
 **To overload a function**, use the `ce.lookupFunction()` and  `ce.define()` methods.
 
 For example, to overload the `Sqrt` function to return `NaN` for
-non-real numbers, you can use the following code:
+non-real numbers, use the following code:
 
 ```js
 const originalSqrtDefinition = ce.lookupFunction('Sqrt')!;

docs/compute-engine/07-guide-latex-syntax.md

@@ -505,13 +505,46 @@ console.log(ce.parse('\\smoll{1}{5}').json);
 // both arguments are integers.
 // ➔ ["Rational", 1, 5]
 ```
+
+
+**To override an existing entry**, create a new array that includes the
+default entries and add your own entry at the end of the array.
+
+Entries at the end of the array will override earlier entries. When parsing
+an expression, the first entry (starting at the bottom) whose trigger
+matches is selected.
+
+```
+ce.latexDictionary = [
+  ...ce.latexDictionary,
+  // The entry below will override the default entry for the `\times` command
+  {
+    latexTrigger: ['\\times'],
+    name: 'CrossProduct',
+    kind: 'infix',
+    associativity: 'none'
+    precedence: 390,
+  },
+];
+```
+
 :::caution
-Do not modify the `ce.latexDictionary` array directly. Instead, create a new
-array that includes the entries from the default dictionary, and add your own
+Do not modify the `ce.latexDictionary` array, or the entries in the array, 
+directly. Instead, create a new array that includes the entries from the \
+default dictionary, and add your own
 entries. Later entries will override earlier ones, so you can replace or
 modify existing entries by providing a new definition for them.
 :::
 
+The `precedence` property is used to determine the order of operations when parsing
+expressions, but it does not impact whether an entry is used for parsing. Only the 
+`latexTrigger` or `identifierTrigger` properties are used to determine if an entry
+is used for parsing.
+
+Note that `latexTrigger` can be an array of tokens. However, the tokens
+are not interpreted as alternatives. The array is treated as a sequence of tokens
+that must be matched in order.
+
 ### LaTeX Dictionary Entries
 
 Each entry in the LaTeX dictionary is an object with the following properties:

docs/compute-engine/09-guide-symbolic-computing.md

@@ -180,13 +180,12 @@ console.log('isEqual?', a.isEqual(b));
 |                                          |                                        |
 | :--------------------------------------- | :------------------------------------- |
 | `lhs === rhs`                            | If true, same box expression instances |
-| `lhs.value === rhs.value`                | Equivalent to `lhs.N().isEqual(rhs.N())` |
 | `lhs.isSame(rhs)`                        | Structural equality                    |
 | `lhs.isEqual(rhs)`                       | Mathematical equality                  |
 | `lhs.match(rhs) !== null`                | Pattern match                          |
-| `lhs.is(rhs)`                            | Synonym for `isSame()`                 |
-| `ce.box(["Equal", lhs, rhs]).evaluate()` | Synonym for `isEqual()`                |
-| `ce.box(["Same", lhs, rhs]).evaluate()`  | Synonym for `isSame()`                 |
+| `lhs.is(rhs)`                            | Synonym for `lhs.isSame(rhs)`, but the argument of `is()` can be a boolean or number.                 |
+| `ce.box(["Equal", lhs, rhs]).evaluate()` | Synonym for `lhs.isEqual(rhs)`                |
+| `ce.box(["Same", lhs, rhs]).evaluate()`  | Synonym for `lhs.isSame(rhs)`                 |
 
 </div>
 

docs/compute-engine/12-guide-numerical-evaluations.md

@@ -81,11 +81,6 @@ console.log(expr.N().value);
 // ➔ 0.5833333333333334
 ```
 
-Unlike the `.re` property, the `.value` property can also return a `boolean`,
-a `string`, depending on the value of the expression.
-
-
-
 The `value` property of a boxed expression can be used in JavaScript
 expressions.
 
@@ -94,11 +89,17 @@ const expr = ce.parse('1/3 + 1/4');
 console.log(expr.N().value + 1);
 ```
 
+
+Unlike the `.re` property, the `.value` property can also return a `boolean`
+or a `string`, depending on the value of the expression.
+
+
+
 **To get a boxed number from a JavaScript number**, use `ce.box()` or `ce.number()`.
 
 ```live
 const boxed = ce.box(1.5);
-console.log(boxed.N().value);
+console.log(boxed.value);
 ```
 
 
@@ -221,7 +222,7 @@ of variables. `ce.assign()` changes the value associated with one or more
 variables in the current scope.
 
 ```live
-const expr = ce.parse('3x^2+4x+2');
+const expr = ce.parse("3x^2+4x+2");
 
 for (let x = 0; x < 1; x += 0.01) {
   ce.assign('x', x);
@@ -233,7 +234,7 @@ You can also use `expr.subs()`, but this will create a brand new expression on
 each iteration, and will be much slower.
 
 ```live
-const expr = ce.parse('3x^2+4x+2');
+const expr = ce.parse("3x^2+4x+2");
 
 for (let x = 0; x < 1; x += 0.01) {
   console.log(`f(${x}) = ${expr.subs({ x }).evaluate()}`);
@@ -245,16 +246,16 @@ for (let x = 0; x < 1; x += 0.01) {
 ```live
 ce.assign("x", null);
 
-console.log(ce.parse('3x^2+4x+2').N());
+console.log(ce.parse("3x^2+4x+2").N());
 // ➔ "3x^2+4x+c"
 ```
 
 **To change the value of a variable** set its `value` property:
 
 ```ts
-ce.symbol('x').value = 5;
+ce.symbol("x").value = 5;
 
-ce.symbol('x').value = undefined;
+ce.symbol("x").value = undefined;
 ```
 
 

docs/compute-engine/50-math-json.md

@@ -20,7 +20,7 @@ export function setupComputeEngine() {
   const [value, setValue] = useState(children);
   const [json, setJson] = useState({});
   window.ce = new ComputeEngine.ComputeEngine();
-    setJson(window.ce?.parse(value).json);
+  setJson(window.ce?.parse(value).json);
 }
 export function MathJSONOutput({children}) {
   const [value, setValue] = useState(children);
@@ -42,12 +42,12 @@ export function MathJSONOutput({children}) {
 }
 
 
-<HeroImage path="/img/hero/math-json.jpg" >
+<HeroImage path="/img/hand-cube.jpg" >
 # MathJSON
 </HeroImage>
 
 <Intro>
-MathJSON: a lightweight data interchange format for mathematical notation.
+A lightweight data interchange format for mathematical notation.
 </Intro>
 
 <div className="symbols-table">