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

package/dist/docs/pacem-core.json

@@ -24556,7 +24556,7 @@
             {
               "kind": "Method",
               "canonicalReference": "@pacem/pacem-core!Expression.parse:member(1)",
-              "docComment": "/**\n * 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(`).\n *\n * @param expression - Bare expression source text.\n *\n * @param element - Element the expression is bound to; provides the scope special tokens (`:host.`, `#id`, `^item`, ...) resolve against.\n *\n * @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.\n */\n",
+              "docComment": "/**\n * 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}). 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(`).\n *\n * @param expression - Bare expression source text.\n *\n * @param element - Element the expression is bound to; provides the scope special tokens (`:host.`, `#id`, `^item`, ...) resolve against.\n *\n * @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.\n */\n",
               "excerptTokens": [
                 {
                   "kind": "Content",

package/dist/esm/adapter.js

@@ -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
  */

package/dist/esm/binding-parser.js

@@ -0,0 +1,259 @@
+/*!
+ * @pacem/pacem-core v2.0.0-abel (https://js.pacem.it)
+ * Pacem (https://pacem.it)
+ * Licensed under Apache-2.0
+ */
+import { Compile } from '@pacem/pacem-foundation';
+//namespace Pacem {
+/** Name of the argument object binding expressions are compiled against (see {@link Expression}). */
+export const BINDING_CONTEXT_PREFIX = '__context_pacem';
+const HOST_REFERENCE = '__host_pacem';
+/** The foundation vocabulary binding expressions are tokenized with. */
+const BINDING_SYNTAX = 'pacem-binding';
+/** Tokenizations are cached by expression text, up to this many entries. */
+const MAX_CACHED_ANALYSES = 4096;
+const INSIGNIFICANT = new Set(['space', 'newline', 'comment', 'doc-comment']);
+const MEMBER_ACCESS = new Set(['.', '?.']);
+/** Globals whose members are off limits. */
+const UNSAFE_OWNERS = new Set(['window', 'document']);
+function isReference(token) {
+    return token.type.startsWith('binding-');
+}
+function isMemberName(token) {
+    return token?.type === 'identifier' || token?.type === 'keyword';
+}
+/** Whether `raw` (and the significant token after it) call what precedes them: `(` or `?.(`. */
+function isInvocation(raw, next) {
+    if (raw === '(') {
+        return true;
+    }
+    return raw === '?.' && next === '(';
+}
+/**
+ * Pure parser of Pacem binding expressions (the content of `{{ … }}` attributes and `on-*` handlers), built on the
+ * `pacem-binding` vocabulary of foundation's language-agnostic `Compile.Scanner`: Pacem references (`:host.`, `::name`,
+ * `^item`, `^index`, `#id`, `$this`) are recognized wherever the JavaScript grammar allows an expression, and never
+ * inside strings or template literal text.
+ */
+export class BindingParser {
+    static { this._scanner = new Compile.Scanner(); }
+    static { this._cache = 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;
+            }
+            // (`{ new: … }` is an object key, not an instantiation)
+            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();
+    }
+}
+/** One rewrite pass: replaces the Pacem references with `__context_pacem` lookups, collecting args and dependencies. */
+class BindingRewriter {
+    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;
+        }
+        // some referenced element/item/host isn't available (yet)
+        for (let key in this._args) {
+            if (this._args[key] == null) {
+                return { kind: 'pending', dependencies: [] };
+            }
+        }
+        const dependencies = this._dependencies;
+        // a single dependency on a plain property path can be bound two-way
+        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(key, factory) {
+        const args = this._args;
+        if (args[key] == null) {
+            args[key] = factory();
+        }
+        return args[key];
+    }
+    _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': {
+                // `^item` is 0 levels up, `^^item` 1, …
+                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));
+                // the dependency is the `item`/`index` property itself, the path goes on with the item members
+                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`/`this`
+                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 });
+    }
+}

package/dist/esm/command.js

@@ -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
  */

package/dist/esm/comparers.js

@@ -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
  */

package/dist/esm/converters.js

@@ -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
  */

package/dist/esm/decorators-next.js

@@ -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
  */

package/dist/esm/decorators.js

@@ -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
  */

package/dist/esm/defaults.js

@@ -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
  */

package/dist/esm/events.js

@@ -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
  */

package/dist/esm/eventtarget.js

@@ -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
  */

package/dist/esm/expression.js

@@ -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
  */
@@ -9,42 +9,8 @@
 import { DeferPromise } from './promise';
 import { Utils } from './utils';
 import { CustomElementUtils, Repeater } from './utils-customelement';
-const CONTEXT_PREFIX = '__context_pacem';
-/** the following pattern matches:
- * -------------------------------
- * ciao "a tutti \"quanti\" voi"                                    -> "a tutti \"quanti\" voi"
- * ciao 'a tutti "quanti" voi'+ mysel.value + 'e a nessun\' altra'  -> 'a tutti "quanti" voi'
- *                                                                     'e a nessun\' altra'
- */
-const stringPattern = /'(\\'|[^'])*[^\\]?'|"(\\"|[^"])*[^\\]?"/g;
-/** the following pattern matches:
- * -------------------------------
- * var l = new Date();  ->  new
- * window.eval(         -> window.
- * eval(                -> eval(
- * eval  (              -> eval  (
- */
-const safetyPattern = /[^\w]new\s|[^\w]window\s*[\.\[]|[^\w]document\s*\.|[^\w]eval\s*\(/;
-/** the following pattern matches:
- * -------------------------------
- * ^^^item.ciao           -> ^^^item
- * !ciao.value            -> !ciao.
- * :host.value            -> :host.
- * ::child.prop           -> ::child.
- * _connectTo(me.value)   -> (me.
- * 009.ciao               ->
- * this[that.value]       -> [that.
- */
-const variablePattern = /(^|[\s\(\[\+\-\*\/!])(:host\.|\^+item[\s\.,;\)\]]|\^+item$|\^+index[^\w\.]|\^+index$|\$?this[\.\s$]?|#[a-zA-Z_][\w]*|::[a-zA-Z_][\w]*)/g;
-///** the following pattern tests:
-// * -------------------------------
-// * __context.$this.myself.value -> true
-// * !__context.myelem.value      -> false
-// * fn(myelem.value)             -> false
-// * $this == that                -> false
-// * ...
-// */
-//const purePropertyPathPattern = /^[\w\.\$]+/; 
+import { BINDING_CONTEXT_PREFIX, BindingParser } from './binding-parser';
+const CONTEXT_PREFIX = BINDING_CONTEXT_PREFIX;
 /**
  * A parsed, compiled binding expression (the content of a `{{ ... }}` attribute value). Parsing
  * (see {@link parse}) rewrites special tokens found in the source text - `:host.`, `^item`/`^^item`/...,
@@ -134,136 +100,45 @@ export 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;
-        //1. remove strings
-        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: length });
-            index = stringMatches.index + length;
-        }
-        if (index < expression.length)
-            trunks.push(expression.substr(index, expression.length - index));
-        //2. loop non string trunks
-        // trunks.length >= strings.length (more precisely, the following statemente is always `true`:
-        // trunks.length === strings.length || trunks.length === strings.length+1;
-        for (var j = 0; j < trunks.length; j++) {
-            let trunk = trunks[j];
-            if (safetyPattern.test(trunk))
-                throw `Unsafe expression detected: "${trunk}".`;
-            if (context == null) {
-                // context is null, means viewActivated event still to be fired.
-                // check whether this is a constant expression (then no need to instantiate actual binding listeners)
-                // or not.
-                if (new RegExp(variablePattern).test(trunk) === true) {
-                    independent = false;
-                    break;
-                }
-            }
-            else {
-                let processedTrunk = trunk.replace(variablePattern, (mwhole, mstart, melem, index, input) => {
-                    independent = false;
-                    const cmpRef = `__host_pacem`;
-                    // default initialization := assumes `this`
-                    let retval = CONTEXT_PREFIX + '.$this' + (melem.endsWith('.') ? '.' : ''), el = element, dotIndex = input.indexOf('.', index), furtherParts = dotIndex > index ? 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); // 5 = 'item'.length + 1 (zero-based)
-                        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); // 6 = 'index'.length + 1 (zero-based)
-                        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}`;
-                    }
-                    // merge dependencies
-                    if (prop && el && prop in el
-                        // && it is not a direct method call (which means that the 'prop' isn't in fact a 'func')
-                        && typeof el[prop] !== 'function' //!isMethodCall 
-                        // && does not already exist as a dependency
-                        && dependencies.find(d => d.element === el && d.property == prop) == null) {
-                        dependencies.push({ element: el, property: prop, path: path, twowayAllowed: false });
-                    }
-                    // return value
-                    return mstart + retval;
-                });
-                expr += processedTrunk;
-                if (j < strings.length) {
-                    const s = strings[j];
-                    expr += expression.substr(s.start, s.length);
-                }
-            }
-        }
-        if (independent) {
-            // constant expression
-            var constexpr = new Expression();
-            constexpr._independent = true;
-            constexpr._fnBody = `return ${expression};`;
-            constexpr._voidBody = expression;
-            constexpr._dependencies = [];
-            return constexpr;
-        }
-        if (context == null) {
-            return this._getPendingExpressionSingleton();
-        }
-        // if some dependency elements aren't available yet, then postpone...
-        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
-            // := && trimmed expression contains only letters, figures, underscores, dots, and '$'...
-            && /[^\w\.\$]+/.test(expr.trim()) !== true) {
-            // ...then 'twoway' binding might be applied/accepted
-            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;
     }
 }
 // }

package/dist/esm/index-animations.js

@@ -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
  */

package/dist/esm/index-behaviors.js

@@ -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
  */

package/dist/esm/index-components.js

@@ -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
  */

package/dist/esm/index-iife.js

@@ -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
  */

package/dist/esm/index-logging.js

@@ -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
  */

package/dist/esm/index-net.js

@@ -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
  */

package/dist/esm/index-root.js

@@ -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
  */

package/dist/esm/index-ui.js

@@ -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
  */

package/dist/esm/index.js

@@ -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
  */

package/dist/esm/logger.js

@@ -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
  */