@pacem/pacem-core 1.0.6-ricci → 2.0.0-abel

package/dist/bundle/pacem-core.mjs

@@ -1,5 +1,5 @@
 /*!
- * @pacem/pacem-core v1.0.6-ricci (https://js.pacem.it)
+ * @pacem/pacem-core v2.0.0-abel (https://js.pacem.it)
  * Pacem (https://pacem.it)
  * Licensed under Apache-2.0
  */
@@ -1355,11 +1355,249 @@ var root;
 var P = (root = window["Pacem"])?.Configuration?.prefix ?? "pacem";
 var PCSS = root?.Configuration?.css ?? P;
 
+// packages/core/dist/esm/binding-parser.js
+import { Compile } from "@pacem/pacem-foundation";
+var BINDING_CONTEXT_PREFIX = "__context_pacem";
+var HOST_REFERENCE = "__host_pacem";
+var BINDING_SYNTAX = "pacem-binding";
+var MAX_CACHED_ANALYSES = 4096;
+var INSIGNIFICANT = /* @__PURE__ */ new Set(["space", "newline", "comment", "doc-comment"]);
+var MEMBER_ACCESS = /* @__PURE__ */ new Set([".", "?."]);
+var UNSAFE_OWNERS = /* @__PURE__ */ new Set(["window", "document"]);
+function isReference(token) {
+  return token.type.startsWith("binding-");
+}
+function isMemberName(token) {
+  return token?.type === "identifier" || token?.type === "keyword";
+}
+function isInvocation(raw, next) {
+  if (raw === "(") {
+    return true;
+  }
+  return raw === "?." && next === "(";
+}
+var BindingParser = class _BindingParser {
+  static {
+    this._scanner = new Compile.Scanner();
+  }
+  static {
+    this._cache = /* @__PURE__ */ new Map();
+  }
+  /** Tokenizes `expression` (cached) and detects its references and unsafe constructs. */
+  static analyze(expression) {
+    const text = expression ?? "";
+    const cache = _BindingParser._cache;
+    const cached = cache.get(text);
+    if (cached != null) {
+      return cached;
+    }
+    if (cache.size >= MAX_CACHED_ANALYSES) {
+      cache.clear();
+    }
+    const tokens = _BindingParser._scanner.tokenize(text, BINDING_SYNTAX);
+    const significant = [];
+    tokens.forEach((t, i) => {
+      if (!INSIGNIFICANT.has(t.type)) {
+        significant.push(i);
+      }
+    });
+    const hasReferences = tokens.some(isReference);
+    const unsafe = _BindingParser._findUnsafe(tokens, significant);
+    const analysis = { tokens, significant, hasReferences, unsafe };
+    cache.set(text, analysis);
+    return analysis;
+  }
+  /**
+   * Finds the first unsafe construct: `new`, members of `window`/`document`, `eval(…)`. Member names (`x.window`),
+   * object keys (`{ new: 1 }`) and string contents never count.
+   */
+  static _findUnsafe(tokens, significant) {
+    for (let k = 0; k < significant.length; k++) {
+      const token = tokens[significant[k]];
+      const previous = tokens[significant[k - 1]];
+      const next = tokens[significant[k + 1]];
+      if (MEMBER_ACCESS.has(previous?.raw)) {
+        continue;
+      }
+      const instantiation = token.type === "keyword" && token.raw === "new" && next?.raw !== ":";
+      if (instantiation) {
+        return "new";
+      }
+      if (token.type !== "identifier") {
+        continue;
+      }
+      const accessed = next?.raw === "[" || MEMBER_ACCESS.has(next?.raw);
+      if (UNSAFE_OWNERS.has(token.raw) && accessed) {
+        return token.raw + next.raw;
+      }
+      if (token.raw === "eval" && next?.raw === "(") {
+        return "eval(";
+      }
+    }
+    return null;
+  }
+  /**
+   * Parses a binding expression against a scope.
+   * @param expression The bare expression text (no `{{ }}` delimiters, no `, twoway`/`, once` modifier).
+   * @param scope What the references resolve to.
+   * @throws When the expression is unsafe (see {@link analyze}).
+   */
+  static parse(expression, scope) {
+    const analysis = _BindingParser.analyze(expression);
+    if (analysis.unsafe != null) {
+      throw `Unsafe expression detected: "${analysis.unsafe}" in "${expression}".`;
+    }
+    if (!analysis.hasReferences) {
+      return { kind: "constant", functionBody: `return ${expression};`, voidBody: expression, dependencies: [] };
+    }
+    if (!scope.ready) {
+      return { kind: "pending", dependencies: [] };
+    }
+    const rewriter = new BindingRewriter(analysis, scope);
+    return rewriter.run();
+  }
+};
+var BindingRewriter = class {
+  constructor(_analysis, _scope) {
+    this._analysis = _analysis;
+    this._scope = _scope;
+    this._dependencies = [];
+    this._args = { "$this": _scope.self };
+  }
+  run() {
+    const tokens = this._analysis.tokens;
+    let expression = "";
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      expression += isReference(token) ? this._rewrite(token, i) : token.raw;
+    }
+    for (let key2 in this._args) {
+      if (this._args[key2] == null) {
+        return { kind: "pending", dependencies: [] };
+      }
+    }
+    const dependencies = this._dependencies;
+    const trimmed = expression.trim();
+    if (dependencies.length === 1 && !/[^\w\.\$]+/.test(trimmed)) {
+      dependencies[0].twowayAllowed = true;
+    }
+    return {
+      kind: "resolved",
+      functionBody: `try{ var ___$$$r = ${expression}; return ___$$$r; }catch(e){  }`,
+      voidBody: `try{ ${expression} }catch(e){  }`,
+      dependencies,
+      args: this._args
+    };
+  }
+  /**
+   * The member values read directly after the token at `index` (`.a.b`, `?.a`), e.g. `['a', 'b']`.
+   * As in javascript, `?.` is a member access like `.`; a member that gets invoked (`.map(`, `?.map(`, `.fn?.(`)
+   * is a method, not a value, so the chain stops before it. Spaces and comments in between are skipped, as in javascript.
+   */
+  _memberChain(index) {
+    const tokens = this._analysis.tokens;
+    const names = [];
+    let k = this._significantAfter(index);
+    while (MEMBER_ACCESS.has(this._significantRaw(k)) && isMemberName(tokens[this._significant(k + 1)])) {
+      const following = this._significantRaw(k + 2);
+      const afterFollowing = this._significantRaw(k + 3);
+      if (isInvocation(following, afterFollowing)) {
+        return names;
+      }
+      const name = tokens[this._significant(k + 1)].raw;
+      names.push(name);
+      k += 2;
+    }
+    return names;
+  }
+  /** The position, in the significant tokens, of the first one after the token at `index`. */
+  _significantAfter(index) {
+    const significant = this._analysis.significant;
+    let k = 0;
+    while (k < significant.length && significant[k] <= index) {
+      k++;
+    }
+    return k;
+  }
+  /** The token index of the `k`-th significant token, if any. */
+  _significant(k) {
+    return this._analysis.significant[k] ?? -1;
+  }
+  _significantRaw(k) {
+    const index = this._significant(k);
+    return this._analysis.tokens[index]?.raw;
+  }
+  _ensureArg(key2, factory) {
+    const args = this._args;
+    if (args[key2] == null) {
+      args[key2] = factory();
+    }
+    return args[key2];
+  }
+  _host() {
+    return this._ensureArg(HOST_REFERENCE, () => this._scope.host());
+  }
+  _rewrite(token, index) {
+    const chain = this._memberChain(index);
+    switch (token.type) {
+      case "binding-host": {
+        const host = this._host();
+        this._addDependency(host, chain);
+        return `${BINDING_CONTEXT_PREFIX}.${HOST_REFERENCE}`;
+      }
+      case "binding-host-property": {
+        const name = token.raw.slice(2);
+        const host = this._host();
+        const element = host == null ? null : host[name];
+        this._addDependency(element, chain);
+        return `${BINDING_CONTEXT_PREFIX}.${HOST_REFERENCE}.${name}`;
+      }
+      case "binding-item":
+      case "binding-index": {
+        const upLevels = token.raw.lastIndexOf("^");
+        const member = token.type === "binding-item" ? "item" : "index";
+        const reference = `__item_${upLevels}_up_pacem`;
+        const placeholder = this._ensureArg(reference, () => this._scope.item(upLevels));
+        const memberChain = member === "item" ? [member].concat(chain) : [member];
+        this._addDependency(placeholder, memberChain);
+        return `${BINDING_CONTEXT_PREFIX}.${reference}.${member}`;
+      }
+      case "binding-element": {
+        const id = token.raw.slice(1);
+        const element = this._ensureArg(id, () => this._scope.element(id));
+        this._addDependency(element, chain);
+        return `${BINDING_CONTEXT_PREFIX}.${id}`;
+      }
+      default: {
+        this._addDependency(this._scope.self, chain);
+        return `${BINDING_CONTEXT_PREFIX}.$this`;
+      }
+    }
+  }
+  /**
+   * Registers a dependency on the first member of `chain` of `element`, unless it's a method, it doesn't exist,
+   * or it's already registered.
+   */
+  _addDependency(element, chain) {
+    const property = chain[0];
+    if (property == null || element == null || typeof element !== "object" && typeof element !== "function") {
+      return;
+    }
+    if (!(property in element) || typeof element[property] === "function") {
+      return;
+    }
+    const dependencies = this._dependencies;
+    const duplicate = dependencies.some((d) => d.element === element && d.property === property);
+    if (duplicate) {
+      return;
+    }
+    const path = chain.join(".");
+    dependencies.push({ element, property, path, twowayAllowed: false });
+  }
+};
+
 // packages/core/dist/esm/expression.js
