@repobit/dex-store-elements 1.7.3 → 2.0.1

package/dist/src/eta/source-registry.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Sidecar registry that preserves original template sources across renders.
+ *
+ * The Eta template subsystem overwrites DOM values during render:
+ *
+ *   <span>{{=it.name}}</span>
+ *   becomes
+ *   <span>iPhone</span>
+ *
+ * Once a render has happened, the original `{{=it.name}}` source is gone
+ * from the DOM. If the index is later cleared and re-initialized — or if a
+ * mutation observer forwards an external edit — the factory can only see
+ * the rendered string, not the template source.
+ *
+ * The registry stores the original sources keyed by node identity. The
+ * factory consults the registry first and only falls back to the DOM
+ * value when the registry has no entry.
+ *
+ * The registry is intentionally generic: it does not know about Eta, scope,
+ * products, options, or pricing. It is a small, GC-friendly cache.
+ *
+ * Lifetime:
+ *
+ * - Uses `WeakMap` / `Map` keyed by DOM nodes so disconnected nodes can be
+ *   reclaimed by the GC.
+ * - `clear()` resets the registry to empty.
+ *
+ * **Cross-scope limitation.** A source registry is owned by the
+ * index that created it (one registry per `EtaTemplateIndex`
+ * instance by default). Moving a rendered template node from one
+ * scope to another loses the original template source — the
+ * destination index's registry has no record of it, so the
+ * factory falls back to the live DOM value, which now holds the
+ * rendered string rather than the template literal. The
+ * destination index cannot recreate the operation without
+ * discovering the new template content externally.
+ *
+ * If an application reparents rendered template nodes across
+ * scopes, the safe options are:
+ *
+ * 1. Share a single `EtaTemplateSourceRegistry` across the
+ *    affected indices and have each index pass that shared
+ *    registry through the `TemplateOperationContext` on every
+ *    factory call — the factory itself is stateless at the call
+ *    site, so a single registry can back multiple indices.
+ * 2. Accept that moved nodes must be re-discovered by the
+ *    destination index — for example, by re-emitting the original
+ *    template literal into the moved node, or by relying on the
+ *    index's normal `MutationObserver` flow to pick up the new
+ *    template content.
+ *
+ * Today the controller does not expose a `sourceRegistry`
+ * cross-index option; sharing requires reaching into the index
+ * constructor. The v4 review recommends keeping this limitation
+ * documented unless an application actually needs cross-scope
+ * DOM moves — at which point the index/controller can grow a
+ * `sourceRegistry` option that overrides the per-index
+ * `createEtaTemplateSourceRegistry()` default.
+ */
+/**
+ * Default predicate used by `EtaTemplateSourceRegistry` to recognise
+ * template text.
+ *
+ * Requires BOTH an opening `{{` AND a closing `}}` so the registry
+ * can safely inspect arbitrary DOM values without false positives on
+ * stray `{{` markers in plain string literals.
+ *
+/**
+ * Default predicate used to decide whether a string contains an
+ * Eta template token.
+ *
+ * Requires BOTH an opening `{{` AND a closing `}}` so the
+ * predicate does not pay the cost of compiling partial template
+ * fragments (e.g. `Hello {{ user` with a typo) or arbitrary
+ * DOM values that happen to contain `{{` inside a plain string
+ * literal. The empty-string guard short-circuits the
+ * `indexOf` calls on falsy input.
+ *
+ * **Single source of truth.** The factory (`factory.ts`) re-exports
+ * this predicate as `defaultIsTemplateText` for backward
+ * compatibility; the two names point at the same function so the
+ * registry and the factory can never drift apart.
+ */
+export declare function defaultContainsEtaTemplate(text: string): boolean;
+/**
+ * Predicate used to decide whether a string contains a template token.
+ *
+ * The default (`defaultContainsEtaTemplate`) requires BOTH an opening
+ * `{{` AND a closing `}}` so the registry can safely inspect arbitrary
+ * DOM values. Callers can plug in a stricter predicate when they want
+ * to be even more conservative.
+ */
+export type EtaTemplatePredicate = (text: string) => boolean;
+/**
+ * Options accepted by `EtaTemplateSourceRegistry`.
+ */
+export interface EtaTemplateSourceRegistryOptions {
+    /**
+     * Predicate used to recognise template text. Defaults to
+     * `defaultContainsEtaTemplate`, which requires both `{{` AND `}}`.
+     */
+    readonly isTemplateText?: EtaTemplatePredicate;
+}
+/**
+ * Sidecar storage for original template sources.
+ *
+ * Reads are tolerant: if no source is preserved for a node, the registry
+ * consults the DOM value, and if that contains a template it persists the
+ * value so the next read returns the preserved source rather than the
+ * (possibly already-rendered) DOM value.
+ *
+ * **Destructive operations out of scope.** The registry only preserves
+ * sources; it does not enumerate attribute names that have been removed
+ * from the DOM. Removing an attribute at runtime (e.g. via
+ * `element.removeAttribute`) is a destructive operation: the registry
+ * has no way to discover a removed attribute name from a live element
+ * alone. Once `removeWhenEmpty` was dropped from the renderer, the
+ * registry only ever needs to handle attributes that are still present
+ * in the DOM, so this limitation is no longer a concern in practice.
+ */
+export declare class EtaTemplateSourceRegistry {
+    private textSources;
+    private attrSources;
+    private readonly isTemplateText;
+    constructor(options?: EtaTemplateSourceRegistryOptions);
+    /**
+     * Returns the preserved source for a text node, falling back to the
+     * current DOM value.
+     *
+     * If the DOM value contains a template and no preserved source exists,
+     * the value is persisted so future reads stay stable even after the
+     * DOM value changes.
+     */
+    readTextSource(node: Text): string | undefined;
+    /**
+     * Sets or clears the preserved source for a text node.
+     *
+     * Pass `undefined` to remove any preserved source; the next call to
+     * `readTextSource` will then fall back to the current DOM value.
+     */
+    replaceTextSource(node: Text, source: string | undefined): void;
+    /**
+     * Returns the preserved source for a single attribute on an element.
+     *
+     * If no preserved source exists, the registry consults the current
+     * DOM value; when the value contains a template, the registry persists
+     * it so future reads stay stable.
+     */
+    readAttributeSource(element: Element, name: string): string | undefined;
+    /**
+     * Stores a preserved source for an attribute. Used both internally
+     * (after reading a fresh DOM value) and externally (after parsing a
+     * template literal that the DOM no longer exposes).
+     */
+    setAttributeSource(element: Element, name: string, source: string): void;
+    /**
+     * Removes a preserved attribute source. No-op if no source exists.
+     */
+    removeAttributeSource(element: Element, name: string): void;
+    /**
+     * Reads the current DOM value for a text node and updates the
+     * registry accordingly.
+     *
+     * Persists the value when it contains a template; clears any
+     * previously preserved source otherwise. This is the right call for
+     * external mutations where the DOM has been edited and the registry
+     * should reflect the new state.
+     */
+    syncTextSource(node: Text): void;
+    /**
+     * Reads the current DOM value for an attribute and updates the
+     * registry accordingly.
+     *
+     * Persists the value when it contains a template; clears any
+     * previously preserved source otherwise. The right call for external
+     * attribute mutations.
+     */
+    syncAttributeSource(element: Element, name: string): void;
+    /**
+     * Wipes every preserved source.
+     *
+     * Mostly useful for tests. Production code should let the GC reclaim
+     * entries as nodes become unreachable.
+     */
+    clear(): void;
+    /**
+     * Returns `true` when `text` looks like an Eta template.
+     *
+     * Delegates to the configured predicate; the default
+     * (`defaultContainsEtaTemplate`) requires both an opening `{{` AND a
+     * closing `}}`.
+     */
+    private containsTemplate;
+}
+/**
+ * Convenience constructor used by the index and the default factory.
+ */
+export declare function createEtaTemplateSourceRegistry(options?: EtaTemplateSourceRegistryOptions): EtaTemplateSourceRegistry;

