@hyperfixi/engine 7.5.1 → 7.6.0

package/dist/common.js

@@ -1594,7 +1594,230 @@
     return indirect(p, node);
   }
 
+  // src/parser.ts
+  var ParseError = class extends Error {
+    constructor(message, token, source, expected) {
+      super(message);
+      this.token = token;
+      this.source = source;
+      this.expected = expected;
+    }
+    /** What the author wrote, when a plugin rewrote the script before it was parsed. */
+    written;
+  };
+  var createGrammar = () => ({
+    commands: /* @__PURE__ */ Object.create(null),
+    fallbacks: /* @__PURE__ */ Object.create(null),
+    features: /* @__PURE__ */ Object.create(null),
+    leaves: [],
+    indirects: [],
+    unaries: [],
+    postfixes: [],
+    collections: []
+  });
+  var Parser = class _Parser {
+    constructor(g, tokens, src) {
+      this.g = g;
+      this.tokens = tokens;
+      this.src = src;
+      const end = src.length;
+      this.eof = { type: "EOF", value: "<<<EOF>>>", start: end, end, line: 0, column: 0 };
+      this.last = this.eof;
+      this.skipWs();
+    }
+    i = 0;
+    follows = [];
+    eof;
+    /** The last token consumed by a match. */
+    last;
+    child(tokens, src) {
+      return new _Parser(this.g, tokens, src);
+    }
+    // ----- access ------------------------------------------------------------
+    /** The nth token from here; whitespace is skipped unless `ws`. */
+    tok(n = 0, ws = false) {
+      let j = this.i;
+      for (; ; ) {
+        if (!ws) while (this.tokens[j]?.type === "WHITESPACE") j++;
+        if (n-- === 0) return this.tokens[j] ?? this.eof;
+        j++;
+      }
+    }
+    cur() {
+      return this.tokens[this.i] ?? this.eof;
+    }
+    hasMore() {
+      return this.i < this.tokens.length;
+    }
+    /** Start offset of the current token — what a rule records as its node's `start`. */
+    pos() {
+      return this.cur().start;
+    }
+    /** Where the parser is, for `reset`: a command's fallback reads again from here. */
+    mark() {
+      return { i: this.i, last: this.last, follows: this.follows.length };
+    }
+    reset(mark2) {
+      this.i = mark2.i;
+      this.last = mark2.last;
+      this.follows.length = mark2.follows;
+    }
+    /** End offset of the last consumed token — a node's `end`. */
+    endPos() {
+      return this.last.end;
+    }
+    text(node) {
+      return this.src.substring(node.start, node.end);
+    }
+    // ----- matching ----------------------------------------------------------
+    match(value, type = "IDENTIFIER") {
+      if (this.follows.includes(value)) return;
+      const t = this.cur();
+      if (t.value === value && t.type === type) return this.consume();
+    }
+    matchOp(value) {
+      const t = this.cur();
+      if (t.op && t.value === value) return this.consume();
+    }
+    matchType(...types) {
+      if (types.includes(this.cur().type)) return this.consume();
+    }
+    matchAny(...values) {
+      for (const value of values) {
+        const t = this.match(value);
+        if (t) return t;
+      }
+    }
+    matchAnyOp(...values) {
+      for (const value of values) {
+        const t = this.matchOp(value);
+        if (t) return t;
+      }
+    }
+    req(value) {
+      return this.match(value) ?? this.expected(value);
+    }
+    reqOp(value) {
+      return this.matchOp(value) ?? this.expected(value);
+    }
+    reqType(...types) {
+      return this.matchType(...types) ?? this.expected(...types);
+    }
+    /** Is the nth token from here this identifier (or this `type`)? Consumes nothing. */
+    peek(value, n = 0, type = "IDENTIFIER") {
+      const t = this.tok(n);
+      if (t.value === value && t.type === type) return t;
+    }
+    // ----- consuming ---------------------------------------------------------
+    consume() {
+      if (!this.hasMore()) return this.eof;
+      this.last = this.tokens[this.i++];
+      this.skipWs();
+      return this.last;
+    }
+    skipWs() {
+      while (this.tokens[this.i]?.type === "WHITESPACE") this.i++;
+    }
+    /** Raw tokens (whitespace included) up to a token with this value or type. */
+    consumeUntil(value, type) {
+      const out = [];
+      let t = this.cur();
+      while ((type == null || t.type !== type) && (value == null || t.value !== value) && t.type !== "EOF") {
+        out.push(t);
+        this.i++;
+        t = this.cur();
+      }
+      this.skipWs();
+      return out;
+    }
+    /** The whitespace just before the current token, if any. */
+    lastWs() {
+      const t = this.tokens[this.i - 1];
+      return t?.type === "WHITESPACE" ? t.value : "";
+    }
+    // ----- follow set: words a nested rule must leave for its caller ----------
+    pushFollow(...words) {
+      this.follows.push(...words);
+      return words.length;
+    }
+    popFollow(count = 1) {
+      this.follows.length -= count;
+    }
+    /** Parse with `words` reserved for the caller, e.g. the `to` of `set x to y`. */
+    withFollow(words, f) {
+      const count = this.pushFollow(...words);
+      try {
+        return f();
+      } finally {
+        this.popFollow(count);
+      }
+    }
+    /** Parse with no reserved words — inside parentheses the outer rule's words are free again. */
+    withoutFollows(f) {
+      const saved = this.follows;
+      this.follows = [];
+      try {
+        return f();
+      } finally {
+        this.follows = saved;
+      }
+    }
+    // ----- errors ------------------------------------------------------------
+    err(message, expected) {
+      const token = this.cur();
+      throw new ParseError(message ?? "Unexpected Token : " + token.value, token, this.src, expected);
+    }
+    expected(...expected) {
+      this.err(
+        expected.length === 1 ? `Expected '${expected[0]}' but found '${this.cur().value}'` : "Expected one of: " + expected.map((e) => `'${e}'`).join(", "),
+        expected
+      );
+    }
+    // ----- statement boundaries ------------------------------------------------
+    commandStart(token) {
+      return token.value in this.g.commands;
+    }
+    featureStart(token) {
+      return token.value in this.g.features;
+    }
+    commandBoundary(token) {
+      return ["end", "then", "else", "otherwise", ")"].includes(token.value) || this.commandStart(token) || this.featureStart(token) || token.type === "EOF";
+    }
+  };
+  function formatError(e) {
+    const lines = e.source.split("\n");
+    const index = e.token.line ? e.token.line - 1 : lines.length - 1;
+    const line = lines[index] ?? "";
+    const column = e.token.line ? e.token.column : Math.max(0, line.length - 1);
+    const gutter = String(index + 1).length;
+    const pad = " ".repeat(gutter + 5 + column);
+    return `  ${index + 1} | ${line}
+` + pad + "^".repeat(Math.max(1, e.token.value.length)) + "\n" + pad + e.message + "\n";
+  }
+
   // src/statements.ts
