@fusion.dev/helix-core 0.146.0 → 0.147.0

package/dist/utils/load-more/load-more.d.ts

@@ -0,0 +1,25 @@
+/** Where a scrolling set stands, for the question of whether to ask for more. */
+export interface EndInSight {
+    /** The length the set last asked for more at, or `-1` where it never has. */
+    askedAt: number;
+    /** The set's length now, which the answer is kept for. */
+    count: number;
+    /** How far below the bottom of the box the set goes, in pixels. */
+    remaining: number;
+    /** The box's own height, in pixels: one screen. */
+    screen: number;
+}
+/**
+ * Whether a reader has come within one screen of the end of a set, and the
+ * set has not already asked for more at this length: React Aria's
+ * `onLoadMore` rule.
+ *
+ * **Once for each length**, so a scroll that goes on asks again only after the
+ * next page arrived and the length moved. False while the box has no height or
+ * the set no items, so a list that has not been laid out asks for nothing.
+ * The caller keeps `askedAt`, setting it to `count` when this answers true.
+ *
+ * Listbox asks this of its own scroll, and `VirtualizeController.endInSight`
+ * of the rows it lays out, so the two lists ask on the same terms.
+ */
+export declare const endInSight: ({ askedAt, count, remaining, screen }: EndInSight) => boolean;

package/dist/utils/load-more/load-more.js

@@ -0,0 +1 @@
+export const endInSight = ({ askedAt, count, remaining, screen }) => count > 0 && screen > 0 && askedAt !== count && remaining <= screen;

package/dist/utils/locale-of/locale-of.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The locale an element speaks: `own`, the element's own `locale` property,
+ * where one is set, and otherwise the `lang` of the nearest element with one,
+ * read out through any shadow root the element is drawn in.
+ *
+ * **The page's language is the default a reader expects.** A date picker on a
+ * page written `lang="de"` that names its months in English and starts its
+ * weeks on Sunday is a widget that ignored the one place the page said what
+ * language it is in; Shoelace and Web Awesome read the same attribute.
+ * `lang=""` is the page saying it does not know, and answers empty.
+ *
+ * Empty where nothing says, which every `Intl` call here takes as the
+ * runtime's own locale, and empty for a bare language the runtime already
+ * speaks (see `usable`). Read when asked rather than watched, so a page that
+ * changes its `lang` is answered in the new one on the element's next render.
+ * A server shim with no `closest` answers `own`, or empty.
+ */
+export declare const localeOf: (element: Element, own?: string) => string;

package/dist/utils/locale-of/locale-of.js

@@ -0,0 +1,26 @@
+let runtime;
+const usable = (lang) => {
+    try {
+        const asked = new Intl.Locale(lang);
+        runtime ??= new Intl.Locale(new Intl.DateTimeFormat().resolvedOptions().locale);
+        return asked.region === undefined && asked.language === runtime.language ? '' : asked.toString();
+    }
+    catch {
+        return '';
+    }
+};
+export const localeOf = (element, own = '') => {
+    if (own) {
+        return own;
+    }
+    let from = element;
+    while (from && typeof from.closest === 'function') {
+        const found = from.closest('[lang]');
+        if (found) {
+            return usable(found.getAttribute('lang') ?? '');
+        }
+        const root = from.getRootNode?.();
+        from = root?.host ?? null;
+    }
+    return '';
+};

package/dist/utils/nearest/nearest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The value in `values` nearest `target`, the first of two at the same
+ * distance, or `undefined` for none.
+ *
+ * Drawer's `snapTo` and Rating's reading of a score between its steps each
+ * wrote this loop. Given in ascending order, a target halfway between two
+ * goes to the lower, which is the rule both kept.
+ */
+export declare const nearest: (values: Iterable<number>, target: number) => number | undefined;

package/dist/utils/nearest/nearest.js

