forma-dsl 0.3.8 → 0.4.0

package/README.md

@@ -6,7 +6,7 @@
 A declarative DSL for 3D modeling and scene composition, with reusable components and live
 previews.
 
-Models are written as text — blocks, attributes and expressions in an HCL-like syntax —
+Models are written as text - blocks, attributes and expressions in an HCL-like syntax -
 parsed and solved by the [Manifold](https://github.com/elalish/manifold) CSG kernel compiled
 to WebAssembly. It runs unchanged in Node and in the browser.
 
@@ -97,10 +97,11 @@ Hand-written TypeScript declarations ship with it, so the API is typed from eith
 
 ## Documentation
 
-**[The full reference](https://kalpak44.github.io/forma-dsl/docs/)** — every declaration,
+**[The full reference](https://kalpak44.github.io/forma-dsl/docs/)** - every declaration,
 block, function and error, each with usage and troubleshooting. The
 **[editor](https://kalpak44.github.io/forma-dsl/editor/)** runs the whole thing in the browser:
-type, and the solid updates.
+type, and the solid updates. **[The site](https://kalpak44.github.io/forma-dsl/)** has a demo
+that types a document out and solves it as it goes.
 
 ## How it works
 
@@ -113,7 +114,7 @@ source ──▶ lexer ──▶ parser ──▶ evaluator ──▶ geometry n
 The evaluator does not call the kernel. It produces a tree of immutable geometry nodes, each
 carrying a 128-bit digest of its own content and its children's digests. Identity is digest
 identity, so a component used twenty times is one node, evaluated once. Nodes are the only
-thing that reaches the kernel, and every result is memoized by digest — which is what makes
+thing that reaches the kernel, and every result is memoized by digest - which is what makes
 an edit cheap, since only the subtrees whose content actually changed are re-evaluated.
 
 WebAssembly objects are not garbage-collected, so an `EvaluationContext` owns everything it
@@ -124,4 +125,4 @@ One runtime dependency, `manifold-3d`.
 
 ## License
 
-MIT — see [LICENSE](LICENSE).
+MIT - see [LICENSE](LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forma-dsl",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "description": "A declarative DSL for 3D modeling and scene composition, reusable components, and live previews.",
   "keywords": [
     "cad",

package/src/core/context.js

@@ -4,7 +4,7 @@
  *
  * Two things earn this its own module. The cache is keyed on content rather than on object
  * identity, so an edit that rebuilds the tree from scratch still hits every subtree it did
- * not change — which is what makes re-solving on a keystroke affordable. And the kernel's
+ * not change - which is what makes re-solving on a keystroke affordable. And the kernel's
  * objects are WASM allocations that no garbage collector will free, so something has to own
  * them and let them go; that is what `dispose` and `collect` are for, and why the caller is
  * told in `render`'s contract that the context is theirs.
@@ -18,8 +18,8 @@ import { loadKernel } from './kernel.js';
 /**
  * How many unreachable entries `collect` keeps.
  *
- * Editing a model churns the tree — a keystroke changes one subtree and leaves its siblings
- * untouched — so the entries that just fell out of the tree are the ones most likely to come
+ * Editing a model churns the tree - a keystroke changes one subtree and leaves its siblings
+ * untouched - so the entries that just fell out of the tree are the ones most likely to come
  * straight back, on an undo or on the next character of a number being typed.
  */
 const DEFAULT_RETAINED = 512;
@@ -113,7 +113,7 @@ export class EvaluationContext {
   /**
    * Resolves to the kernel object for a node.
    *
-   * Concurrent requests for the same node share one evaluation — without the in-flight map,
+   * Concurrent requests for the same node share one evaluation - without the in-flight map,
    * a shape used twice in a tree that is walked concurrently would be built twice and one
    * copy leaked.
    *
@@ -335,6 +335,6 @@ function free(value) {
   try {
     value?.delete();
   } catch {
-    // Already freed by the kernel, or never owned one — either way there is nothing to do.
+    // Already freed by the kernel, or never owned one - either way there is nothing to do.
   }
 }

package/src/core/digest.js

@@ -23,8 +23,8 @@ function rotl(x, r) {
 /**
  * Wraps a number to a signed 32-bit integer, the way the algorithm's additions are defined.
  *
- * `Math.imul(x, 1)` rather than `x | 0`: the two are identical — both coerce through
- * ToInt32 — but this one says *wrap*, which is what MurmurHash means here. `Math.trunc` is
+ * `Math.imul(x, 1)` rather than `x | 0`: the two are identical - both coerce through
+ * ToInt32 - but this one says *wrap*, which is what MurmurHash means here. `Math.trunc` is
  * emphatically not a substitute: it drops the fraction without wrapping, so `2**31 + 5`
  * stays positive instead of becoming negative, and every digest downstream changes.
  *
@@ -68,7 +68,7 @@ function fmix(h) {
 /**
  * Packs the bytes after the last whole block into four words, little-endian.
  *
- * Byte `i` of the tail belongs to word `i >> 2` at shift `(i & 3) * 8` — which is what
+ * Byte `i` of the tail belongs to word `i >> 2` at shift `(i & 3) * 8` - which is what
  * MurmurHash3's fallthrough spells out one case at a time. The arithmetic is identical;
  * only the shape differs, and the digests it produces are asserted to be unchanged.
  *

package/src/core/kernel.js

@@ -2,7 +2,7 @@
  * Loading the Manifold WASM module, and the global knobs for curve resolution.
  *
  * One instance per page or process. Memoized here rather than left to each caller, because
- * two models evaluating concurrently at startup must not each start an instantiation — and
+ * two models evaluating concurrently at startup must not each start an instantiation - and
  * because the resolution controls below are global to the module, so there is nowhere else
  * they could honestly live.
  */
@@ -38,7 +38,7 @@ export function loadKernel(options) {
       return wasm;
     }, (error) => {
       // A rejected promise would be memoized along with everything else, so a transient
-      // failure — a WASM fetch that lost the network — would be permanent for the page.
+      // failure - a WASM fetch that lost the network - would be permanent for the page.
       modulePromise = null;
       throw error;
     });

package/src/core/node.js

@@ -2,7 +2,7 @@
  * The geometry tree: a description of geometry that has not been built yet.
  *
  * A node names an operation and its children, and carries a digest of the whole subtree
- * beneath it. Nothing here touches the kernel — that separation is the point, and the
+ * beneath it. Nothing here touches the kernel - that separation is the point, and the
  * evaluation context is the other half of it.
  *
  * The digest is what the evaluation cache is keyed on, so everything feeding it has to be
@@ -19,7 +19,7 @@ import { Transform } from '../values/transform.js';
 /**
  * Orders strings by UTF-16 code unit, which is what a bare `sort()` does.
  *
- * Written out rather than left implicit — and deliberately *not* `localeCompare`, which is
+ * Written out rather than left implicit - and deliberately *not* `localeCompare`, which is
  * what a linter will suggest. Collation is locale-dependent, and this ordering feeds the
  * digest: two machines with different locales would have to agree, or the cache would miss
  * across them and a model would re-solve from scratch on someone else's laptop.

package/src/export/stl.js

@@ -1,8 +1,8 @@
 /**
  * Binary STL, for handing a solved part to a slicer.
  *
- * STL is the least a mesh format can carry — triangles and normals, no units, no colour and
- * no notion of a part — and it is what every slicer reads. Anything richer belongs in its
+ * STL is the least a mesh format can carry - triangles and normals, no units, no colour and
+ * no notion of a part - and it is what every slicer reads. Anything richer belongs in its
  * own exporter rather than in a dialect of this one.
  */
 

package/src/index.d.ts

@@ -47,6 +47,17 @@ export interface FormaDocument {
 
 export declare function parse(source: string): FormaDocument;
 
+/**
+ * Renders the lines around a position with a caret under its column.
+ *
+ * Both the CLI and the MCP server print this beside an error message; a position on its own
+ * still makes the reader count lines.
+ */
+export declare function excerpt(
+  source: string,
+  loc?: Pick<SourceLocation, 'line' | 'column'> | null,
+): string | undefined;
+
 // --- the kernel -------------------------------------------------------------------------
 
 // Re-exported from the dependency rather than restated here. A hand-written approximation
@@ -66,7 +77,7 @@ export type Kernel = ManifoldToplevel;
  * A live 3D solid owned by an EvaluationContext.
  *
  * WebAssembly objects are not garbage-collected. Anything obtained from a context belongs
- * to that context — do not call `delete()` on it yourself.
+ * to that context - do not call `delete()` on it yourself.
  */
 export type Solid = Manifold;
 
@@ -146,7 +157,7 @@ export declare class Transform {
   readonly m: readonly number[];
   readonly order: number;
   at(row: number, col: number): number;
-  /** `this ∘ other` — `other` runs first. */
+  /** `this ∘ other` - `other` runs first. */
   concat(other: Transform): Transform;
   toArray(): number[];
 }
@@ -204,7 +215,7 @@ export interface ContextStats {
 /**
  * Evaluates a geometry tree against the Manifold kernel, memoized by node digest.
  *
- * A context is meant to outlive a single render — reusing one is what makes a re-render
+ * A context is meant to outlive a single render - reusing one is what makes a re-render
  * after an edit skip the subtrees that did not change. It owns every WASM object it holds,
  * so it must eventually be `dispose()`d, and `collect()` bounds what it holds meanwhile.
  */
@@ -357,6 +368,12 @@ export interface FunctionDefinition {
 export declare const FUNCTIONS: Record<string, FunctionDefinition>;
 export declare const CONSTANTS: Record<string, number>;
 
+/**
+ * The type names a `param` block may declare, each of which is also an ordinary identifier
+ * bound to itself in the root scope - which is why `type = number` needs no quoting.
+ */
+export declare const TYPE_NAMES: readonly ParameterType[];
+
 export interface RenderMesh {
   /** Three vertices per triangle, expanded so hard edges stay hard. */
   positions: Float32Array;

package/src/index.js

@@ -13,7 +13,8 @@
 export { Program, Evaluator } from './lang/evaluate.js';
 export { parse } from './lang/parser.js';
 export { tokenize, FormaError } from './lang/lexer.js';
-export { BLOCKS, FUNCTIONS, CONSTANTS } from './lang/builtins.js';
+export { excerpt } from './lang/excerpt.js';
+export { BLOCKS, FUNCTIONS, CONSTANTS, TYPE_NAMES } from './lang/builtins.js';
 export { GeometryNode } from './core/node.js';
 export { EvaluationContext } from './core/context.js';
 export { loadKernel, setQuality, resetQuality } from './core/kernel.js';
@@ -32,7 +33,7 @@ import { toRenderMesh } from './export/mesh.js';
  *
  * The caller owns the returned `context` and must dispose it: it holds the WASM objects for
  * every node in the tree, and those are not garbage-collected. Passing the same context back
- * on the next call is the intended use — that is what lets the digest cache skip the subtrees
+ * on the next call is the intended use - that is what lets the digest cache skip the subtrees
  * an edit did not change. Call `context.collect(parts.map(p => p.node))` afterwards to bound
  * how much a reused context holds.
  *
@@ -66,7 +67,7 @@ export async function render(source, options = {}) {
       // Checked before solving rather than after: a 2D part is going to be refused either
       // way, and there is no reason to spend the kernel call first.
       if (part.node.dim !== 3) {
-        throw new Error(`part "${part.name}" is 2D — extrude or revolve it before rendering`);
+        throw new Error(`part "${part.name}" is 2D - extrude or revolve it before rendering`);
       }
       // The check above is what makes this a solid rather than a cross-section.
       const concrete = /** @type {Solid} */ (await owned.evaluate(part.node));
@@ -110,7 +111,7 @@ export function describeParameters(source) {
     try {
       return evaluator.expression(expression, evaluator.root);
     } catch {
-      // One unreadable attribute — a min that refers to a param with no value yet — must
+      // One unreadable attribute - a min that refers to a param with no value yet - must
       // not cost the caller every other descriptor in the document.
       return undefined;
     }

package/src/lang/ast.d.ts

@@ -5,7 +5,7 @@
  * one carries, could only be recovered by reading the parser and the evaluator side by side
  * and hoping they agreed.
  *
- * Declarations rather than JSDoc typedefs, which is what this always was — there is no
+ * Declarations rather than JSDoc typedefs, which is what this always was - there is no
  * runtime content here, so there is nothing for a `.js` file to carry and nothing to build.
  * Written as types, a discriminant is `kind: 'unary'` rather than a `@property` whose
  * description the lint obliged someone to invent.

package/src/lang/builtins.js

@@ -4,7 +4,7 @@
  *
  * This is the one description of what the language contains. The editor's highlighting, the
  * landing page's and the docs' code samples, and the MCP server's catalogue all read
- * `BLOCKS` and `FUNCTIONS` from here rather than restating them — so a block added here is
+ * `BLOCKS` and `FUNCTIONS` from here rather than restating them - so a block added here is
  * one they all learn about, and a block they claim without it existing fails their tests.
  */
 
@@ -195,8 +195,8 @@ export class Args {
    * leaves it guessing at spellings. What it read is tracked already, so the list costs
    * nothing to produce.
    *
-   * A block that branches on which of two spellings it was given — `radius` against
-   * `diameter` — only reads one of them, so the list is what this call would accept and not
+   * A block that branches on which of two spellings it was given - `radius` against
+   * `diameter` - only reads one of them, so the list is what this call would accept and not
    * always the whole set.
    *
    * @returns {void}
@@ -207,7 +207,7 @@ export class Args {
     if (extra.length) {
       const plural = extra.length > 1 ? 's' : '';
       const reads = [...this.used].sort((a, z) => a.localeCompare(z));
-      const instead = reads.length ? ` — ${this.type} reads ${quoteAll(reads)}` : '';
+      const instead = reads.length ? ` - ${this.type} reads ${quoteAll(reads)}` : '';
       throw new FormaError(
         `${this.type}: unknown attribute${plural} ${quoteAll(extra)}${instead}`,
         this.loc,
@@ -579,6 +579,6 @@ export const CONSTANTS = { pi: Math.PI, e: Math.E };
 
 /**
  * Type names are ordinary identifiers that stand for themselves, so `type = number` in a
- * param block needs no keyword and no quoting — the same trade HCL makes.
+ * param block needs no keyword and no quoting - the same trade HCL makes.
  */
 export const TYPE_NAMES = ['number', 'string', 'bool', 'vector', 'list', 'angle'];

package/src/lang/evaluate.js

@@ -3,7 +3,7 @@
  *
  * Nothing here calls the kernel. Evaluating a model produces {@link GeometryNode}s, which
  * describe geometry without building any, and solving those is {@link EvaluationContext}'s
- * job. Keeping the two apart is what makes a live preview affordable — a description is
+ * job. Keeping the two apart is what makes a live preview affordable - a description is
  * cheap to rebuild on every keystroke, and a solid is not.
  *
  * The three things in this file fail in three different ways, which is why they are three
@@ -30,7 +30,7 @@ const SPECIAL_FORMS = ['align', 'for', 'if', 'part'];
 /**
  * What a body produces: geometry to hand upwards, and any scene parts declared inside it.
  *
- * Parts travel separately from nodes because a part is not an operand — it is a coloured
+ * Parts travel separately from nodes because a part is not an operand - it is a colored
  * piece of the finished scene, and an enclosing `translate` must not absorb it.
  *
  * @typedef {object} Produced
@@ -150,8 +150,8 @@ export class Program {
   /**
    * The declared parameters, in source order, as the editor needs them to build controls.
    *
-   * A param may legitimately have no default — the document then requires a value from the
-   * caller — so the descriptor has to stand on its own. `type` is taken from the declaration
+   * A param may legitimately have no default - the document then requires a value from the
+   * caller - so the descriptor has to stand on its own. `type` is taken from the declaration
    * when it is given and inferred from the default otherwise, and falls back to `number`,
    * which is what a param without either almost always is.
    *
@@ -205,8 +205,8 @@ export class Evaluator {
     /** @type {Program} The program being evaluated. */
     this.program = program;
     /**
-     * @type {EvaluationContext | null} Needed only by blocks that measure their child —
-     * `align` has to know where the geometry actually is — so a program without one can
+     * @type {EvaluationContext | null} Needed only by blocks that measure their child -
+     * `align` has to know where the geometry actually is - so a program without one can
      * still be built into a node tree without loading the kernel.
      */
     this.context = context;
@@ -217,13 +217,13 @@ export class Evaluator {
      * How many blocks may be built before evaluation gives up, or null for no limit.
      *
      * {@link MAX_DEPTH} stops a component that calls itself, and `range` caps how many values
-     * a single loop produces — but neither bounds their product. Two loops of ten thousand
+     * a single loop produces - but neither bounds their product. Two loops of ten thousand
      * nested in each other is a hundred million blocks, each one a kernel allocation, and no
      * amount of waiting finishes it.
      *
      * Off by default, because the embedder that controls its own input does not need it and
-     * should not have a ceiling imposed. A host that builds documents it did not write — an
-     * MCP server, a shared editor — should pass one.
+     * should not have a ceiling imposed. A host that builds documents it did not write - an
+     * MCP server, a shared editor - should pass one.
      *
      * @type {number | null}
      */
@@ -265,7 +265,7 @@ export class Evaluator {
 
   /**
    * Settles one declared param: what the caller gave, or what the declaration defaults to,
-   * or nothing at all — which is the caller's problem to report, since a document param and
+   * or nothing at all - which is the caller's problem to report, since a document param and
    * a component param say different things about it.
    *
    * @param {unknown} supplied What was passed in, or undefined.
@@ -452,6 +452,12 @@ export class Evaluator {
     /** @type {Produced} */
     const produced = { nodes: [], parts: [] };
 
+    // One block at a time, deliberately. `block` checks the signal and the node budget on
+    // the way in, so building these concurrently would enter every one of them before any
+    // could trip either - which turns `maxNodes` from a bound on how much gets built into a
+    // bound on how much gets built after everything has already started. There is also
+    // nothing to overlap: the evaluator is pure, and the one block that reaches the kernel
+    // is memoized by the context anyway.
     for (const block of body.blocks) {
       const result = await this.block(block, inner);
       produced.nodes.push(...result.nodes);
@@ -478,14 +484,14 @@ export class Evaluator {
 
     if (this.maxNodes !== null && ++this.built > this.maxNodes) {
       throw new FormaError(
-        `more than ${this.maxNodes} blocks built — the document asks for more geometry than `
+        `more than ${this.maxNodes} blocks built - the document asks for more geometry than `
         + 'this budget allows; narrow a loop, or raise maxNodes if it is genuinely this large',
         block.loc,
       );
     }
 
     if (this.depth > MAX_DEPTH) {
-      throw new FormaError(`nesting deeper than ${MAX_DEPTH} blocks — is a component using itself?`, block.loc);
+      throw new FormaError(`nesting deeper than ${MAX_DEPTH} blocks - is a component using itself?`, block.loc);
     }
 
     if (block.kind === 'for') return this.forBlock(block, scope);
@@ -505,7 +511,7 @@ export class Evaluator {
     if (!definition) {
       // The whole vocabulary, because the reader is often a program with no copy of the
       // manual: a misspelling it cannot correct from the error costs a round trip it has no
-      // way to end. Declared components come first — they are the names this document itself
+      // way to end. Declared components come first - they are the names this document itself
       // introduced, and the likeliest thing a near miss was reaching for.
       const known = [
         ...[...this.program.components.keys()].sort((a, z) => a.localeCompare(z)),
@@ -513,7 +519,7 @@ export class Evaluator {
         ...Object.keys(BLOCKS).sort((a, z) => a.localeCompare(z)),
       ];
       throw new FormaError(
-        `unknown block "${block.type}" — the blocks are ${quoteAll(known)}`,
+        `unknown block "${block.type}" - the blocks are ${quoteAll(known)}`,
         block.loc,
       );
     }
@@ -611,6 +617,9 @@ export class Evaluator {
     /** @type {Produced} */
     const produced = { nodes: [], parts: [] };
 
+    // Sequential for the same reason `body` is, and more so: this is the loop a runaway
+    // document runs away in, and the budget can only stop it if the iterations are entered
+    // one at a time.
     for (const [index, item] of sequence.entries()) {
       const iteration = scope.child();
       // One name binds the value; two bind the index and then the value.
@@ -665,7 +674,7 @@ export class Evaluator {
    */
   async alignBlock(block, scope) {
     if (!this.context) {
-      throw new FormaError('align needs a kernel context — render the model rather than building it', block.loc);
+      throw new FormaError('align needs a kernel context - render the model rather than building it', block.loc);
     }
     const args = new Args('align', this.attributes(block.body, scope), block.loc);
     const { nodes: children } = await this.body(block.body, scope.child());
@@ -903,7 +912,7 @@ function subtract(left, right, loc) {
 }
 
 /**
- * `*`: a vector times a scalar in either order — the common case in a model — componentwise
+ * `*`: a vector times a scalar in either order - the common case in a model - componentwise
  * on two lists, and ordinary multiplication otherwise.
  *
  * @param {unknown} left The left operand.

package/src/lang/excerpt.js

@@ -0,0 +1,41 @@
+/**
+ * Rendering the lines around an error, with a caret under the column it points at.
+ *
+ * Every error the language raises carries a position, and a position on its own still makes
+ * the reader count lines. This turns one into something that can be printed next to the
+ * message - which is what the CLI writes to stderr and what the MCP server hands back to a
+ * model that has just written a document that does not parse.
+ *
+ * It lives in the library rather than in either consumer because both want the same answer,
+ * and two copies of it would be two things to keep agreeing about what a column means.
+ */
+/** @import { SourceLocation } from '../index.js' */
+
+/** How many lines of source to show either side of the one in question. */
+const CONTEXT_LINES = 2;
+
+/**
+ * Renders a source excerpt with a caret under the column an error points at.
+ *
+ * @param {string} source The document.
+ * @param {Pick<SourceLocation, 'line' | 'column'> | null} [loc] Where the error was raised.
+ * @returns {string | undefined} The excerpt, or undefined when there is no position to show.
+ */
+export function excerpt(source, loc = null) {
+  if (!loc || !Number.isInteger(loc.line)) return undefined;
+
+  const lines = source.split('\n');
+  const first = Math.max(1, loc.line - CONTEXT_LINES);
+  const last = Math.min(lines.length, loc.line + CONTEXT_LINES);
+  const width = String(last).length;
+
+  /** @type {string[]} */
+  const out = [];
+  for (let n = first; n <= last; n++) {
+    out.push(`${String(n).padStart(width)} | ${lines[n - 1]}`);
+    if (n === loc.line) {
+      out.push(`${' '.repeat(width)} | ${' '.repeat(Math.max(0, loc.column - 1))}^`);
+    }
+  }
+  return out.join('\n');
+}

package/src/lang/lexer.js

@@ -3,7 +3,7 @@
  *
  * Strings are the one thing it does not hand on whole. A `"..."` carrying `${...}` is split
  * here into literal runs and spliced source, because working out where a splice ends means
- * counting braces — which is a job for something reading characters, not for a parser reading
+ * counting braces - which is a job for something reading characters, not for a parser reading
  * tokens.
  *
  * {@link FormaError} lives here rather than next to the evaluator because this is the first
@@ -62,15 +62,15 @@ const isDigit = (c) => c >= '0' && c <= '9';
 /**
  * @param {string} c A single character.
  * @returns {boolean} Whether it is whitespace that carries no meaning. A newline does carry
- *   meaning — it ends an attribute — so it is deliberately not here.
+ *   meaning - it ends an attribute - so it is deliberately not here.
  */
 const isSpace = (c) => c === ' ' || c === '\t' || c === '\r';
 
 /**
  * Walks the source once, keeping the cursor and the accumulated tokens together.
  *
- * A class rather than one long function because the four scanners below — comments,
- * strings, numbers, names — all need the same mutable cursor, and threading it through
+ * A class rather than one long function because the four scanners below - comments,
+ * strings, numbers, names - all need the same mutable cursor, and threading it through
  * arguments made each of them harder to read than the grammar it implements.
  */
 class Lexer {

package/src/lang/parser.js

@@ -3,7 +3,7 @@
  *
  * Recursive descent with a precedence table for the infix operators. The grammar is small
  * enough that a generator would cost more than it saved, and writing it by hand is what lets
- * every node carry the source position that produced it — which is the whole of how errors
+ * every node carry the source position that produced it - which is the whole of how errors
  * point at something later on.
  *
  * It checks shape and nothing else. Whether `cylinder` is a real block, and whether its
@@ -321,7 +321,7 @@ class Parser {
   }
 
   /**
-   * @returns {boolean} Whether the current token starts a new line outside any bracket —
+   * @returns {boolean} Whether the current token starts a new line outside any bracket -
    *   the signal that the expression is finished and the next attribute has begun.
    */
   breaksLine() {
@@ -361,7 +361,7 @@ class Parser {
   }
 
   /**
-   * Reads the suffixes — member access, indexing and calls — that bind tightest.
+   * Reads the suffixes - member access, indexing and calls - that bind tightest.
    *
    * @returns {Expression} The expression.
    */

package/src/values/angle.js

@@ -40,7 +40,7 @@ export class Angle {
   static turns(value) { return new Angle(Number(value) * 2 * Math.PI); }
 
   /**
-   * Accepts an Angle or a bare number, which is read as degrees — the unit a person writing
+   * Accepts an Angle or a bare number, which is read as degrees - the unit a person writing
    * a model thinks in.
    *
    * @param {Angle | number} value An angle, or a number of degrees.

package/src/values/transform.js

@@ -3,7 +3,7 @@
  *
  * A value type: every operation returns a new transform and none mutates the receiver, so a
  * transform captured by a scope cannot be changed underneath it by a sibling block. That
- * matters more than it sounds — nesting is how the language composes, and a mutable
+ * matters more than it sounds - nesting is how the language composes, and a mutable
  * transform would make a block's meaning depend on what ran before it.
  */
 
@@ -116,7 +116,7 @@ export class Transform {
   }
 
   /**
-   * Rotates about x, then y, then z — the order OpenSCAD and Cadova both use, so a model
+   * Rotates about x, then y, then z - the order OpenSCAD and Cadova both use, so a model
    * ported from either lands in the same orientation.
    *
    * @param {Vector | ReadonlyArray<number>} angles Degrees about x, y and z.