+  function withFallbacks(p, rule, keyword, start) {
+    const fallbacks = p.g.fallbacks[keyword];
+    if (!fallbacks) return rule(p, keyword, start);
+    const mark2 = p.mark();
+    try {
+      return rule(p, keyword, start);
+    } catch (e) {
+      if (!(e instanceof ParseError)) throw e;
+      let error = e;
+      for (const fallback of fallbacks) {
+        p.reset(mark2);
+        try {
+          const cmd = fallback(p, keyword, start);
+          if (cmd && p.pos() >= e.token.start) return cmd;
+        } catch (f) {
+          if (!(f instanceof ParseError)) throw f;
+          if (f.token.start > error.token.start) error = f;
+        }
+      }
+      throw error;
+    }
+  }
   function command(p) {
     const start = p.pos();
     if (p.matchOp("(")) {
@@ -1605,7 +1828,7 @@
     const t = p.cur();
     const rule = p.g.commands[t.value];
     let cmd;
-    if (rule) cmd = p.match(t.value) && rule(p, t.value, start);
+    if (rule) cmd = p.match(t.value) && withFallbacks(p, rule, t.value, start);
     else if (t.type === "IDENTIFIER") cmd = p.g.pseudo?.(p, start);
     if (!cmd || !p.match("unless")) return cmd;
     const inner = cmd;
@@ -1950,13 +2173,7 @@
           node.between = [attribute2, attributeRef(p) ?? p.err("Expected attributeRef")];
         }
       } else if (!(node.classRefs = classRefs(p)) && !(node.attributeRef = attributeRef(p))) {
-        const element = p.g.toggleElement;
-        if (!element) node.target = p.withFollow(["between"], () => assignable(p));
-        else {
-          const target2 = p.withFollow(["between", "as"], () => unary(p));
-          if (!p.peek("between")) return element(p, target2, start);
-          node.target = writable(p, target2);
-        }
+        node.target = p.withFollow(["between"], () => assignable(p));
       }
       if (!node.styleProp && !node.target) node.on = p.match("on") ? expr(p) : implicitMe(p);
       if (p.match("between")) {
@@ -2511,201 +2728,23 @@
     return result;
   }
 