@@ -0,0 +1,9 @@
+export const nearest = (values, target) => {
+    let found;
+    for (const one of values) {
+        if (found === undefined || Math.abs(one - target) < Math.abs(found - target)) {
+            found = one;
+        }
+    }
+    return found;
+};

package/dist/utils/number-format/number-format.d.ts

@@ -9,6 +9,15 @@
  */
 /** Writes a number in a locale with `Intl.NumberFormat` options. */
 export declare const formatNumber: (value: number, locale?: string, options?: Intl.NumberFormatOptions) => string;
+/**
+ * A reading in words: `value` written with `options` where they say another
+ * style, and otherwise `share`, from 0 to 1, as a percentage, whole unless
+ * `options` say more.
+ *
+ * Meter and Progress each wrote this, with the value each holds to its range
+ * and the share of it that is filled.
+ */
+export declare const readingText: (value: number, share: number, locale?: string, options?: Intl.NumberFormatOptions) => string;
 /**
  * Reads a number written in a locale with the same options it is shown with,
  * or `null` where the text is no number.

package/dist/utils/number-format/number-format.js

@@ -9,6 +9,10 @@ const formatter = (locale, options) => {
     return found;
 };
 export const formatNumber = (value, locale = '', options) => formatter(locale, options).format(value);
+const WHOLE_PERCENT = { maximumFractionDigits: 0, style: 'percent' };
+export const readingText = (value, share, locale = '', options) => options && options.style !== 'percent'
+    ? formatNumber(value, locale, options)
+    : formatNumber(share, locale, options ?? WHOLE_PERCENT);
 const grouped = (text, separator, decimal) => {
     const whole = (text.split(decimal)[0] ?? '').replace(/^[+-]/u, '');
     return new RegExp(`^\\d{1,3}(${literal(separator)}\\d{3})+$`, 'u').test(whole);

package/dist/utils/own-rule/own-rule.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A page's own rule for a field's value: a message, a list of them, or `true`,
+ * `null` or nothing to accept the value. Input's and Textarea's `validate`.
+ */
+export type OwnRule = (value: string) => string | string[] | true | null | undefined;
+/**
+ * Applies a page's own rule after the native verdict was copied, as React
+ * Aria's TextField `validate` does: only while the browser finds nothing
+ * wrong, so a required empty field says the browser's sentence first. A list
+ * of messages is joined with spaces, and the message is a `customError`
+ * anchored at the control, so the bubble points at the text.
+ *
+ * A function rather than a member of `MixinField`, so only the fields that
+ * take `validate` carry it.
+ */
+export declare const applyOwnRule: (internals: ElementInternals, control: HTMLInputElement | HTMLTextAreaElement, rule: OwnRule | undefined, value: string) => void;

package/dist/utils/own-rule/own-rule.js

@@ -0,0 +1,7 @@
+export const applyOwnRule = (internals, control, rule, value) => {
+    const own = control.validity.valid ? rule?.(value) : undefined;
+    const message = Array.isArray(own) ? own.join(' ') : typeof own === 'string' ? own : '';
+    if (message !== '') {
+        internals.setValidity({ customError: true }, message, control);
+    }
+};

package/dist/utils/platform/platform.d.ts

@@ -21,3 +21,11 @@ export declare const appleTouch: (platform: Platform | undefined) => boolean;
  * `mod` as the key it names.
  */
 export declare const onApple: (platform?: Platform | undefined) => boolean;
+/**
+ * Whether the browser runs on Android, where TalkBack reads no `aria-sort`.
+ *
+ * React Aria's table header describes its sort order in words there for the
+ * same reason, so a reader who cannot hear the state still hears which way a
+ * column is sorted. From the user agent; `false` on a server.
+ */
+export declare const onAndroid: (platform?: Platform | undefined) => boolean;

package/dist/utils/platform/platform.js

@@ -9,3 +9,4 @@ export const appleTouch = (platform) => {
     return platform.platform === 'MacIntel' && (platform.maxTouchPoints ?? 0) > 1;
 };
 export const onApple = (platform = typeof navigator === 'undefined' ? undefined : navigator) => platform !== undefined && /mac|iphone|ipad|ipod/i.test(platform.userAgent ?? '');
