@rohal12/spindle 0.52.3 → 0.52.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rohal12/spindle",
-  "version": "0.52.3",
+  "version": "0.52.4",
   "type": "module",
   "description": "A Preact-based story format for Twine 2.",
   "license": "Unlicense",

package/src/components/macros/Widget.tsx

@@ -5,12 +5,20 @@ import { defineMacro } from '../../define-macro';
 import { checkVariableName } from '../../utils/namespace';
 import { MacroError } from './MacroError';
 
-function parseWidgetDef(rawArgs: string): { name: string; params: string[] } {
-  const tokens = rawArgs.trim().split(/\s+/);
-  const name = tokens[0]!.replace(/["']/g, '');
-  const params = tokens.slice(1).filter((t) => t.startsWith('@'));
-  for (const param of params) checkVariableName(param.slice(1), param);
-  return { name, params };
+/**
+ * Read the arguments of a {widget} definition: its name (quotes dropped)
+ * and its parameters, the words after it that start with one of the
+ * characters of `sigils`.
+ */
+export function parseWidgetDef(
+  rawArgs: string,
+  sigils = '@',
+): { name: string; params: string[] } {
+  const [first, ...rest] = rawArgs.trim().split(/\s+/);
+  return {
+    name: first!.replace(/["']/g, ''),
+    params: rest.filter((word) => sigils.includes(word[0]!)),
+  };
 }
 
 defineMacro({
@@ -20,7 +28,10 @@ defineMacro({
     let parsed: ReturnType<typeof parseWidgetDef> | undefined;
     let error: unknown;
     try {
-      parsed = parseWidgetDef(rawArgs);
+      // Refuse `@` parameters that no namespace can hold
+      const def = parseWidgetDef(rawArgs);
+      for (const param of def.params) checkVariableName(param.slice(1), param);
+      parsed = def;
     } catch (err) {
       error = err;
     }

package/src/index.tsx

@@ -21,6 +21,7 @@ import { tokenize } from './markup/tokenizer';
 import { buildAST, registerBlockMacro } from './markup/ast';
 import { registerWidget } from './widgets/widget-registry';
 import { astContainsChildren } from './widgets/ast-scanner';
+import { parseWidgetDef } from './components/macros/Widget';
 import { errorMessage } from './utils/error-message';
 import type { ASTNode } from './markup/ast';
 import './macros/register-builtins';
@@ -173,14 +174,10 @@ export function boot() {
       const widgetAST = buildAST(widgetTokens);
       for (const node of widgetAST) {
         if (node.type === 'macro' && node.name === 'widget' && node.rawArgs) {
-          const tokens2 = node.rawArgs.trim().split(/\s+/);
-          const widgetName = tokens2[0]!.replace(/["']/g, '');
-          const params = tokens2
-            .slice(1)
-            .filter(
-              (t) =>
-                t.startsWith('$') || t.startsWith('_') || t.startsWith('@'),
-            );
+          const { name: widgetName, params } = parseWidgetDef(
+            node.rawArgs,
+            '$_@',
+          );
           const children = node.children as ASTNode[];
           const isBlock = astContainsChildren(children);
           try {

package/src/interpolation.ts

@@ -14,7 +14,13 @@
  * string, so it is reported instead of being run or shown as source.
  */
 import { evaluate } from './expression';
-import { tokenize } from './markup/tokenizer';
+import {
+  SCOPE_SIGILS,
+  SIGIL_SCOPES,
+  tokenize,
+  type VariableScope,
+} from './markup/tokenizer';
+import type { Sigil } from './js-lexer';
 import { buildAST } from './markup/ast';
 import type { ASTNode, MacroNode, TextNode } from './markup/ast';
 import { getMacro, getMacroText, isSubMacro } from './registry';
@@ -116,15 +122,6 @@ function display(value: unknown): string {
   return value == null ? '' : String(value);
 }
 
-type VariableKind = 'variable' | 'temporary' | 'local' | 'transient';
-
-const KIND_SIGILS = {
-  variable: '$',
-  temporary: '_',
-  local: '@',
-  transient: '%',
-} as const;
-
 /**
  * The value of a variable reference (`name` without its sigil, with an
  * optional dot path), as `{$name}` shows it in passage text (see
@@ -133,12 +130,12 @@ const KIND_SIGILS = {
  */
 function resolveVariable(
   scope: TextScope,
-  kind: VariableKind,
+  kind: VariableScope,
   name: string,
 ): unknown {
   const parts = name.split('.');
   const root = parts[0]!;
-  checkVariableName(root, KIND_SIGILS[kind] + root);
+  checkVariableName(root, SCOPE_SIGILS[kind] + root);
   const store =
     kind === 'variable'
       ? scope.variables
@@ -210,12 +207,16 @@ class TextEvaluator {
   }
 
   /** A variable reference, or '' and an error if it can't be one. */
-  private variable(kind: VariableKind, name: string, scope: TextScope): string {
+  private variable(
+    kind: VariableScope,
+    name: string,
+    scope: TextScope,
+  ): string {
     try {
       return display(resolveVariable(scope, kind, name));
     } catch (error) {
       // Reported as passage text reports it: `{$__proto__ error: …}`
-      this.errors.push({ macro: KIND_SIGILS[kind] + name, error });
+      this.errors.push({ macro: SCOPE_SIGILS[kind] + name, error });
       return '';
     }
   }
@@ -341,13 +342,6 @@ export function interpolateText(
   return renderText(parsed.nodes, scope);
 }
 
-const SIGIL_KINDS = {
-  $: 'variable',
-  _: 'temporary',
-  '@': 'local',
-  '%': 'transient',
-} as const;
-
 /**
  * Resolve the sigil references in the value of a code attribute (see
  * isCodeAttribute): `{$x}`, `{_x.y}`, `{$n + 1}`. Everything else, other
@@ -367,7 +361,7 @@ export function interpolateCode(
     } else if ('verbatim' in part) {
       text += part.verbatim;
     } else if (/^[$_@%][\w.]+$/.test(part.expr)) {
-      const kind = SIGIL_KINDS[part.expr[0] as keyof typeof SIGIL_KINDS];
+      const kind = SIGIL_SCOPES[part.expr[0] as Sigil];
       try {
         text += display(resolveVariable(scope, kind, part.expr.slice(1)));
       } catch (error) {

package/src/js-lexer.ts

@@ -145,15 +145,14 @@ function scanRegex(
   };
   let i = start + 1;
   while (i < src.length) {
+    // Unterminated at the end of the line: leave the rest to the parser
+    const lineEnd = regexLineEnd(src, i);
+    if (lineEnd !== -1) return done(lineEnd, false);
     const c = src.charAt(i);
     if (c === '\\') {
-      // An escaped line break ends the line, and the regex, too
-      if (LINE_TERMINATOR_RE.test(src.charAt(i + 1))) return done(i + 1, false);
       i += 2;
       continue;
     }
-    // Unterminated at the end of the line: leave the rest to the parser
-    if (LINE_TERMINATOR_RE.test(c)) return done(i, false);
     if (c === '[') {
       // A class, where `/` does not close
       i = scanRegexClass(src, i, cache);
@@ -191,16 +190,17 @@ function scanRegexClass(
   const opens = [open];
   let i = open + 1;
   while (i < src.length) {
+    const lineEnd = regexLineEnd(src, i);
+    if (lineEnd !== -1) {
+      i = lineEnd;
+      break;
+    }
     const c = src.charAt(i);
     if (c === '\\') {
-      if (LINE_TERMINATOR_RE.test(src.charAt(i + 1))) {
-        i++;
-        break;
-      }
       i += 2;
       continue;
     }
-    if (c === ']' || LINE_TERMINATOR_RE.test(c)) break;
+    if (c === ']') break;
     if (c === '[' && cache) opens.push(i);
     i++;
   }
@@ -209,6 +209,17 @@ function scanRegexClass(
   return i;
 }
 
+/**
+ * Index of the line break at `i`, escaped (`\` then a line break) or not,
+ * where a regex literal or class ends unterminated; -1 if there is none.
+ */
+function regexLineEnd(src: string, i: number): number {
+  const c = src.charAt(i);
+  if (LINE_TERMINATOR_RE.test(c)) return i;
+  if (c === '\\' && LINE_TERMINATOR_RE.test(src.charAt(i + 1))) return i + 1;
+  return -1;
+}
+
 /**
  * The next index from `from` on where `find` matches (-1 for none), for
  * searches from increasing positions: a search from within the stretch the

package/src/markup/ast.ts

@@ -1,40 +1,39 @@
-import type { Token } from './tokenizer';
+import {
+  withSelectors,
+  type HtmlToken,
+  type MacroToken,
+  type Selectors,
+  type Token,
+  type VariableScope,
+} from './tokenizer';
 
 export interface TextNode {
   type: 'text';
   value: string;
 }
 
-export interface VariableNode {
+export interface VariableNode extends Selectors {
   type: 'variable';
   name: string;
-  scope: 'variable' | 'temporary' | 'local' | 'transient';
-  className?: string;
-  id?: string;
+  scope: VariableScope;
 }
 
-export interface ExpressionNode {
+export interface ExpressionNode extends Selectors {
   type: 'expression';
   expression: string;
-  className?: string;
-  id?: string;
 }
 
-export interface Branch {
+export interface Branch extends Selectors {
   rawArgs: string;
-  className?: string;
-  id?: string;
   children: ASTNode[];
 }
 
-export interface MacroNode {
+export interface MacroNode extends Selectors {
   type: 'macro';
   name: string;
   rawArgs: string;
   children: ASTNode[];
   branches?: Branch[];
-  className?: string;
-  id?: string;
 }
 
 export interface HtmlNode {
@@ -99,6 +98,24 @@ function quoteArg(value: string): string {
   return `"${value.replace(/[\\"]/g, '\\$&')}"`;
 }
 
+/** A new branch for the macro token opening it, with its selectors. */
+function newBranch(token: MacroToken): Branch {
+  return withSelectors<Branch>({ rawArgs: token.rawArgs, children: [] }, token);
+}
+
+/** A macro or HTML element, or a token opening or closing one. */
+type Tagged = MacroNode | HtmlNode | MacroToken | HtmlToken;
+
+/** The name of a macro or HTML element. */
+function tagName(tagged: Tagged): string {
+  return tagged.type === 'html' ? tagged.tag : tagged.name;
+}
+
+/** The tag closing a macro or HTML element, as written in markup. */
+function closerOf(tagged: Tagged): string {
+  return tagged.type === 'html' ? `</${tagged.tag}>` : `{/${tagged.name}}`;
+}
+
 /**
  * Build an AST from a token array. Block macros are nested into trees
  * using a stack. Throws on unclosed or mismatched macros.
@@ -119,6 +136,32 @@ export function buildAST(tokens: Token[]): ASTNode[] {
     return top.children;
   }
 
+  /**
+   * Pop the node on top of the stack, which the closing `token` (`</b>`,
+   * `{/if}`) must close. Names match ignoring case.
+   */
+  function close(token: MacroToken | HtmlToken) {
+    const found = closerOf(token);
+    if (stack.length === 0) {
+      throw new Error(
+        `Unexpected closing ${found} (at character ${token.start})`,
+      );
+    }
+
+    const top = stack[stack.length - 1]!;
+    if (
+      top.node.type !== token.type ||
+      tagName(top.node).toLowerCase() !== tagName(token).toLowerCase()
+    ) {
+      throw new Error(
+        `Expected ${closerOf(top.node)} but found ${found} (at character ${token.start})`,
+      );
+    }
+
+    stack.pop();
+    current().push(top.node);
+  }
+
   for (const token of tokens) {
     switch (token.type) {
       case 'text':
@@ -127,120 +170,64 @@ export function buildAST(tokens: Token[]): ASTNode[] {
 
       case 'link': {
         const rawArgs = `${quoteArg(token.display)} ${quoteArg(token.target)}`;
-        const macroNode: MacroNode = {
-          type: 'macro',
-          name: 'link',
-          rawArgs,
-          children: [],
-        };
-        if (token.className) macroNode.className = token.className;
-        if (token.id) macroNode.id = token.id;
-        current().push(macroNode);
+        current().push(
+          withSelectors<MacroNode>(
+            { type: 'macro', name: 'link', rawArgs, children: [] },
+            token,
+          ),
+        );
         break;
       }
 
-      case 'variable': {
-        const varNode: VariableNode = {
-          type: 'variable',
-          name: token.name,
-          scope: token.scope,
-        };
-        if (token.className) varNode.className = token.className;
-        if (token.id) varNode.id = token.id;
-        current().push(varNode);
+      case 'variable':
+        current().push(
+          withSelectors<VariableNode>(
+            { type: 'variable', name: token.name, scope: token.scope },
+            token,
+          ),
+        );
         break;
-      }
 
-      case 'expression': {
-        const exprNode: ExpressionNode = {
-          type: 'expression',
-          expression: token.expression,
-        };
-        if (token.className) exprNode.className = token.className;
-        if (token.id) exprNode.id = token.id;
-        current().push(exprNode);
+      case 'expression':
+        current().push(
+          withSelectors<ExpressionNode>(
+            { type: 'expression', expression: token.expression },
+            token,
+          ),
+        );
         break;
-      }
 
       case 'html': {
-        if (token.isSelfClose) {
-          // Self-closing HTML tag (br, hr, img, etc.)
-          current().push({
-            type: 'html',
-            tag: token.tag,
-            attributes: token.attributes,
-            children: [],
-          });
-          break;
-        }
-
-        if (token.isClose) {
-          // Closing HTML tag — pop from stack
-          if (stack.length === 0) {
-            throw new Error(
-              `Unexpected closing </${token.tag}> (at character ${token.start})`,
-            );
-          }
-
-          const top = stack[stack.length - 1]!;
-          if (
-            top.node.type !== 'html' ||
-            top.node.tag.toLowerCase() !== token.tag.toLowerCase()
-          ) {
-            const expected =
-              top.node.type === 'html'
-                ? `</${top.node.tag}>`
-                : `{/${top.node.name}}`;
-            throw new Error(
-              `Expected ${expected} but found </${token.tag}> (at character ${token.start})`,
-            );
-          }
-
-          stack.pop();
-          current().push(top.node);
-          break;
-        }
-
-        // Opening HTML tag — push onto stack
         const htmlNode: HtmlNode = {
           type: 'html',
           tag: token.tag,
           attributes: token.attributes,
           children: [],
         };
-        stack.push({ node: htmlNode, start: token.start });
+        if (token.isSelfClose) {
+          // Self-closing HTML tag (br, hr, img, etc.)
+          current().push(htmlNode);
+        } else if (token.isClose) {
+          // Closing HTML tag — pop from stack
+          close(token);
+        } else {
+          // Opening HTML tag — push onto stack
+          stack.push({ node: htmlNode, start: token.start });
+        }
         break;
       }
 
       case 'macro': {
-        // Normalize macro name to lowercase — registration is lowercase,
-        // but the tokenizer preserves original casing from passage markup.
-        const name = token.name.toLowerCase();
-
         if (token.isClose) {
           // Closing tag — pop from stack
-          if (stack.length === 0) {
-            throw new Error(
-              `Unexpected closing {/${token.name}} (at character ${token.start})`,
-            );
-          }
-
-          const top = stack[stack.length - 1]!;
-          if (top.node.type !== 'macro' || top.node.name !== name) {
-            const expected =
-              top.node.type === 'macro'
-                ? `{/${top.node.name}}`
-                : `</${top.node.tag}>`;
-            throw new Error(
-              `Expected ${expected} but found {/${token.name}} (at character ${token.start})`,
-            );
-          }
-
-          stack.pop();
-          current().push(top.node);
+          close(token);
           break;
         }
 
+        // Normalize macro name to lowercase — registration is lowercase,
+        // but the tokenizer preserves original casing from passage markup.
+        const name = token.name.toLowerCase();
+
         // Handle branch macros (elseif/else, case/default, next)
         const expectedParent = Object.prototype.hasOwnProperty.call(
           BRANCH_PARENT,
@@ -261,55 +248,29 @@ export function buildAST(tokens: Token[]): ASTNode[] {
             );
           }
 
-          const branch: Branch = {
-            rawArgs: token.rawArgs,
-            children: [],
-          };
-          if (token.className) branch.className = token.className;
-          if (token.id) branch.id = token.id;
-          topNode.branches!.push(branch);
+          topNode.branches!.push(newBranch(token));
           break;
         }
 
-        // Block macro — push onto stack
-        if (BLOCK_MACROS.has(name)) {
-          const node: MacroNode = {
-            type: 'macro',
-            name,
-            rawArgs: token.rawArgs,
-            children: [],
-          };
-
-          // Branching blocks: className/id goes on the first branch, not the node
-          if (BRANCHING_BLOCK_MACROS.has(name)) {
-            const firstBranch: Branch = {
-              rawArgs: token.rawArgs,
-              children: [],
-            };
-            if (token.className) firstBranch.className = token.className;
-            if (token.id) firstBranch.id = token.id;
-            node.branches = [firstBranch];
-          } else {
-            if (token.className) node.className = token.className;
-            if (token.id) node.id = token.id;
-          }
+        const node: MacroNode = {
+          type: 'macro',
+          name,
+          rawArgs: token.rawArgs,
+          children: [],
+        };
 
-          stack.push({ node, start: token.start });
+        if (!BLOCK_MACROS.has(name)) {
+          // Self-closing macro (set, print, etc.)
+          current().push(withSelectors(node, token));
           break;
         }
 
-        // Self-closing macro (set, print, etc.)
-        {
-          const macroNode: MacroNode = {
-            type: 'macro',
-            name,
-            rawArgs: token.rawArgs,
-            children: [],
-          };
-          if (token.className) macroNode.className = token.className;
-          if (token.id) macroNode.id = token.id;
-          current().push(macroNode);
-        }
+        // Block macro — push onto stack. Branching blocks: className/id
+        // goes on the first branch, not the node
+        if (BRANCHING_BLOCK_MACROS.has(name))
+          node.branches = [newBranch(token)];
+        else withSelectors(node, token);
+        stack.push({ node, start: token.start });
         break;
       }
 

package/src/markup/code-attributes.ts

@@ -1,4 +1,4 @@
-import { createScanMemo, scanBalancedBrace } from './tokenizer';
+import { createScanMemo, isSigil, scanBalancedBrace } from './tokenizer';
 
 /**
  * Attributes whose value is code with braces of its own, not text: event
@@ -41,11 +41,9 @@ export function splitSigilTemplate(template: string): SigilPart[] {
     }
     text += template.slice(i, brace);
     i = brace + 1;
-    const sigil = template[i];
-    const end =
-      sigil === '$' || sigil === '_' || sigil === '@' || sigil === '%'
-        ? scanBalancedBrace(template, i, memo)
-        : -1;
+    const end = isSigil(template[i])
+      ? scanBalancedBrace(template, i, memo)
+      : -1;
     if (end === -1) {
       text += '{';
       continue;