@fusion.dev/helix-core 0.25.1 → 0.30.0

package/dist/controllers/chart-pointer-controller/chart-pointer-controller.d.ts

@@ -35,7 +35,9 @@ export interface ChartPointerHost extends ReactiveControllerHost, HTMLElement {
  * `pointerType` is not fine.
  */
 export declare class ChartPointerController implements ReactiveController {
-    #private;
+    private host;
+    private moved;
+    private plot;
     /** The reading under the pointer, or -1 when the pointer is elsewhere. */
     at: number;
     /**
@@ -73,6 +75,26 @@ export declare class ChartPointerController implements ReactiveController {
      * position until the render that follows.
      */
     hostUpdated(): void;
+    /**
+     * The box the readings are laid out in, which is the plot and not the host.
+     *
+     * The host also holds the row of labels, so measuring against it would map
+     * the pointer over a box taller than the drawing. That mattered the moment a
+     * chart started measuring down the box rather than across it, which is what
+     * `axis` is for: on a horizontal bar chart the labels are beside the plot
+     * rather than under it, and the host is wider than the drawing by exactly
+     * their column.
+     *
+     * **Held only while it is still in the tree.** Every chart renders a
+     * different template for its empty state, so the plot a pointer crossed
+     * before the table filled is a node Lit has since replaced: held forever, it
+     * measures a detached box and the tooltip never appears. Looked up again
+     * whenever the held one has left, which is once per data arrival rather than
+     * once per move.
+     */
+    private box;
     /** Puts the pointer on a reading, for a chart that resolves it some other way. */
     set(at: number): void;
+    private readonly move;
+    private readonly leave;
 }

package/dist/controllers/chart-pointer-controller/chart-pointer-controller.js

@@ -1,17 +1,14 @@
 export class ChartPointerController {
-    #host;
-    #moved;
-    #plot;
     constructor(host) {
-        this.#moved = false;
+        this.moved = false;
         this.at = -1;
         this.axis = 'inline';
-        this.#move = (event) => {
+        this.move = (event) => {
             if (this.axis === 'none' || (event.pointerType !== 'mouse' && event.pointerType !== 'pen')) {
                 return;
             }
-            const box = this.#box();
-            const count = this.#host.readings;
+            const box = this.box();
+            const count = this.host.readings;
             const along = this.axis === 'block' ? box?.height : box?.width;
             if (!box || !along || count === 0) {
                 return;
@@ -21,48 +18,48 @@ export class ChartPointerController {
             const next = Math.min(Math.max(slot, 0), count - 1);
             if (next !== this.at) {
                 this.at = next;
-                this.#moved = true;
-                this.#host.requestUpdate();
+                this.moved = true;
+                this.host.requestUpdate();
             }
         };
-        this.#leave = () => {
+        this.leave = () => {
             if (this.at !== -1) {
                 this.at = -1;
-                this.#host.requestUpdate();
+                this.host.requestUpdate();
             }
         };
-        this.#host = host;
+        this.host = host;
         host.addController(this);
     }
     hostConnected() {
-        this.#host.addEventListener('pointermove', this.#move);
-        this.#host.addEventListener('pointerleave', this.#leave);
+        this.host.addEventListener('pointermove', this.move);
+        this.host.addEventListener('pointerleave', this.leave);
     }
     hostDisconnected() {
-        this.#host.removeEventListener('pointermove', this.#move);
-        this.#host.removeEventListener('pointerleave', this.#leave);
+        this.host.removeEventListener('pointermove', this.move);
+        this.host.removeEventListener('pointerleave', this.leave);
         this.at = -1;
     }
     hostUpdated() {
-        if (!this.#moved) {
+        if (!this.moved) {
             return;
         }
-        this.#moved = false;
-        this.#host.renderRoot
+        this.moved = false;
+        this.host.renderRoot
             .querySelector('[part="tooltip-anchor"]')
             ?.reposition?.();
     }
-    #box() {
-        this.#plot ??= this.#host.renderRoot.querySelector('[part="plot"]') ?? undefined;
-        return this.#plot?.getBoundingClientRect();
+    box() {
+        if (!this.plot?.isConnected) {
+            this.plot = this.host.renderRoot.querySelector('[part="plot"]') ?? undefined;
+        }
+        return this.plot?.getBoundingClientRect();
     }
     set(at) {
         if (at !== this.at) {
             this.at = at;
-            this.#moved = true;
-            this.#host.requestUpdate();
+            this.moved = true;
+            this.host.requestUpdate();
         }
     }
-    #move;
-    #leave;
 }

package/dist/controllers/dismiss-controller/dismiss-controller.d.ts

@@ -74,8 +74,35 @@ export declare class DismissController implements ReactiveController {
      * null in some browsers, so the read is guarded and the frame is simply
      * skipped. Nothing is lost by skipping it that was not already lost: there is
      * no listener to add to a document this one may not touch.
+     *
+     * **And walked only where the page holds a frame at all.** The walk is every
+     * element on the page, through every shadow root, and it ran on every
+     * `activate`, which is every tooltip hover and every menu opening. Measured
+     * in Chromium on 14 Sep 2026, on a page of 10,006 elements across 500 shadow
+     * roots, which is the shape of a docs page: 1.36ms per walk, against a
+     * length read on `getElementsByTagName('iframe')` too small for
+     * `performance.now` to resolve over 20,000 runs. That collection is live and
+     * the engine keeps its count, so asking it is a read rather than a search.
+     *
+     * **What the count cannot see is a frame inside a shadow root**, and that is
+     * a trade made knowingly rather than an oversight. A page whose only frame
+     * sits in a shadow root reads as having none and skips the walk, so a
+     * same-origin frame rendered by a component is not listened to there. The
+     * one frame this library renders inside a shadow root is the sandbox's
+     * preview, which is sandboxed without `allow-same-origin` and so is a
+     * document this one may not read whether or not it is found: the blur
+     * signal is what covers it, and the walk never could. A page with a frame in
+     * the light DOM still walks, shadow roots included.
+     *
+     * Held for the rest of the run as well, so overlays that activate together,
+     * a dialog opening a select from its own `updated`, walk once between them.
+     * A microtask and no longer: what a frame gathered here is good for is the
+     * lifetime of one open, and the task after this one is a page that may have
+     * gained a frame.
      */
     private static frameDocuments;
+    /** What the last walk found, for the rest of the run it was made in. */
+    private static found;
     /**
      * The frame documents being listened to, held so the same ones are released.
      *

package/dist/controllers/dismiss-controller/dismiss-controller.js

@@ -8,7 +8,12 @@ const deepDepth = (node) => {
     }
     return depth;
 };
-const listening = new Set();
+const REGISTRY = Symbol.for('fusion.helix.dismiss.listening');
+const globals = globalThis;
+if (globals[REGISTRY] === undefined) {
+    globals[REGISTRY] = new Set();
+}
+const listening = globals[REGISTRY];
 export class DismissController {
     constructor(host, { boundary, onDismiss }) {
         this.active = false;
@@ -54,6 +59,12 @@ export class DismissController {
         host.addController(this);
     }
     static frameDocuments() {
+        if (DismissController.found) {
+            return DismissController.found;
+        }
+        if (document.getElementsByTagName('iframe').length === 0) {
+            return [];
+        }
         const found = [];
         const walk = (root) => {
             for (const element of root.querySelectorAll('*')) {
@@ -73,6 +84,10 @@ export class DismissController {
             }
         };
         walk(document);
+        DismissController.found = found;
+        queueMicrotask(() => {
+            DismissController.found = undefined;
+        });
         return found;
     }
     activate() {
@@ -84,7 +99,7 @@ export class DismissController {
         document.addEventListener('keydown', this.handleKeydown);
         document.addEventListener('pointerdown', this.handlePointerDown);
         window.addEventListener('blur', this.handleWindowBlur);
-        this.frames = DismissController.frameDocuments();
+        this.frames = [...DismissController.frameDocuments()];
         for (const inner of this.frames) {
             inner.addEventListener('pointerdown', this.handlePointerDown);
         }

package/dist/controllers/floating-controller/floating-controller.d.ts

@@ -112,6 +112,19 @@ export declare class FloatingController implements ReactiveController {
     constructor(host: ReactiveControllerHost & HTMLElement, options: FloatingOptions);
     /** The placement in use after the last measurement. */
     placement: Placement;
+    /**
+     * How far the arrow keeps from the floating element's ends, measured once.
+     *
+     * `autoUpdate` runs `update` on every scroll frame of every ancestor, and
+     * `corner` is a `getComputedStyle` and four parses, which was a style read
+     * per frame for a number that does not change while the surface is up. So it
+     * is read as placing starts, when the surface has just been shown and has a
+     * computed style to read, and forgotten as placing stops, so a surface
+     * restyled between opens is measured again. `update` measures for itself
+     * where nothing started it, which is a `reposition` on a surface placed by
+     * its own stylesheet.
+     */
+    private padding;
     /** Starts placing, and keeps placing until stopped. */
     start(): void;
     /** Stops placing and releases everything it was tracking. */

package/dist/controllers/floating-controller/floating-controller.js

@@ -53,7 +53,7 @@ export class FloatingController {
                 }));
             }
             if (pointer) {
-                middleware.push(arrow({ element: pointer, padding: corner(floating) }));
+                middleware.push(arrow({ element: pointer, padding: this.padding ?? corner(floating) }));
             }
             computePosition(anchor, floating, {
                 middleware,
@@ -92,12 +92,14 @@ export class FloatingController {
         if (!anchor || !floating || this.cleanup) {
             return;
         }
+        this.padding = this.options.arrow?.() ? corner(floating) : 0;
         this.cleanup = autoUpdate(anchor, floating, this.update);
     }
     stop() {
         this.run += 1;
         this.cleanup?.();
         this.cleanup = undefined;
+        this.padding = undefined;
         this.options.floating()?.removeAttribute('data-placed');
     }
     hostDisconnected() {

package/dist/controllers/indicator-controller/indicator-controller.d.ts

@@ -7,6 +7,20 @@ export interface IndicatorOptions {
     active: () => HTMLElement | null | undefined;
     /** The traveling mark. Positioned against the surface. */
     indicator: () => HTMLElement | null | undefined;
+    /**
+     * Elements whose own size moves the mark, beyond the host.
+     *
+     * The host is always watched, and it is not enough on its own: an item can
+     * change width inside a strip that keeps its size, and the host never fires
+     * for that. So a component hands over its items, and they are watched too.
+     *
+     * Read again on every placement rather than once, because the set is not
+     * settled when the controller connects: a tab strip's tabs have not
+     * upgraded by its first update, so a list read then is empty, and watching
+     * nothing is silent. Observing the same element twice is a no-op, so the
+     * re-read costs nothing and needs no bookkeeping about who is watched.
+     */
+    observe?: () => readonly Element[];
     /**
      * The box the mark is positioned against, which is its containing block.
      *
@@ -61,6 +75,8 @@ export declare class IndicatorController implements ReactiveController {
     private resize;
     constructor(host: ReactiveControllerHost & HTMLElement, options: IndicatorOptions);
     hostConnected(): void;
+    /** Watches whatever `observe` names now, which `place` asks for on every placement. */
+    private watch;
     hostDisconnected(): void;
     /** Called after every update, which is when the marked child may have moved. */
     hostUpdated(): void;

package/dist/controllers/indicator-controller/indicator-controller.js

@@ -7,6 +7,12 @@ export class IndicatorController {
     hostConnected() {
         this.resize = new ResizeObserver(() => this.place());
         this.resize.observe(this.host);
+        this.watch();
+    }
+    watch() {
+        for (const element of this.options.observe?.() ?? []) {
+            this.resize?.observe(element);
+        }
     }
     hostDisconnected() {
         this.resize?.disconnect();
@@ -17,6 +23,7 @@ export class IndicatorController {
         this.place();
     }
     place() {
+        this.watch();
         const indicator = this.options.indicator();
         const surface = this.options.surface();
         const active = this.options.active();

package/dist/controllers/popover-controller/popover-controller.d.ts

@@ -56,6 +56,26 @@ export interface PopoverOptions {
      * select puts focus back on its trigger, and a tooltip does neither.
      */
     onDismiss: () => void;
+    /**
+     * Whether the host wants the surface up, read after every update.
+     *
+     * **The open state is a property, and a consumer may set it directly**, so
+     * raising the surface from a `show()` method alone leaves a panel opened by
+     * declaring `open` visible, out of the top layer and unanchored: every
+     * imperative path works and every declarative one is half-open. Ten
+     * families wrote the same `if (this.open) show() else hide()` into their
+     * `updated()` for that reason, and this is that paragraph once.
+     *
+     * After the update and never before it, because the render has to have
+     * been written: until then the surface is still `display: none` and
+     * `showPopover` on it measures zeroes. A controller's `hostUpdated` runs
+     * after the commit and before the host's own `updated`, so a host that has
+     * to act on a surface that is up, focusing into it or centering a wheel,
+     * finds it up.
+     *
+     * Left unset, the host drives `show()` and `hide()` itself.
+     */
+    open?: () => boolean;
     /** Preferred side. It moves if that side does not fit. */
     placement?: Placement | (() => Placement);
     /** The panel that floats. */
@@ -99,6 +119,8 @@ export declare class PopoverController implements ReactiveController {
     constructor(host: ReactiveControllerHost & HTMLElement, options: PopoverOptions);
     /** Whether the surface is showing. */
     get open(): boolean;
+    /** Puts the surface where the host's `open` says, however it got there. */
+    hostUpdated(): void;
     /** Whether this one is placed by measurement, read fresh so it may change. */
     private get places();
     /**

package/dist/controllers/popover-controller/popover-controller.js

@@ -21,6 +21,18 @@ export class PopoverController {
     get open() {
         return this.shown;
     }
+    hostUpdated() {
+        const wanted = this.options.open?.();
+        if (wanted === undefined) {
+            return;
+        }
+        if (wanted) {
+            this.show();
+        }
+        else {
+            this.hide();
+        }
+    }
     get places() {
         const asked = this.options.place;
         if (asked === undefined) {

package/dist/controllers/source-controller/source-controller.d.ts

@@ -1,5 +1,5 @@
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
-import { type Series } from '../../utils/read-series/read-series.js';
+import { type Row, type Series } from '../../utils/read-series/read-series.js';
 /** A host that names the element it reads from. */
 export interface SourceHost extends ReactiveControllerHost, HTMLElement {
     /**
@@ -28,7 +28,20 @@ export interface SourceHost extends ReactiveControllerHost, HTMLElement {
  * and nothing in a page has reason to know a chart is reading it.
  */
 export declare class SourceController implements ReactiveController {
-    #private;
+    private host;
+    private observer;
+    /** Whether a hydrating render was told there was nothing, and needs the render after. */
+    private deferred;
+    /**
+     * Which edit of the table the parses below belong to.
+     *
+     * Moved by the watcher and by `watch()`, which are the two things that can
+     * change what a chart reads without the chart doing anything: an edit to the
+     * table, and `for` naming another one.
+     */
+    private version;
+    private heldRows;
+    private heldSeries;
     constructor(host: SourceHost);
     /**
      * The element `for` names, or null where there is nothing to name it in.
@@ -42,8 +55,37 @@ export declare class SourceController implements ReactiveController {
      * a template Lit throws on. The update after it, which this asks for, draws.
      */
     get element(): Element | null;
-    /** The series it holds, or none. */
+    /**
+     * The element `for` names, whatever the host is rendering.
+     *
+     * Apart from `element` because the watcher needs the table while a render
+     * cannot have it: attached on connect, which on a server's page is before
+     * the render that hydrates, it resolved nothing there and never watched, so a
+     * table a page filled afterwards drew no line.
+     */
+    private resolve;
+    /**
+     * The series it holds, or none.
+     *
+     * **Parsed once per edit, not once per read.** A chart's render asks for
+     * these several times over, and the pointer asks for the row count on every
+     * move, so parsing the whole table on each read was a table walk per
+     * pointermove. The parse is held against the table it came from and the
+     * edit it saw, and let go when either moves: `element` is compared by
+     * identity, so a table replaced under the same id parses again, and the
+     * watcher moves the version on every mutation it delivers.
+     *
+     * Which is a microtask after the edit, the observer being what it is. A
+     * read in the same run as the edit answers the parse before it, and every
+     * render that follows, which is what the watcher exists to ask for, answers
+     * the one after. The same array comes back until then, so a consumer may
+     * compare by identity.
+     */
     get series(): Series[];
+    /** Every row it holds, text and number alike, or none. Held the way `series` is. */
+    get rows(): Row[];
+    /** A held parse where it still describes the table, or a fresh one. */
+    private parsed;
     hostConnected(): void;
     hostUpdated(): void;
     hostDisconnected(): void;

package/dist/controllers/source-controller/source-controller.js

@@ -1,21 +1,20 @@
-import { readSeries } from '../../utils/read-series/read-series.js';
+import { readRows, readSeries } from '../../utils/read-series/read-series.js';
 export class SourceController {
-    #host;
-    #observer;
-    #deferred = false;
     constructor(host) {
-        this.#host = host;
+        this.deferred = false;
+        this.version = 0;
+        this.host = host;
         host.addController(this);
     }
     get element() {
-        if (this.#host.hydrating === true) {
-            this.#deferred = this.#host.for !== '';
+        if (this.host.hydrating === true) {
+            this.deferred = this.host.for !== '';
             return null;
         }
-        return this.#resolve();
+        return this.resolve();
     }
-    #resolve() {
-        const host = this.#host;
+    resolve() {
+        const host = this.host;
         if (host.for === '') {
             return null;
         }
@@ -33,32 +32,45 @@ export class SourceController {
             : null;
     }
     get series() {
+        this.heldSeries = this.parsed(this.heldSeries, (table) => (table ? readSeries(table) : []));
+        return this.heldSeries.value;
+    }
+    get rows() {
+        this.heldRows = this.parsed(this.heldRows, (table) => (table ? readRows(table) : []));
+        return this.heldRows.value;
+    }
+    parsed(held, read) {
         const element = this.element;
-        return element ? readSeries(element) : [];
+        if (held && held.element === element && held.version === this.version) {
+            return held;
+        }
+        return { element, value: read(element), version: this.version };
     }
     hostConnected() {
         this.watch();
     }
     hostUpdated() {
-        if (this.#deferred) {
-            this.#deferred = false;
-            this.#host.requestUpdate();
+        if (this.deferred) {
+            this.deferred = false;
+            this.host.requestUpdate();
         }
     }
     hostDisconnected() {
-        this.#observer?.disconnect();
-        this.#observer = undefined;
+        this.observer?.disconnect();
+        this.observer = undefined;
     }
     watch() {
-        this.#observer?.disconnect();
-        const element = this.#resolve();
+        this.observer?.disconnect();
+        this.version += 1;
+        const element = this.resolve();
         if (!element || typeof MutationObserver === 'undefined') {
             return;
         }
-        this.#observer ??= new MutationObserver(() => {
-            this.#host.requestUpdate();
+        this.observer ??= new MutationObserver(() => {
+            this.version += 1;
+            this.host.requestUpdate();
         });
-        this.#observer.observe(element, {
+        this.observer.observe(element, {
             characterData: true,
             childList: true,
             subtree: true,

package/dist/helix-element/helix-element.d.ts

@@ -50,6 +50,25 @@ export declare class HelixElement extends LitElement {
      * template cache on the joined string rather than on the object.
      */
     protected tag(name: string): StaticValue;
+    /**
+     * One of this element's own parts, by name, or null where it is not rendered.
+     *
+     * Not `part`, which every element already has: `Element.part` is the
+     * `DOMTokenList` of the names the element itself carries, and a method under
+     * that name is a type error on every subclass.
+     *
+     * **One guard for every lookup.** Lit's server shim has no `querySelector`
+     * on the render root, so a lookup reached during a server render, from a
+     * getter a template reads or from `willUpdate`, throws there and nowhere
+     * else. Four spellings of the same guard had grown across the library, and
+     * a fifth site with none. Null on the server, which is what the rest of the
+     * code already treats a part that has not rendered as.
+     *
+     * `helix component`'s `selectors` reads these calls the way it reads a
+     * `querySelector('[part="x"]')`, so a name nothing renders is a finding
+     * rather than a null an optional chain swallows.
+     */
+    protected partNamed<T extends Element = HTMLElement>(name: string): T | null;
     /**
      * The element's semantics, set without touching the DOM.
      *

package/dist/helix-element/helix-element.js

@@ -1,7 +1,6 @@
 import { css, LitElement } from 'lit';
 import { unsafeStatic } from 'lit/static-html.js';
-import { eventsForTag } from '../events/element-events.js';
-import { helixEventNames } from '../events/events.js';
+import { applyReactProperties, auditReactProps, bindReactHandler, reactPropsOf, } from './react-bridge.js';
 const BOX_SIZING = css `
   *,
   ::before,
@@ -25,103 +24,15 @@ const SETTLED = css `
     transition: none !important;
   }
 `;
-const REACT_PROPS = '__reactProps$';
-let reactPropsKey;
-const reactPropsOf = (node) => {
-    const stash = node;
-    if (reactPropsKey !== undefined && stash[reactPropsKey] !== undefined) {
-        return stash[reactPropsKey];
-    }
-    const found = Object.keys(stash).find((key) => key.startsWith(REACT_PROPS));
-    if (found === undefined) {
-        return undefined;
-    }
-    reactPropsKey = found;
-    return stash[found];
-};
-const audited = new WeakSet();
-const REMOVED = new Set(['onActiveChange', 'onCheckedChange', 'onOpenChange', 'onValueChange']);
-const auditReactProps = (host, props) => {
-    if (audited.has(host)) {
-        return;
-    }
-    audited.add(host);
-    const tag = host instanceof Element ? `<${host.localName}>` : 'A Helix element';
-    for (const key of Object.keys(props)) {
-        if (key.startsWith('on:')) {
-            console.warn(`${tag} was given \`${key}\`, which is Solid's syntax. React binds the name after \`on\` ` +
-                `verbatim, so this listens for an event called \`${key.slice(2)}\`. Write \`on${key.slice(3)}\`.`);
-            continue;
-        }
-        if (REMOVED.has(key)) {
-            console.warn(`${tag} was given \`${key}\`, which was removed. It never worked from JSX, because React ` +
-                `binds any \`on\` prop as an event of that name. Listen for the element's change event instead.`);
-            continue;
-        }
-        if (!key.startsWith('on') || !key.includes('-')) {
-            continue;
-        }
-        const name = key.slice(2);
-        if (!helixEventNames.has(name)) {
-            console.warn(`${tag} was given \`${key}\`, and nothing dispatches \`${name}\`. TypeScript cannot ` +
-                `check a hyphenated JSX prop, so this is the only place it shows up.`);
-            continue;
-        }
-        const mine = host instanceof Element ? eventsForTag(host.localName) : undefined;
-        if (mine && !mine.has(name)) {
-            console.warn(`${tag} was given \`${key}\`, but it dispatches ${[...mine].map((one) => `\`${one}\``).join(', ')}. ` +
-                `\`${name}\` is sent by a different element, and React only wires an \`on\` prop on the ` +
-                'element that dispatches, so this handler will never run. Put it on that element.');
-        }
-    }
-};
-const REACT_WIRES = new Set(['scroll', 'scrollend']);
-const reactPropFor = (event) => {
-    if (event.type.includes('-')) {
-        return `on${event.type}`;
-    }
-    if (event.bubbles || REACT_WIRES.has(event.type)) {
-        return undefined;
-    }
-    return `on${event.type.charAt(0).toUpperCase()}${event.type.slice(1)}`;
-};
-const bindReactHandler = (host, event) => {
-    const props = reactPropsOf(host);
-    if (props === undefined) {
-        return;
-    }
-    auditReactProps(host, props);
-    const key = reactPropFor(event);
-    const handler = key === undefined ? undefined : props[key];
-    if (typeof handler === 'function') {
-        host.addEventListener(event.type, handler);
-    }
-};
-const applyReactProperties = (host) => {
-    const props = reactPropsOf(host);
-    if (props === undefined) {
-        return false;
-    }
-    const target = host;
-    for (const name of host.constructor.elementProperties.keys()) {
-        if (typeof name !== 'string' || !Object.hasOwn(props, name)) {
-            continue;
-        }
-        const value = props[name];
-        if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
-            continue;
-        }
-        if (target[name] !== value) {
-            target[name] = value;
-        }
-    }
-    return true;
-};
 export class HelixElement extends LitElement {
     static { this.tier = 'helix-headless-'; }
     tag(name) {
         return unsafeStatic(`${this.constructor.tier}${name}`);
     }
+    partNamed(name) {
+        const root = this.renderRoot;
+        return typeof root?.querySelector === 'function' ? root.querySelector(`[part="${name}"]`) : null;
+    }
     toggleState(name, on) {
         if ('states' in this.internals) {
             this.internals.states[on ? 'add' : 'delete'](name);