+export const onAndroid = (platform = typeof navigator === 'undefined' ? undefined : navigator) => platform !== undefined && /android/i.test(platform.userAgent ?? '');

package/dist/utils/read-series/read-series.d.ts

@@ -136,3 +136,17 @@ export declare const readRows: (table: Element) => Row[];
  * name is written, in `lines`, `hidden-series` and `hide()` alike.
  */
 export declare const seriesKey: (name: string) => string;
+/** Where the highest and the lowest readings are, by place, or none. */
+export interface Extremes {
+    /** The place of the highest reading, the first where several tie. */
+    high?: number;
+    /** The place of the lowest reading, the first where several tie. */
+    low?: number;
+}
+/**
+ * Where the highest and the lowest readings stand. A blank slot is passed
+ * over, and a list with nothing in it has neither.
+ *
+ * Sparkline's overview and Heatmap's busiest place each looked for these.
+ */
+export declare const extremesOf: (slots: readonly (number | undefined)[]) => Extremes;

package/dist/utils/read-series/read-series.js

@@ -139,3 +139,18 @@ export const readRows = (table) => {
     return [...(element.tBodies[0]?.rows ?? [])].map((one) => row(one.cells[0], [...one.cells].slice(1), names));
 };
 export const seriesKey = (name) => name.trim().toLowerCase();
+export const extremesOf = (slots) => {
+    const found = {};
+    slots.forEach((value, at) => {
+        if (value === undefined) {
+            return;
+        }
+        if (found.high === undefined || value > slots[found.high]) {
+            found.high = at;
+        }
+        if (found.low === undefined || value < slots[found.low]) {
+            found.low = at;
+        }
+    });
+    return found;
+};

package/dist/utils/relative-time/relative-time.d.ts