-var CONTEXT_PREFIX = "__context_pacem";
-var stringPattern = /'(\\'|[^'])*[^\\]?'|"(\\"|[^"])*[^\\]?"/g;
-var safetyPattern = /[^\w]new\s|[^\w]window\s*[\.\[]|[^\w]document\s*\.|[^\w]eval\s*\(/;
-var variablePattern = /(^|[\s\(\[\+\-\*\/!])(:host\.|\^+item[\s\.,;\)\]]|\^+item$|\^+index[^\w\.]|\^+index$|\$?this[\.\s$]?|#[a-zA-Z_][\w]*|::[a-zA-Z_][\w]*)/g;
+var CONTEXT_PREFIX = BINDING_CONTEXT_PREFIX;
 var Expression = class _Expression {
   constructor() {
     this._pending = false;
@@ -1441,111 +1679,45 @@ var Expression = class _Expression {
    * Parses a binding expression's source text (the bare content of a `{{ ... }}` attribute, without the
    * delimiters - see {@link CustomElementUtils.extractBindingAttributeExpression}) into an {@link Expression},
    * resolving its special tokens against `element`'s scope (see {@link CustomElementUtils.findScopeContext}).
-   * Throws if the expression matches the unsafe-code guard (`new`, `window.`, `document.`, `eval(`).
+   * Tokenization and rewriting are delegated to {@link BindingParser} (cached per expression text).
+   * Throws if the expression uses an unsafe construct (`new`, members of `window`/`document`, `eval(`).
    * @param expression Bare expression source text.
    * @param element Element the expression is bound to; provides the scope special tokens (`:host.`, `#id`, `^item`, ...) resolve against.
-   * @returns A constant expression if it has no dependencies; a shared pending placeholder if `element` isn't attached to a scope yet; otherwise a fully resolved expression.
+   * @returns A constant expression if it has no special tokens; a shared pending placeholder if `element` isn't attached to a scope yet; otherwise a fully resolved expression.
    */
   static parse(expression, element) {
-    var context = CustomElementUtils.findScopeContext(element);
-    var args = { "$this": element };
-    var dependencies = [];
-    var expr = "";
-    var independent = true;
-    var strings = [], stringMatches, index = 0, trunks = [];
-    while ((stringMatches = stringPattern.exec(expression)) != null) {
-      trunks.push(expression.substr(index, stringMatches.index - index));
-      let length = stringMatches[0].length;
-      strings.push({ start: stringMatches.index, length });
-      index = stringMatches.index + length;
-    }
-    if (index < expression.length)
-      trunks.push(expression.substr(index, expression.length - index));
-    for (var j = 0; j < trunks.length; j++) {
-      let trunk = trunks[j];
-      if (safetyPattern.test(trunk))
-        throw `Unsafe expression detected: "${trunk}".`;
-      if (context == null) {
-        if (new RegExp(variablePattern).test(trunk) === true) {
-          independent = false;
-          break;
-        }
-      } else {
-        let processedTrunk = trunk.replace(variablePattern, (mwhole, mstart, melem, index2, input) => {
-          independent = false;
-          const cmpRef = `__host_pacem`;
-          let retval = CONTEXT_PREFIX + ".$this" + (melem.endsWith(".") ? "." : ""), el = element, dotIndex = input.indexOf(".", index2), furtherParts = dotIndex > index2 ? input.substr(dotIndex + 1).trim() : "", pathRegexArray = /^[\w\.\$]+/.exec(furtherParts), path = pathRegexArray && pathRegexArray.length > 0 && pathRegexArray[0], propArray, prop = path && (propArray = path.split(".")).length > 0 && propArray[0];
-          if (melem === ":host.") {
-            el = args[cmpRef] = args[cmpRef] || CustomElementUtils.findHostContext(element);
-            retval = `${CONTEXT_PREFIX}.${cmpRef}.`;
-          } else if (melem.endsWith("^item") || melem.substr(0, melem.length - 1).endsWith("^item")) {
-            let lastChar = melem.endsWith("^item") ? "" : melem.substr(melem.length - 1, 1);
-            let upLevels = melem.length - (lastChar.length > 0 ? 6 : 5);
-            let itemRef = `__item_${upLevels}_up_pacem`;
-            let item = Repeater.findItemContext(element, upLevels);
-            el = args[itemRef] = args[itemRef] || item && item.placeholder;
-            path = "item" + (path ? "." + path : "");
-            prop = "item";
-            retval = `${CONTEXT_PREFIX}.${itemRef}.item${lastChar}`;
-          } else if (melem.endsWith("^index") || melem.substr(0, melem.length - 1).endsWith("^index")) {
-            let lastChar = melem.endsWith("^index") ? "" : melem.substr(melem.length - 1, 1);
-            let upLevels = melem.length - (lastChar.length > 0 ? 7 : 6);
-            let itemRef = `__item_${upLevels}_up_pacem`;
-            let item = Repeater.findItemContext(element, upLevels);
-            el = args[itemRef] = args[itemRef] || item && item.placeholder;
-            path = "index";
-            prop = "index";
-            retval = `${CONTEXT_PREFIX}.${itemRef}.index${lastChar}`;
-          } else if (melem.startsWith("::")) {
-            let melem0 = melem.substr(2, melem.length - 2);
-            let host = args[cmpRef] = args[cmpRef] || CustomElementUtils.findHostContext(element);
-            if (!Utils.isNull(host)) {
-              el = host[melem0];
-            } else {
-              el = null;
-            }
-            retval = `${CONTEXT_PREFIX}.${cmpRef}.${melem0}`;
-          } else if (melem.startsWith("#")) {
-            let melem0 = melem.substr(1, melem.length - 1);
-            el = args[melem0] = args[melem0] || context.querySelector("#" + melem0);
-            retval = `${CONTEXT_PREFIX}.${melem0}`;
-          }
-          if (prop && el && prop in el && typeof el[prop] !== "function" && dependencies.find((d) => d.element === el && d.property == prop) == null) {
-            dependencies.push({ element: el, property: prop, path, twowayAllowed: false });
-          }
-          return mstart + retval;
-        });
-        expr += processedTrunk;
-        if (j < strings.length) {
-          const s = strings[j];
-          expr += expression.substr(s.start, s.length);
-        }
-      }
-    }
-    if (independent) {
-      var constexpr = new _Expression();
-      constexpr._independent = true;
-      constexpr._fnBody = `return ${expression};`;
-      constexpr._voidBody = expression;
-      constexpr._dependencies = [];
-      return constexpr;
-    }
-    if (context == null) {
-      return this._getPendingExpressionSingleton();
-    }
-    for (var elem in args) {
-      if (args[elem] == null)
-        return _Expression._getPendingExpressionSingleton();
+    const scope = _Expression._scopeOf(element);
+    const parsed = BindingParser.parse(expression, scope);
+    return _Expression._fromParsed(parsed);
+  }
+  /** The DOM surroundings of `element` the special tokens resolve against (lazily, except for the scope context). */
+  static _scopeOf(element) {
+    const context = CustomElementUtils.findScopeContext(element);
+    return {
+      ready: context != null,
+      self: element,
+      host: () => CustomElementUtils.findHostContext(element),
+      item: (upLevels) => {
+        const item = Repeater.findItemContext(element, upLevels);
+        return item?.placeholder;
+      },
+      element: (id) => context.querySelector("#" + id)
+    };
+  }
+  static _fromParsed(parsed) {
+    if (parsed.kind === "pending") {
+      return _Expression._getPendingExpressionSingleton();
     }
-    if (dependencies.length == 1 && /[^\w\.\$]+/.test(expr.trim()) !== true) {
-      dependencies[0].twowayAllowed = true;
+    const retval = new _Expression();
+    retval._fnBody = parsed.functionBody;
+    retval._voidBody = parsed.voidBody;
+    retval._dependencies = parsed.dependencies;
+    if (parsed.kind === "constant") {
+      retval._independent = true;
+      return retval;
     }
-    var retexpr = new _Expression();
-    retexpr._args = args;
-    retexpr._fnBody = `try{ var ___$$$r = ${expr}; return ___$$$r; }catch(e){  }`;
-    retexpr._voidBody = `try{ ${expr} }catch(e){  }`;
-    retexpr._dependencies = dependencies;
-    return retexpr;
+    retval._args = parsed.args;
+    return retval;
   }
 };