-  // src/parser.ts
-  var ParseError = class extends Error {
-    constructor(message, token, source, expected) {
-      super(message);
-      this.token = token;
-      this.source = source;
-      this.expected = expected;
-    }
-    /** What the author wrote, when a plugin rewrote the script before it was parsed. */
-    written;
-  };
-  var createGrammar = () => ({
-    commands: /* @__PURE__ */ Object.create(null),
-    features: /* @__PURE__ */ Object.create(null),
-    leaves: [],
-    indirects: [],
-    unaries: [],
-    postfixes: [],
-    collections: []
-  });
-  var Parser = class _Parser {
-    constructor(g, tokens, src) {
-      this.g = g;
-      this.tokens = tokens;
-      this.src = src;
-      const end = src.length;
-      this.eof = { type: "EOF", value: "<<<EOF>>>", start: end, end, line: 0, column: 0 };
-      this.last = this.eof;
-      this.skipWs();
-    }
-    i = 0;
-    follows = [];
-    eof;
-    /** The last token consumed by a match. */
-    last;
-    child(tokens, src) {
-      return new _Parser(this.g, tokens, src);
-    }
-    // ----- access ------------------------------------------------------------
-    /** The nth token from here; whitespace is skipped unless `ws`. */
-    tok(n = 0, ws = false) {
-      let j = this.i;
-      for (; ; ) {
-        if (!ws) while (this.tokens[j]?.type === "WHITESPACE") j++;
-        if (n-- === 0) return this.tokens[j] ?? this.eof;
-        j++;
-      }
-    }
-    cur() {
-      return this.tokens[this.i] ?? this.eof;
-    }
-    hasMore() {
-      return this.i < this.tokens.length;
-    }
-    /** Start offset of the current token — what a rule records as its node's `start`. */
-    pos() {
-      return this.cur().start;
-    }
-    /** End offset of the last consumed token — a node's `end`. */
-    endPos() {
-      return this.last.end;
-    }
-    text(node) {
-      return this.src.substring(node.start, node.end);
-    }
-    // ----- matching ----------------------------------------------------------
-    match(value, type = "IDENTIFIER") {
-      if (this.follows.includes(value)) return;
-      const t = this.cur();
-      if (t.value === value && t.type === type) return this.consume();
-    }
-    matchOp(value) {
-      const t = this.cur();
-      if (t.op && t.value === value) return this.consume();
-    }
-    matchType(...types) {
-      if (types.includes(this.cur().type)) return this.consume();
-    }
-    matchAny(...values) {
-      for (const value of values) {
-        const t = this.match(value);
-        if (t) return t;
-      }
-    }
-    matchAnyOp(...values) {
-      for (const value of values) {
-        const t = this.matchOp(value);
-        if (t) return t;
-      }
-    }
-    req(value) {
-      return this.match(value) ?? this.expected(value);
-    }
-    reqOp(value) {
-      return this.matchOp(value) ?? this.expected(value);
-    }
-    reqType(...types) {
-      return this.matchType(...types) ?? this.expected(...types);
-    }
-    /** Is the nth token from here this identifier (or this `type`)? Consumes nothing. */
-    peek(value, n = 0, type = "IDENTIFIER") {
-      const t = this.tok(n);
-      if (t.value === value && t.type === type) return t;
-    }
-    // ----- consuming ---------------------------------------------------------
-    consume() {
-      if (!this.hasMore()) return this.eof;
-      this.last = this.tokens[this.i++];
-      this.skipWs();
-      return this.last;
-    }
-    skipWs() {
-      while (this.tokens[this.i]?.type === "WHITESPACE") this.i++;
-    }
-    /** Raw tokens (whitespace included) up to a token with this value or type. */
-    consumeUntil(value, type) {
-      const out = [];
-      let t = this.cur();
-      while ((type == null || t.type !== type) && (value == null || t.value !== value) && t.type !== "EOF") {
-        out.push(t);
-        this.i++;
-        t = this.cur();
-      }
-      this.skipWs();
-      return out;
-    }
-    /** The whitespace just before the current token, if any. */
-    lastWs() {
-      const t = this.tokens[this.i - 1];
-      return t?.type === "WHITESPACE" ? t.value : "";
-    }
-    // ----- follow set: words a nested rule must leave for its caller ----------
-    pushFollow(...words) {
-      this.follows.push(...words);
-      return words.length;
-    }
-    popFollow(count = 1) {
-      this.follows.length -= count;
-    }
-    /** Parse with `words` reserved for the caller, e.g. the `to` of `set x to y`. */
-    withFollow(words, f) {
-      const count = this.pushFollow(...words);
-      try {
-        return f();
-      } finally {
-        this.popFollow(count);
-      }
-    }
-    /** Parse with no reserved words — inside parentheses the outer rule's words are free again. */
-    withoutFollows(f) {
-      const saved = this.follows;
-      this.follows = [];
-      try {
-        return f();
-      } finally {
-        this.follows = saved;
-      }
-    }
-    // ----- errors ------------------------------------------------------------
-    err(message, expected) {
-      const token = this.cur();
-      throw new ParseError(message ?? "Unexpected Token : " + token.value, token, this.src, expected);
-    }
-    expected(...expected) {
-      this.err(
-        expected.length === 1 ? `Expected '${expected[0]}' but found '${this.cur().value}'` : "Expected one of: " + expected.map((e) => `'${e}'`).join(", "),
-        expected
-      );
-    }
-    // ----- statement boundaries ------------------------------------------------
-    commandStart(token) {
-      return token.value in this.g.commands;
-    }
-    featureStart(token) {
-      return token.value in this.g.features;
-    }
-    commandBoundary(token) {
-      return ["end", "then", "else", "otherwise", ")"].includes(token.value) || this.commandStart(token) || this.featureStart(token) || token.type === "EOF";
-    }
-  };
-  function formatError(e) {
-    const lines = e.source.split("\n");
-    const index = e.token.line ? e.token.line - 1 : lines.length - 1;
-    const line = lines[index] ?? "";
-    const column = e.token.line ? e.token.column : Math.max(0, line.length - 1);
-    const gutter = String(index + 1).length;
-    const pad = " ".repeat(gutter + 5 + column);
-    return `  ${index + 1} | ${line}
-` + pad + "^".repeat(Math.max(1, e.token.value.length)) + "\n" + pad + e.message + "\n";
-  }
-
   // src/engine.ts
   var grammar = createGrammar();