package/dist/src/eta/source-registry.js

@@ -0,0 +1,267 @@
+// src/eta/source-registry.ts
+/**
+ * Sidecar registry that preserves original template sources across renders.
+ *
+ * The Eta template subsystem overwrites DOM values during render:
+ *
+ *   <span>{{=it.name}}</span>
+ *   becomes
+ *   <span>iPhone</span>
+ *
+ * Once a render has happened, the original `{{=it.name}}` source is gone
+ * from the DOM. If the index is later cleared and re-initialized — or if a
+ * mutation observer forwards an external edit — the factory can only see
+ * the rendered string, not the template source.
+ *
+ * The registry stores the original sources keyed by node identity. The
+ * factory consults the registry first and only falls back to the DOM
+ * value when the registry has no entry.
+ *
+ * The registry is intentionally generic: it does not know about Eta, scope,
+ * products, options, or pricing. It is a small, GC-friendly cache.
+ *
+ * Lifetime:
+ *
+ * - Uses `WeakMap` / `Map` keyed by DOM nodes so disconnected nodes can be
+ *   reclaimed by the GC.
+ * - `clear()` resets the registry to empty.
+ *
+ * **Cross-scope limitation.** A source registry is owned by the
+ * index that created it (one registry per `EtaTemplateIndex`
+ * instance by default). Moving a rendered template node from one
+ * scope to another loses the original template source — the
+ * destination index's registry has no record of it, so the
+ * factory falls back to the live DOM value, which now holds the
+ * rendered string rather than the template literal. The
+ * destination index cannot recreate the operation without
+ * discovering the new template content externally.
+ *
+ * If an application reparents rendered template nodes across
+ * scopes, the safe options are:
+ *
+ * 1. Share a single `EtaTemplateSourceRegistry` across the
+ *    affected indices and have each index pass that shared
+ *    registry through the `TemplateOperationContext` on every
+ *    factory call — the factory itself is stateless at the call
+ *    site, so a single registry can back multiple indices.
+ * 2. Accept that moved nodes must be re-discovered by the
+ *    destination index — for example, by re-emitting the original
+ *    template literal into the moved node, or by relying on the
+ *    index's normal `MutationObserver` flow to pick up the new
+ *    template content.
+ *
+ * Today the controller does not expose a `sourceRegistry`
+ * cross-index option; sharing requires reaching into the index
+ * constructor. The v4 review recommends keeping this limitation
+ * documented unless an application actually needs cross-scope
+ * DOM moves — at which point the index/controller can grow a
+ * `sourceRegistry` option that overrides the per-index
+ * `createEtaTemplateSourceRegistry()` default.
+ */
+/**
+ * Default predicate used by `EtaTemplateSourceRegistry` to recognise
+ * template text.
+ *
+ * Requires BOTH an opening `{{` AND a closing `}}` so the registry
+ * can safely inspect arbitrary DOM values without false positives on
+ * stray `{{` markers in plain string literals.
+ *
+/**
+ * Default predicate used to decide whether a string contains an
+ * Eta template token.
+ *
+ * Requires BOTH an opening `{{` AND a closing `}}` so the
+ * predicate does not pay the cost of compiling partial template
+ * fragments (e.g. `Hello {{ user` with a typo) or arbitrary
+ * DOM values that happen to contain `{{` inside a plain string
+ * literal. The empty-string guard short-circuits the
+ * `indexOf` calls on falsy input.
+ *
+ * **Single source of truth.** The factory (`factory.ts`) re-exports
+ * this predicate as `defaultIsTemplateText` for backward
+ * compatibility; the two names point at the same function so the
+ * registry and the factory can never drift apart.
+ */
+export function defaultContainsEtaTemplate(text) {
+    if (!text) {
+        return false;
+    }
+    return (text.indexOf('{{') !== -1 &&
+        text.indexOf('}}') !== -1);
+}
+/**
+ * Sidecar storage for original template sources.
+ *
+ * Reads are tolerant: if no source is preserved for a node, the registry
+ * consults the DOM value, and if that contains a template it persists the
+ * value so the next read returns the preserved source rather than the
+ * (possibly already-rendered) DOM value.
+ *
+ * **Destructive operations out of scope.** The registry only preserves
+ * sources; it does not enumerate attribute names that have been removed
+ * from the DOM. Removing an attribute at runtime (e.g. via
+ * `element.removeAttribute`) is a destructive operation: the registry
+ * has no way to discover a removed attribute name from a live element
+ * alone. Once `removeWhenEmpty` was dropped from the renderer, the
+ * registry only ever needs to handle attributes that are still present
+ * in the DOM, so this limitation is no longer a concern in practice.
+ */
+export class EtaTemplateSourceRegistry {
+    constructor(options = {}) {
+        this.textSources = new WeakMap();
+        this.attrSources = new WeakMap();
+        this.isTemplateText =
+            options.isTemplateText ??
+                defaultContainsEtaTemplate;
+    }
+    /**
+     * Returns the preserved source for a text node, falling back to the
+     * current DOM value.
+     *
+     * If the DOM value contains a template and no preserved source exists,
+     * the value is persisted so future reads stay stable even after the
+     * DOM value changes.
+     */
+    readTextSource(node) {
+        const existing = this.textSources.get(node);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const current = node.nodeValue ?? '';
+        if (!this.containsTemplate(current)) {
+            return undefined;
+        }
+        this.textSources.set(node, current);
+        return current;
+    }
+    /**
+     * Sets or clears the preserved source for a text node.
+     *
+     * Pass `undefined` to remove any preserved source; the next call to
+     * `readTextSource` will then fall back to the current DOM value.
+     */
+    replaceTextSource(node, source) {
+        if (source === undefined) {
+            this.textSources.delete(node);
+            return;
+        }
+        this.textSources.set(node, source);
+    }
+    /**
+     * Returns the preserved source for a single attribute on an element.
+     *
+     * If no preserved source exists, the registry consults the current
+     * DOM value; when the value contains a template, the registry persists
+     * it so future reads stay stable.
+     */
+    readAttributeSource(element, name) {
+        const existing = this.attrSources.get(element)?.get(name);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const current = element.getAttribute(name);
+        if (current === null ||
+            current === undefined ||
+            !this.containsTemplate(current)) {
+            return undefined;
+        }
+        this.setAttributeSource(element, name, current);
+        return current;
+    }
+    /**
+     * Stores a preserved source for an attribute. Used both internally
+     * (after reading a fresh DOM value) and externally (after parsing a
+     * template literal that the DOM no longer exposes).
+     */
+    setAttributeSource(element, name, source) {
+        let byName = this.attrSources.get(element);
+        if (!byName) {
+            byName = new Map();
+            this.attrSources.set(element, byName);
+        }
+        byName.set(name, source);
+    }
+    /**
+     * Removes a preserved attribute source. No-op if no source exists.
+     */
+    removeAttributeSource(element, name) {
+        const byName = this.attrSources.get(element);
+        if (!byName) {
+            return;
+        }
+        byName.delete(name);
+        if (byName.size === 0) {
+            this.attrSources.delete(element);
+        }
+    }
+    /**
+     * Reads the current DOM value for a text node and updates the
+     * registry accordingly.
+     *
+     * Persists the value when it contains a template; clears any
+     * previously preserved source otherwise. This is the right call for
+     * external mutations where the DOM has been edited and the registry
+     * should reflect the new state.
+     */
+    syncTextSource(node) {
+        const current = node.nodeValue ?? '';
+        if (this.containsTemplate(current)) {
+            this.textSources.set(node, current);
+        }
+        else {
+            this.textSources.delete(node);
+        }
+    }
+    /**
+     * Reads the current DOM value for an attribute and updates the
+     * registry accordingly.
+     *
+     * Persists the value when it contains a template; clears any
+     * previously preserved source otherwise. The right call for external
+     * attribute mutations.
+     */
+    syncAttributeSource(element, name) {
+        const current = element.getAttribute(name);
+        if (current === null ||
+            current === undefined) {
+            this.removeAttributeSource(element, name);
+            return;
+        }
+        if (this.containsTemplate(current)) {
+            this.setAttributeSource(element, name, current);
+        }
+        else {
+            this.removeAttributeSource(element, name);
+        }
+    }
+    /**
+     * Wipes every preserved source.
+     *
+     * Mostly useful for tests. Production code should let the GC reclaim
+     * entries as nodes become unreachable.
+     */
+    clear() {
+        // WeakMap has no `clear` in older targets, so we replace the
+        // internal references with fresh maps. The old maps become
+        // unreachable as soon as no caller holds them.
+        this.textSources = new WeakMap();
+        this.attrSources = new WeakMap();
+    }
+    /**
+     * Returns `true` when `text` looks like an Eta template.
+     *
+     * Delegates to the configured predicate; the default
+     * (`defaultContainsEtaTemplate`) requires both an opening `{{` AND a
+     * closing `}}`.
+     */
+    containsTemplate(text) {
+        return this.isTemplateText(text);
+    }
+}
+/**
+ * Convenience constructor used by the index and the default factory.
+ */
+export function createEtaTemplateSourceRegistry(options) {
+    return new EtaTemplateSourceRegistry(options);
+}
+//# sourceMappingURL=source-registry.js.map