@@ -1,3 +1,11 @@
+/**
+ * How long each unit lasts, in milliseconds, largest last. `elapsedTime`
+ * reads its minute, hour and day from here.
+ */
+export declare const UNITS: Array<{
+    ms: number;
+    unit: Intl.RelativeTimeFormatUnit;
+}>;
 /** What one timestamp reads as, and when that stops being true. */
 export interface Relative {
     /**

package/dist/utils/relative-time/relative-time.js

@@ -1,5 +1,5 @@
 const held = new Map();
-const UNITS = [
+export const UNITS = [
     { ms: 1000, unit: 'second' },
     { ms: 60_000, unit: 'minute' },
     { ms: 3_600_000, unit: 'hour' },
@@ -25,7 +25,10 @@ export const relativeTime = (locale, options = {}) => {
         }
         const size = Math.abs(elapsed);
         if (size < 60_000) {
-            return { next: Math.max(1000, 60_000 - size), text: found.format(0, 'second') };
+            return {
+                next: Math.max(1000, 60_000 - size),
+                text: found.format(elapsed > 0 ? 0 : -0, 'second'),
+            };
         }
         let chosen = UNITS[1];
         for (const unit of UNITS) {

package/dist/utils/report-render/report-render.js

@@ -1,18 +1,6 @@
+import { callListener } from '../call-listener/call-listener.js';
 export const RENDER_SLOT = Symbol.for('fusion.dev/helix/render');
 export const measuring = () => typeof globalThis[RENDER_SLOT] === 'function';
-let told = false;
 export const reportRender = (element, start, duration) => {
-    const listener = globalThis[RENDER_SLOT];
-    if (typeof listener !== 'function') {
-        return;
-    }
-    try {
-        listener(element, { duration, start });
-    }
-    catch (error) {
-        if (!told) {
-            told = true;
-            console.error('helix: a render listener threw, and the element rendered as usual. Later failures are not printed.', error);
-        }
-    }
+    callListener(RENDER_SLOT, 'render', 'the element rendered as usual', element, { duration, start });
 };

package/dist/utils/report-runtime/report-runtime.d.ts

@@ -18,8 +18,10 @@
  */
 /** What went wrong, stable across versions, so it can be counted. */
 export type RuntimeKind = 
+/** A deprecated property, attribute or slot was used; the message names what replaces it. */
+'deprecated'
 /** Another class asked for a tag that is already registered: two copies of Helix. */
-'duplicate-registration'
+ | 'duplicate-registration'
 /** The browser refused fullscreen, usually for a frame without the permission. */
  | 'fullscreen-refused'
 /** A rating's `min` is no score between 0 and its `max`. */
@@ -41,6 +43,8 @@ export type RuntimeKind =
  | 'missing-row-key'
 /** A stencil names parts the shape does not have. */
  | 'missing-stencil-parts'
+/** A chart, a legend or a sparkline names no table with `for`. Development builds only. */
+ | 'missing-table'
 /** A Skip Link's `href` names no element in its tree, so a press moves focus nowhere. */
  | 'missing-target'
 /** A tooltip's `for` names no element in its own tree. */

package/dist/utils/report-runtime/report-runtime.js

@@ -1,7 +1,7 @@
+import { callListener } from '../call-listener/call-listener.js';
 export const RUNTIME_SLOT = Symbol.for('fusion.dev/helix/runtime');
 export const RUNTIME_LOG = Symbol.for('fusion.dev/helix/runtime-log');
 const KEPT = 200;
-let told = false;
 export const reportRuntime = (event) => {
     const store = globalThis;
     const log = Array.isArray(store[RUNTIME_LOG]) ? store[RUNTIME_LOG] : [];
@@ -9,19 +9,7 @@ export const reportRuntime = (event) => {
         log.push(event);
     }
     store[RUNTIME_LOG] = log;
-    let quiet = false;
-    const listener = store[RUNTIME_SLOT];
-    if (typeof listener === 'function') {
-        try {
-            quiet = listener(event) === true;
-        }
-        catch (error) {
-            if (!told) {
-                told = true;
-                console.error('helix: a runtime listener threw, and the warning is printed here. Later failures are not printed.', error);
-            }
-        }
-    }
+    const quiet = callListener(RUNTIME_SLOT, 'runtime', 'the warning is printed here', event) === true;
     if (quiet) {
         return;
     }

package/dist/utils/report-usage/report-usage.js

@@ -1,4 +1,5 @@
 import { VERSION } from '../../version.js';
+import { callListener } from '../call-listener/call-listener.js';
 export const USAGE_SLOT = Symbol.for('fusion.dev/helix/usage');
 export const VERSIONS_SLOT = Symbol.for('fusion.dev/helix/versions');
 export const noteVersion = () => {
@@ -9,19 +10,6 @@ export const noteVersion = () => {
     }
     store[VERSIONS_SLOT] = listed;
 };
-let told = false;
 export const reportUsage = (element) => {
-    const listener = globalThis[USAGE_SLOT];
-    if (typeof listener !== 'function') {
-        return;
-    }
-    try {
-        listener(element);
-    }
-    catch (error) {
-        if (!told) {
-            told = true;
-            console.error('helix: a usage listener threw, and the element rendered as usual. Later failures are not printed.', error);
-        }
-    }
+    callListener(USAGE_SLOT, 'usage', 'the element rendered as usual', element);
 };

package/dist/utils/scroll-item-into-view/scroll-item-into-view.d.ts

@@ -7,4 +7,37 @@ export interface ScrollItemOptions {
     /** Whether to animate. Ignored where the reader asked for less motion. */
     smooth?: boolean;
 }
+/**
+ * The nearest ancestor that actually scrolls, crossing shadow boundaries.
+ *
+ * **Not `item.offsetParent`**, which is the nearest *positioned* ancestor and
+ * has nothing whatever to do with overflow. The two coincide often enough to
+ * look right, because a scroller frequently is positioned, and they come apart
+ * exactly where it matters: put anything `position: relative` between the item
+ * and the box that scrolls, and the util scrolls the thing in between, which
+ * does not scroll, and reports nothing.
+ *
+ * The walk crosses shadow boundaries through the host, because the item is
+ * almost always in one and `parentElement` is null at the root. Without that
+ * step, a component whose scroller is its own `[part]` would find nothing.
+ *
+ * It stops before the document. Scrolling the page is the one thing this whole
+ * util exists not to do, so finding nothing inside the component and returning
+ * null is the honest answer: the caller no-ops rather than taking the address
+ * bar with it.
+ */
+export declare const scrollingAncestor: (item: HTMLElement, options?: ScrollerOptions) => HTMLElement | null;
+/** Where `scrollingAncestor` looks, and what it takes for a scroller. */
+export interface ScrollerOptions {
+    /** The axis whose overflow counts, or either where absent. */
+    readonly axis?: 'x' | 'y';
+    /**
+     * Only a box whose content is larger than it, along `axis`: one that can
+     * scroll now, rather than one that would once it fills. Outline asks this of
+     * the box its links and its sections scroll in.
+     */
+    readonly overflowing?: boolean;
+    /** Where the walk stops, unread: the document's body where absent. */
+    readonly stop?: Element | null;
+}
 export declare const scrollItemIntoView: (item: HTMLElement, options?: ScrollItemOptions) => void;

package/dist/utils/scroll-item-into-view/scroll-item-into-view.js

@@ -1,15 +1,25 @@
-const scrollingAncestor = (item) => {
-    const stop = item.ownerDocument.body;
+export const scrollingAncestor = (item, options = {}) => {
+    const { axis, overflowing = false, stop = item.ownerDocument.body } = options;
     let node = climb(item);
     while (node && node !== stop) {
         const style = getComputedStyle(node);
-        if (/\b(auto|scroll|overlay)\b/.test(`${style.overflowX} ${style.overflowY}`)) {
+        const overflow = axis === 'x'
+            ? style.overflowX
+            : axis === 'y'
+                ? style.overflowY
+                : `${style.overflowX} ${style.overflowY}`;
+        if (/\b(auto|scroll|overlay)\b/.test(overflow) && (!overflowing || overflows(node, axis))) {
             return node;
         }
         node = climb(node);
     }
     return null;
 };
+const overflows = (node, axis) => {
+    const tall = node.scrollHeight > node.clientHeight;
+    const wide = node.scrollWidth > node.clientWidth;
+    return axis === 'x' ? wide : axis === 'y' ? tall : tall || wide;
+};
 const climb = (node) => {
     if (node.parentElement) {
         return node.parentElement;

package/dist/utils/slotted-glyph/slotted-glyph.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A glyph a consumer slots once and a component draws in many places: the
+ * marks of a rating, the remove icon on every row of a file list.
+ *
+ * A slotted element can be assigned to one slot only, so a component that
+ * draws it in several places draws copies. **One copy per place, kept**, so a
+ * render does not make them again: a drag renders on every pointer move, and
+ * handing Lit a fresh node each time swaps every copy on every frame.
+ */
+export declare class SlottedGlyph {
+    /** The copies made so far, by the place each is drawn in. */
+    private readonly copies;
+    /** The element slotted last, which every copy is made from. */
+    private source;
+    /** Whether a glyph is slotted, so the component draws copies of it. */
+    get slotted(): boolean;
+    /**
+     * Reads the slot after a `slotchange`: the first element assigned to it,
+     * through any slot it is forwarded by. The copies made of the last one go.
+     */
+    read(slot: HTMLSlotElement): void;
+    /**
+     * Takes `source` as the glyph, or none, as `read` does from a slot: the
+     * copies made of the last one go. For the first render, which reads the
+     * host's children before any `slotchange` answers.
+     */
+    take(source: Element | undefined): void;
+    /**
+     * The copy for one place, made the first time it is asked for and the same
+     * node after, or `undefined` while nothing is slotted.
+     */
+    copyFor(place: number | string): Node | undefined;
+}

package/dist/utils/slotted-glyph/slotted-glyph.js

@@ -0,0 +1,27 @@
+export class SlottedGlyph {
+    constructor() {
+        this.copies = new Map();
+    }
+    get slotted() {
+        return this.source !== undefined;
+    }
+    read(slot) {
+        this.take(slot.assignedElements({ flatten: true })[0]);
+    }
+    take(source) {
+        this.source = source;
+        this.copies.clear();
+    }
+    copyFor(place) {
+        if (!this.source) {
+            return undefined;
+        }
+        const key = String(place);
+        let copy = this.copies.get(key);
+        if (!copy) {
+            copy = this.source.cloneNode(true);
+            this.copies.set(key, copy);
+        }
+        return copy;
+    }
+}

package/dist/utils/typeahead/typeahead.d.ts

@@ -65,3 +65,11 @@ export interface TypeaheadBy<Item> {
  * `TypeaheadBy`.
  */
 export declare const typeaheadBy: <Item>(words: (item: Item) => string) => TypeaheadBy<Item>;
+/**
+ * Turns on typeahead for a set whose items carry their own `words`, as List's
+ * rows, Tag Group's tags and Drilldown's items do. An item with none is
+ * passed over.
+ */
+export declare const typeaheadByWords: () => TypeaheadBy<{
+    readonly words?: string;
+}>;

package/dist/utils/typeahead/typeahead.js

@@ -34,3 +34,4 @@ export const typeaheadBy = (words) => ({
     search: new Typeahead(),
     words,
 });
+export const typeaheadByWords = () => typeaheadBy((item) => item.words ?? '');

package/dist/utils/verdict-flags/verdict-flags.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What a picker field finds wrong: a message, reported as `badInput`, or the
+ * validity flag to set and its message. Empty means nothing is wrong.
+ */
+export type PickerVerdict = string | readonly [flag: keyof ValidityStateFlags, message: string];
+/**
+ * A verdict as the flags and the message `setValidity` takes, or `null` where
+ * there is nothing wrong.
+ *
+ * Shared by `MixinPickerField` and `MixinSegmentedField`, the two shapes a
+ * date, time or color field takes, which report the same verdicts.
+ */
+export declare const verdictFlags: (verdict: PickerVerdict) => [flags: ValidityStateFlags, message: string] | null;

package/dist/utils/verdict-flags/verdict-flags.js

@@ -0,0 +1,6 @@
+export const verdictFlags = (verdict) => {
+    if (typeof verdict === 'string') {
+        return verdict === '' ? null : [{ badInput: true }, verdict];
+    }
+    return [{ [verdict[0]]: true }, verdict[1]];
+};

package/dist/utils/written-list/written-list.d.ts

@@ -71,6 +71,37 @@ export declare const toggleValue: (list: readonly string[], value: string, order
  * follows.
  */
 export declare const toggleEvery: (chosen: Iterable<string>, values: readonly string[], order?: readonly string[]) => string[];
+/**
+ * What a select-all box shows for `values`: checked when every one is
+ * chosen, mixed when some are, and neither for none or an empty set.
+ *
+ * Checkbox Group's select-all box and the header boxes of Table and Data
+ * Table each worked this out. A set that does not count its disabled boxes
+ * passes only the enabled values.
+ */
+export declare const everyState: (chosen: Iterable<string>, values: readonly string[]) => {
+    checked: boolean;
+    indeterminate: boolean;
+};
+/**
+ * `keys` in the order the rows are, which is `order`: the keys of the whole
+ * set. A key the set does not hold, a selected row a search has hidden say,
+ * keeps its place after them in the order it was given.
+ *
+ * So a selection reads in row order whatever order its rows were chosen in:
+ * Data Table's, and Table's and Virtual List's, which wrote it in press order
+ * or wrote this again.
+ */
+export declare const inRowOrder: (keys: Iterable<string>, order: readonly string[]) => string[];
+/**
+ * Where a Shift range runs from, as an index into `keys`: the row last chosen
+ * while it is among them, and otherwise the row the reader is on, `from`,
+ * which becomes the one to run from.
+ */
+export declare const anchorAt: (keys: readonly string[], anchorKey: string | undefined, from: number) => {
+    anchor: number;
+    anchorKey: string | undefined;
+};
 /** How many items a set lets a reader select: Tag Group's and List's `selection-mode`. */
 export type SelectionMode = 'multiple' | 'none' | 'single';
 /**

package/dist/utils/written-list/written-list.js

@@ -25,6 +25,22 @@ export const toggleEvery = (chosen, values, order) => {
     }
     return order ? order.filter((value) => next.has(value)) : [...next];
 };
+export const everyState = (chosen, values) => {
+    const held = new Set(chosen);
+    const count = values.filter((value) => held.has(value)).length;
+    const checked = values.length > 0 && count === values.length;
+    return { checked, indeterminate: count > 0 && !checked };
+};
+export const inRowOrder = (keys, order) => {
+    const wanted = new Set(keys);
+    const placed = order.filter((key) => wanted.has(key));
+    const seen = new Set(placed);
+    return [...placed, ...[...wanted].filter((key) => !seen.has(key))];
+};
+export const anchorAt = (keys, anchorKey, from) => {
+    const anchor = anchorKey === undefined ? -1 : keys.indexOf(anchorKey);
+    return anchor < 0 ? { anchor: from, anchorKey: keys[from] } : { anchor, anchorKey };
+};
 export const pressedValue = (mode, value, pressed) => {
     const now = commaList(value);
     if (mode === 'single') {

package/dist/version.d.ts

@@ -6,4 +6,4 @@
  * release, so the two never disagree; a spec beside this holds them to it.
  * Nothing else in the running code knows which release it is.
  */
-export declare const VERSION = "0.146.0";
+export declare const VERSION = "0.147.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.146.0';
+export const VERSION = '0.147.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fusion.dev/helix-core",
   "description": "Helix element primitives: base classes, mixins, decorators, utilities.",
-  "version": "0.146.0",
+  "version": "0.147.0",
   "license": "MIT",
   "author": "Ross Sheppard <ross.sheppard@fusion.dev>",
   "repository": {
@@ -34,11 +34,11 @@
   "bugs": "https://github.com/project-fusion/fusion/issues",
   "dependencies": {
     "@floating-ui/dom": "^1.8.0",
-    "@fusion.dev/helix-icons": "0.146.0"
+    "@fusion.dev/helix-icons": "0.147.0"
   },
   "devDependencies": {
-    "@fusion.dev/helix-cem": "0.146.0",
-    "@fusion.dev/helix-testing": "0.146.0",
+    "@fusion.dev/helix-cem": "0.147.0",
+    "@fusion.dev/helix-testing": "0.147.0",
     "@lit-labs/ssr": "^4.1.0",
     "lit": "^3.2.1"
   },
@@ -54,6 +54,17 @@
       "development": "./dist/utils/audit-name/audit-name.js",
       "helix-development": "./dist/utils/audit-name/audit-name.js",
       "default": "./dist/utils/audit-name/audit-name-off.js"
+    },
+    "#audit-source": {
+      "helix-source": {
+        "development": "./src/utils/audit-source/audit-source.ts",
+        "helix-development": "./src/utils/audit-source/audit-source.ts",
+        "default": "./src/utils/audit-source/audit-source-off.ts"
+      },
+      "types": "./dist/utils/audit-source/audit-source.d.ts",
+      "development": "./dist/utils/audit-source/audit-source.js",
+      "helix-development": "./dist/utils/audit-source/audit-source.js",
+      "default": "./dist/utils/audit-source/audit-source-off.js"
     }
   },
   "keywords": [