+  var registered = /* @__PURE__ */ new Set();
+  var unread = /* @__PURE__ */ new Set();
   function register(...modules) {
-    for (const module of modules) module(grammar);
+    const added = modules.filter((module) => !registered.has(module));
+    for (const module of added) {
+      registered.add(module);
+      module(grammar);
+    }
+    if (!added.length) return;
+    for (const elt of [...unread]) {
+      unread.delete(elt);
+      if (!elt.isConnected) continue;
+      dropData(elt);
+      initElement(elt);
+    }
   }
   var parser = (src) => new Parser(grammar, tokenize(src), src);
   function parseProgram(src) {
@@ -2778,6 +2817,7 @@
       setTimeout(() => triggerEvent(target, "load", { hyperscript: true }), 1);
     } catch (e) {
       if (e instanceof ParseError) {
+        unread.add(elt);
         if (src !== written) e.written = written;
         triggerEvent(elt, "hyperscript:parse-error", { errors: [e] });
         const from = e.written ? `
@@ -2844,6 +2884,12 @@
     addAfterProcessHook: (hook) => void afterProcess.push(hook),
     /** Not in upstream: rewrite a script as it is read, leaving the attribute as written. */
     addSourceTransform: (transform) => void transforms.push(transform),
+    /** Not in upstream: add grammar modules, from a script tag (`dist/ext/<name>.js`) or a page. */
+    register,
+    // `kit` (what a module may call) is added by the script-tag bundle (`bundles/full.ts`) only,
+    // so a bundle of the user's own keeps only the parts of the engine it uses.
+    /** Not in upstream: the extension files (`dist/ext/<name>.js`) this page has loaded. */
+    extensions: /* @__PURE__ */ new Set(),
     evaluate,
     parse: hostParse,
     process: processNode,
@@ -2852,7 +2898,7 @@
     cleanup,
     /** The part of upstream's `internals` that pages and tests reach for. */
     internals: { runtime: { cleanup, processNode } },
-    version: false ? "dev" : "7.5.1"
+    version: false ? "dev" : "7.6.0"
   });
   function boot() {
     Object.assign(globalThis, { _hyperscript: api });