package/dist/src/eta/source-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-registry.js","sourceRoot":"","sources":["../../../src/eta/source-registry.ts"],"names":[],"mappings":"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","sourcesContent":["// src/eta/source-registry.ts\n\n/**\n * Sidecar registry that preserves original template sources across renders.\n *\n * The Eta template subsystem overwrites DOM values during render:\n *\n *   <span>{{=it.name}}</span>\n *   becomes\n *   <span>iPhone</span>\n *\n * Once a render has happened, the original `{{=it.name}}` source is gone\n * from the DOM. If the index is later cleared and re-initialized — or if a\n * mutation observer forwards an external edit — the factory can only see\n * the rendered string, not the template source.\n *\n * The registry stores the original sources keyed by node identity. The\n * factory consults the registry first and only falls back to the DOM\n * value when the registry has no entry.\n *\n * The registry is intentionally generic: it does not know about Eta, scope,\n * products, options, or pricing. It is a small, GC-friendly cache.\n *\n * Lifetime:\n *\n * - Uses `WeakMap` / `Map` keyed by DOM nodes so disconnected nodes can be\n *   reclaimed by the GC.\n * - `clear()` resets the registry to empty.\n *\n * **Cross-scope limitation.** A source registry is owned by the\n * index that created it (one registry per `EtaTemplateIndex`\n * instance by default). Moving a rendered template node from one\n * scope to another loses the original template source — the\n * destination index's registry has no record of it, so the\n * factory falls back to the live DOM value, which now holds the\n * rendered string rather than the template literal. The\n * destination index cannot recreate the operation without\n * discovering the new template content externally.\n *\n * If an application reparents rendered template nodes across\n * scopes, the safe options are:\n *\n * 1. Share a single `EtaTemplateSourceRegistry` across the\n *    affected indices and have each index pass that shared\n *    registry through the `TemplateOperationContext` on every\n *    factory call — the factory itself is stateless at the call\n *    site, so a single registry can back multiple indices.\n * 2. Accept that moved nodes must be re-discovered by the\n *    destination index — for example, by re-emitting the original\n *    template literal into the moved node, or by relying on the\n *    index's normal `MutationObserver` flow to pick up the new\n *    template content.\n *\n * Today the controller does not expose a `sourceRegistry`\n * cross-index option; sharing requires reaching into the index\n * constructor. The v4 review recommends keeping this limitation\n * documented unless an application actually needs cross-scope\n * DOM moves — at which point the index/controller can grow a\n * `sourceRegistry` option that overrides the per-index\n * `createEtaTemplateSourceRegistry()` default.\n */\n\n/**\n * Default predicate used by `EtaTemplateSourceRegistry` to recognise\n * template text.\n *\n * Requires BOTH an opening `{{` AND a closing `}}` so the registry\n * can safely inspect arbitrary DOM values without false positives on\n * stray `{{` markers in plain string literals.\n *\n/**\n * Default predicate used to decide whether a string contains an\n * Eta template token.\n *\n * Requires BOTH an opening `{{` AND a closing `}}` so the\n * predicate does not pay the cost of compiling partial template\n * fragments (e.g. `Hello {{ user` with a typo) or arbitrary\n * DOM values that happen to contain `{{` inside a plain string\n * literal. The empty-string guard short-circuits the\n * `indexOf` calls on falsy input.\n *\n * **Single source of truth.** The factory (`factory.ts`) re-exports\n * this predicate as `defaultIsTemplateText` for backward\n * compatibility; the two names point at the same function so the\n * registry and the factory can never drift apart.\n */\nexport function defaultContainsEtaTemplate(\n  text: string\n): boolean {\n  if (!text) {\n    return false;\n  }\n\n  return (\n    text.indexOf('{{') !== -1 &&\n    text.indexOf('}}') !== -1\n  );\n}\n\n/**\n * Predicate used to decide whether a string contains a template token.\n *\n * The default (`defaultContainsEtaTemplate`) requires BOTH an opening\n * `{{` AND a closing `}}` so the registry can safely inspect arbitrary\n * DOM values. Callers can plug in a stricter predicate when they want\n * to be even more conservative.\n */\nexport type EtaTemplatePredicate = (text: string) => boolean;\n\n/**\n * Options accepted by `EtaTemplateSourceRegistry`.\n */\nexport interface EtaTemplateSourceRegistryOptions {\n  /**\n   * Predicate used to recognise template text. Defaults to\n   * `defaultContainsEtaTemplate`, which requires both `{{` AND `}}`.\n   */\n  readonly isTemplateText?: EtaTemplatePredicate;\n}\n\n/**\n * Sidecar storage for original template sources.\n *\n * Reads are tolerant: if no source is preserved for a node, the registry\n * consults the DOM value, and if that contains a template it persists the\n * value so the next read returns the preserved source rather than the\n * (possibly already-rendered) DOM value.\n *\n * **Destructive operations out of scope.** The registry only preserves\n * sources; it does not enumerate attribute names that have been removed\n * from the DOM. Removing an attribute at runtime (e.g. via\n * `element.removeAttribute`) is a destructive operation: the registry\n * has no way to discover a removed attribute name from a live element\n * alone. Once `removeWhenEmpty` was dropped from the renderer, the\n * registry only ever needs to handle attributes that are still present\n * in the DOM, so this limitation is no longer a concern in practice.\n */\nexport class EtaTemplateSourceRegistry {\n  private textSources: WeakMap<Text, string> =\n    new WeakMap();\n\n  private attrSources: WeakMap<\n    Element,\n    Map<string, string>\n  > = new WeakMap();\n\n  private readonly isTemplateText: EtaTemplatePredicate;\n\n  constructor(\n    options: EtaTemplateSourceRegistryOptions = {}\n  ) {\n    this.isTemplateText =\n      options.isTemplateText ??\n      defaultContainsEtaTemplate;\n  }\n\n  /**\n   * Returns the preserved source for a text node, falling back to the\n   * current DOM value.\n   *\n   * If the DOM value contains a template and no preserved source exists,\n   * the value is persisted so future reads stay stable even after the\n   * DOM value changes.\n   */\n  readTextSource(node: Text): string | undefined {\n    const existing = this.textSources.get(node);\n\n    if (existing !== undefined) {\n      return existing;\n    }\n\n    const current = node.nodeValue ?? '';\n\n    if (!this.containsTemplate(current)) {\n      return undefined;\n    }\n\n    this.textSources.set(node, current);\n\n    return current;\n  }\n\n  /**\n   * Sets or clears the preserved source for a text node.\n   *\n   * Pass `undefined` to remove any preserved source; the next call to\n   * `readTextSource` will then fall back to the current DOM value.\n   */\n  replaceTextSource(\n    node: Text,\n    source: string | undefined\n  ): void {\n    if (source === undefined) {\n      this.textSources.delete(node);\n      return;\n    }\n\n    this.textSources.set(node, source);\n  }\n\n  /**\n   * Returns the preserved source for a single attribute on an element.\n   *\n   * If no preserved source exists, the registry consults the current\n   * DOM value; when the value contains a template, the registry persists\n   * it so future reads stay stable.\n   */\n  readAttributeSource(\n    element: Element,\n    name: string\n  ): string | undefined {\n    const existing =\n      this.attrSources.get(element)?.get(name);\n\n    if (existing !== undefined) {\n      return existing;\n    }\n\n    const current = element.getAttribute(name);\n\n    if (\n      current === null ||\n      current === undefined ||\n      !this.containsTemplate(current)\n    ) {\n      return undefined;\n    }\n\n    this.setAttributeSource(element, name, current);\n\n    return current;\n  }\n\n  /**\n   * Stores a preserved source for an attribute. Used both internally\n   * (after reading a fresh DOM value) and externally (after parsing a\n   * template literal that the DOM no longer exposes).\n   */\n  setAttributeSource(\n    element: Element,\n    name: string,\n    source: string\n  ): void {\n    let byName = this.attrSources.get(element);\n\n    if (!byName) {\n      byName = new Map<string, string>();\n      this.attrSources.set(element, byName);\n    }\n\n    byName.set(name, source);\n  }\n\n  /**\n   * Removes a preserved attribute source. No-op if no source exists.\n   */\n  removeAttributeSource(\n    element: Element,\n    name: string\n  ): void {\n    const byName = this.attrSources.get(element);\n\n    if (!byName) {\n      return;\n    }\n\n    byName.delete(name);\n\n    if (byName.size === 0) {\n      this.attrSources.delete(element);\n    }\n  }\n\n  /**\n   * Reads the current DOM value for a text node and updates the\n   * registry accordingly.\n   *\n   * Persists the value when it contains a template; clears any\n   * previously preserved source otherwise. This is the right call for\n   * external mutations where the DOM has been edited and the registry\n   * should reflect the new state.\n   */\n  syncTextSource(node: Text): void {\n    const current = node.nodeValue ?? '';\n\n    if (this.containsTemplate(current)) {\n      this.textSources.set(node, current);\n    } else {\n      this.textSources.delete(node);\n    }\n  }\n\n  /**\n   * Reads the current DOM value for an attribute and updates the\n   * registry accordingly.\n   *\n   * Persists the value when it contains a template; clears any\n   * previously preserved source otherwise. The right call for external\n   * attribute mutations.\n   */\n  syncAttributeSource(\n    element: Element,\n    name: string\n  ): void {\n    const current = element.getAttribute(name);\n\n    if (\n      current === null ||\n      current === undefined\n    ) {\n      this.removeAttributeSource(element, name);\n      return;\n    }\n\n    if (this.containsTemplate(current)) {\n      this.setAttributeSource(element, name, current);\n    } else {\n      this.removeAttributeSource(element, name);\n    }\n  }\n\n  /**\n   * Wipes every preserved source.\n   *\n   * Mostly useful for tests. Production code should let the GC reclaim\n   * entries as nodes become unreachable.\n   */\n  clear(): void {\n    // WeakMap has no `clear` in older targets, so we replace the\n    // internal references with fresh maps. The old maps become\n    // unreachable as soon as no caller holds them.\n    this.textSources = new WeakMap();\n    this.attrSources = new WeakMap();\n  }\n\n  /**\n   * Returns `true` when `text` looks like an Eta template.\n   *\n   * Delegates to the configured predicate; the default\n   * (`defaultContainsEtaTemplate`) requires both an opening `{{` AND a\n   * closing `}}`.\n   */\n  private containsTemplate(text: string): boolean {\n    return this.isTemplateText(text);\n  }\n}\n\n/**\n * Convenience constructor used by the index and the default factory.\n */\nexport function createEtaTemplateSourceRegistry(\n  options?: EtaTemplateSourceRegistryOptions\n): EtaTemplateSourceRegistry {\n  return new EtaTemplateSourceRegistry(options);\n}\n"]}