@fusion.dev/helix-core 0.148.0 → 0.149.1

package/dist/mixins/mixin-viewport/mixin-viewport.js

@@ -8,9 +8,9 @@ import { html, nothing } from 'lit';
 import { property, state } from 'lit/decorators.js';
 import { FullscreenController } from '../../controllers/fullscreen-controller/fullscreen-controller.js';
 import { IdleController } from '../../controllers/idle-controller/idle-controller.js';
-import { fillTemplate } from '../../utils/fill-template/fill-template.js';
 import { inlineStep } from '../../utils/inline-step/inline-step.js';
 import { isRtl } from '../../utils/is-rtl/is-rtl.js';
+import { formatWords, words } from '../../words/words.js';
 const HINT_SHOWS = 1600;
 export const MixinViewport = (Base) => {
     class Viewport extends Base {
@@ -38,11 +38,10 @@ export const MixinViewport = (Base) => {
             this.handleGestureWheel = (event) => {
                 if (this.gestures === 'cooperative' && !(event.ctrlKey || event.metaKey)) {
                     const mac = typeof navigator !== 'undefined' && navigator.userAgent.includes('Mac');
-                    const words = this.wheelHintLabel ?? this.restingGestureLabels.wheel;
-                    this.showHint(fillTemplate(words, { key: mac ? '⌘' : 'Ctrl' }), event);
+                    this.showHint(formatWords(this, 'wheelHintLabel', { key: mac ? '⌘' : 'Ctrl' }), event);
                 }
                 else if (this.gestures === 'activate' && !this.gesturesTaken) {
-                    this.showHint(this.activateHintLabel ?? this.restingGestureLabels.activate, event);
+                    this.showHint(this.activateHintLabel, event);
                 }
             };
             this.handleGestureTouch = (event) => {
@@ -51,10 +50,10 @@ export const MixinViewport = (Base) => {
                     return;
                 }
                 if (this.gestures === 'cooperative') {
-                    this.showHint(this.twoFingerHintLabel ?? this.restingGestureLabels.twoFinger, finger);
+                    this.showHint(this.twoFingerHintLabel, finger);
                 }
                 else if (this.gestures === 'activate' && !this.gesturesTaken) {
-                    this.showHint(this.activateHintLabel ?? this.restingGestureLabels.activate, finger);
+                    this.showHint(this.activateHintLabel, finger);
                 }
             };
             this.handleTake = (event) => {
@@ -133,17 +132,7 @@ export const MixinViewport = (Base) => {
                 }
             };
         }
-        get restingControlsLabel() {
-            return 'View controls';
-        }
-        get restingGestureLabels() {
-            return {
-                activate: 'Press to use it',
-                twoFinger: 'Use two fingers to move it',
-                using: 'In use. Press Escape to scroll the page again.',
-                wheel: 'Use {key} and scroll to zoom',
-            };
-        }
+        static { this.words = ''; }
         get gestureMode() {
             if (this.gestures === 'cooperative') {
                 return 'cooperative';
@@ -215,7 +204,7 @@ export const MixinViewport = (Base) => {
           ?hidden=${this.hint === ''}
           style=${at ? `--_viewport-hint-x: ${(at.x * 100).toFixed(2)}%; --_viewport-hint-y: ${(at.y * 100).toFixed(2)}%` : nothing}
         >${this.hint}</div>
-        <div part="gesture-status" aria-hidden="true" ?hidden=${!this.gesturesTaken}>${this.usingLabel ?? this.restingGestureLabels.using}</div>`;
+        <div part="gesture-status" aria-hidden="true" ?hidden=${!this.gesturesTaken}>${this.usingLabel}</div>`;
         }
         panEvent(_detail) {
             throw new Error(`<${this.localName}> composes MixinViewport and must implement panEvent(), the surface naming no event of its own.`);
@@ -287,7 +276,7 @@ export const MixinViewport = (Base) => {
                 return nothing;
             }
             const [up, start, end, down] = ['up', 'start', 'end', 'down'].map((way) => this.panGlyph(way));
-            return html `<div part="controls" role="group" aria-label=${this.controlsLabel ?? this.restingControlsLabel}>
+            return html `<div part="controls" role="group" aria-label=${this.controlsLabel}>
         ${pan
                 ? html `<button part="pan-up" aria-label=${this.panLabel('up')} type="button" @click=${() => this.pan('up')}>
                   <slot name="pan-up-icon">${up}</slot>
@@ -325,19 +314,14 @@ export const MixinViewport = (Base) => {
       </div>`;
         }
     }
-    __decorate([
-        property({ attribute: 'activate-hint-label' })
-    ], Viewport.prototype, "activateHintLabel", void 0);
     __decorate([
         property({ reflect: true })
     ], Viewport.prototype, "controls", void 0);
-    __decorate([
-        property({ attribute: 'controls-label' })
-    ], Viewport.prototype, "controlsLabel", void 0);
     __decorate([
         property({ attribute: 'controls-placement', reflect: true })
     ], Viewport.prototype, "controlsPlacement", void 0);
     __decorate([
+        words,
         property({ attribute: 'fullscreen-label' })
     ], Viewport.prototype, "fullscreenLabel", void 0);
     __decorate([
@@ -347,30 +331,26 @@ export const MixinViewport = (Base) => {
         property({ attribute: 'idle-delay', type: Number })
     ], Viewport.prototype, "idleDelay", void 0);
     __decorate([
+        words,
         property({ attribute: 'pan-down-label' })
     ], Viewport.prototype, "panDownLabel", void 0);
     __decorate([
+        words,
         property({ attribute: 'pan-left-label' })
     ], Viewport.prototype, "panLeftLabel", void 0);
     __decorate([
+        words,
         property({ attribute: 'pan-right-label' })
     ], Viewport.prototype, "panRightLabel", void 0);
     __decorate([
         property({ attribute: 'pan-step', type: Number })
     ], Viewport.prototype, "panStep", void 0);
     __decorate([
+        words,
         property({ attribute: 'pan-up-label' })
     ], Viewport.prototype, "panUpLabel", void 0);
     __decorate([
-        property({ attribute: 'two-finger-hint-label' })
-    ], Viewport.prototype, "twoFingerHintLabel", void 0);
-    __decorate([
-        property({ attribute: 'using-label' })
-    ], Viewport.prototype, "usingLabel", void 0);
-    __decorate([
-        property({ attribute: 'wheel-hint-label' })
-    ], Viewport.prototype, "wheelHintLabel", void 0);
-    __decorate([
+        words,
         property({ attribute: 'zoom-in-label' })
     ], Viewport.prototype, "zoomInLabel", void 0);
     __decorate([
@@ -389,6 +369,7 @@ export const MixinViewport = (Base) => {
         state()
     ], Viewport.prototype, "hintAt", void 0);
     __decorate([
+        words,
         property({ attribute: 'zoom-out-label' })
     ], Viewport.prototype, "zoomOutLabel", void 0);
     return Viewport;

package/dist/utils/calendar/calendar.d.ts

@@ -16,6 +16,33 @@ export declare const localToday: (now?: Date) => string;
  * neither, as Firefox does not, or where the tag cannot be read.
  */
 export declare const weekStartOf: (locale: string) => number;
+/**
+ * The calendars a date family draws and writes: those whose months are the
+ * Gregorian months, so a grid of Gregorian days is one of their months.
+ *
+ * `buddhist` is Thailand's (2569 for 2026), `japanese` the Japanese eras
+ * (Reiwa 8), and `roc` Taiwan's Minguo years (115). They differ from
+ * `gregory` in the year alone, and `iso8601` in the order the parts are
+ * written.
+ */
+export type DateCalendar = 'buddhist' | 'gregory' | 'iso8601' | 'japanese' | 'roc';
+/**
+ * The language tag a date family formats with: `locale`, with the calendar it
+ * writes dates in.
+ *
+ * That is `calendar` where it is one of the five `DateCalendar` names, then
+ * the locale's own calendar where its months are the Gregorian months, then
+ * `gregory`. **A calendar with months of its own, such as `persian` for `fa-IR`
+ * or `islamic-umalqura` for `ar-SA` in some engines, is written as `gregory`.**
+ * The arithmetic is Gregorian, so a heading in Mehr 1405 over the days of
+ * October 2026 named a month the grid did not show.
+ *
+ * `locale` unchanged where nothing moves, so a page in a Gregorian locale
+ * formats exactly as it did. Empty is the runtime's own locale. A tag `Intl`
+ * refuses throws, as every formatter given one does. Remembered per locale and
+ * calendar, since reading a locale's calendar builds a formatter.
+ */
+export declare const calendarLocale: (locale: string, calendar?: string) => string;
 /** A month as `YYYY-MM`. */
 export declare const monthOf: (date: Date) => string;
 /** A date some days away, which may be negative, at midnight UTC. */

package/dist/utils/calendar/calendar.js

@@ -15,6 +15,23 @@ export const weekStartOf = (locale) => {
         return 0;
     }
 };
+const DRAWN = ['buddhist', 'gregory', 'iso8601', 'japanese', 'roc'];
+const tagged = new Map();
+export const calendarLocale = (locale, calendar = '') => {
+    const key = `${locale} ${calendar}`;
+    let tag = tagged.get(key);
+    if (tag === undefined) {
+        const own = new Intl.DateTimeFormat(locale || undefined).resolvedOptions();
+        const wanted = DRAWN.includes(calendar)
+            ? calendar
+            : DRAWN.includes(own.calendar)
+                ? ''
+                : 'gregory';
+        tag = wanted ? `${new Intl.Locale(locale || own.locale, { calendar: wanted })}` : locale;
+        tagged.set(key, tag);
+    }
+    return tag;
+};
 export const monthOf = (date) => `${String(date.getUTCFullYear()).padStart(4, '0')}-${String(date.getUTCMonth() + 1).padStart(2, '0')}`;
 export const addDays = (date, days) => utcDate(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate() + days);
 export const sameMonth = (left, right) => left.getUTCFullYear() === right.getUTCFullYear() && left.getUTCMonth() === right.getUTCMonth();

package/dist/utils/count-label/count-label.d.ts

@@ -4,10 +4,13 @@
  *
  * **`Intl.PluralRules` picks the sentence**, because the line between "one"
  * and "other" is the language's: French says "0 résultat" where English says
- * "0 results". A language with more forms than two writes its `one` in the
- * first sentence and the rest in the second.
+ * "0 results". Each sentence is a message, so `other` can hold every form a
+ * language has, `{count, plural, one {# wynik} few {# wyniki} many {# wyników}
+ * other {# wyniku}}`, and an empty `one` leaves the choice to it.
  *
- * Data Table says how many rows a search left this way, and Listbox how many
- * options a filter left, which Combobox and Command hand down to it.
+ * Kept for the families whose singular property is still read. A family on the
+ * words registry formats its one plural message with `formatWords`. Listbox
+ * says how many options a filter left this way, which Combobox and Command
+ * hand down to it.
  */
 export declare const countLabel: (count: number, one: string, other: string, locale?: string) => string;

package/dist/utils/count-label/count-label.js

@@ -1,5 +1,2 @@
-import { fillTemplate } from '../fill-template/fill-template.js';
-import { formatNumbers } from '../format-numbers/format-numbers.js';
-export const countLabel = (count, one, other, locale = '') => fillTemplate(new Intl.PluralRules(locale || undefined).select(count) === 'one' ? one : other, {
-    count: formatNumbers(locale)(count),
-});
+import { formatMessage } from '../../words/message.js';
+export const countLabel = (count, one, other, locale = '') => formatMessage(one && new Intl.PluralRules(locale || undefined).select(count) === 'one' ? one : other, { count }, locale);

package/dist/utils/date-segments/date-segments.d.ts

@@ -26,7 +26,8 @@ export interface SegmentOptions {
  * between them, read off `Intl`'s own rendering of a sample.
  *
  * `en-US` is month, day, year with slashes; `de-DE` day, month, year with
- * dots; `ja-JP` year, month, day. A time follows the clock: a twelve hour
+ * dots; `ja-JP` year, month, day; the `iso8601` calendar year, month, day
+ * with hyphens. A time follows the clock: a twelve hour
  * locale ends with the half of the day.
  */
 export declare const segmentLayout: (kind: SegmentedKind, locale: string, options?: SegmentOptions) => SegmentSlot[];

package/dist/utils/date-segments/date-segments.js

@@ -14,6 +14,16 @@ export const segmentLayout = (kind, locale, options = {}) => {
             ...(options.seconds ? { second: '2-digit' } : {}),
             ...(options.hourCycle ? { hourCycle: options.hourCycle } : {}),
         });
+    if (kind === 'date' &&
+        (/-ca-iso8601/i.test(locale) || format.resolvedOptions().calendar === 'iso8601')) {
+        return [
+            { kind: 'year' },
+            { literal: '-' },
+            { kind: 'month' },
+            { literal: '-' },
+            { kind: 'day' },
+        ];
+    }
     const known = new Set(['day', 'dayPeriod', 'hour', 'minute', 'month', 'second', 'year']);
     const slots = [];
     for (const part of format.formatToParts(SAMPLE)) {

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

@@ -1,3 +1,8 @@
+/**
+ * The runtime's own locale: in a browser, the language its interface is set
+ * to, which is what every `Intl` call given no locale uses.
+ */
+export declare const runtimeLocale: () => string;
 /**
  * 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,

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

@@ -1,9 +1,15 @@
 let runtime;
+export const runtimeLocale = () => {
+    runtime ??= new Intl.Locale(new Intl.DateTimeFormat().resolvedOptions().locale);
+    return runtime.toString();
+};
 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();
+        runtimeLocale();
+        return asked.region === undefined && asked.language === runtime?.language
+            ? ''
+            : asked.toString();
     }
     catch {
         return '';

package/dist/utils/reorder/drag-preview.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The copy of an item a pointer drags: what the item draws, through every
+ * shadow root and slot in it, rebuilt as plain elements with the styles the
+ * browser computed for each written on it.
+ *
+ * `ReorderController` puts the copy in the host's own shadow root, in the top
+ * layer, so the page's markup is never touched and no scrolling box clips it.
+ * A copy is inert: it has no custom elements, no slots, and no attributes but
+ * a picture's, so nothing in it upgrades, takes the host's children, or joins
+ * a radio group. Pseudo-elements are not copied.
+ */
+import { nothing, type TemplateResult } from 'lit';
+/**
+ * The part a host draws for the drag preview: an empty manual popover,
+ * hidden from assistive technology, which `ReorderController` fills with a
+ * copy of the item a pointer drags and shows in the top layer. Closed, it
+ * takes no room. Drawn while `on`, which is while the host reorders.
+ */
+export declare const drawDragPreview: (on: boolean) => TemplateResult | typeof nothing;
+/** A point in the viewport, where the boxes of a copy are measured from. */
+interface Origin {
+    x: number;
+    y: number;
+}
+/**
+ * The box an element draws: its own, or the boxes of what it draws together,
+ * for an element that is `display: contents`, such as a row of a grid.
+ */
+export declare const boxOf: (element: Element) => DOMRect;
+/**
+ * A copy of what a node draws, for a drag preview, with every style the
+ * browser computed for each part written on it. The custom properties are
+ * left out, having done their work, and so are the logical properties, whose
+ * physical twins are written: two of a pair in one style do not agree on
+ * which wins.
+ *
+ * A `placed` node is put where it is with `position: absolute`, measured from
+ * `origin`, the padding box it is placed in, rather than laid out again. The
+ * root of a preview is placed in the preview, whose padding box is the root's
+ * box as `boxOf` measures it, and so is whatever a grid lays out, since a
+ * subgrid has no tracks of its own once it is copied out of its grid. An
+ * element that is `display: contents`, such as a row whose cells sit in the
+ * grid of its table, has each of its cells put where it is.
+ */
+export declare const dragPreviewOf: (node: Node, placed: boolean, origin: Origin) => Node[];
+export {};

package/dist/utils/reorder/drag-preview.js

@@ -0,0 +1,58 @@
+import { html, nothing } from 'lit';
+export const drawDragPreview = (on) => on ? html `<div part="drag-preview" popover="manual" aria-hidden="true" inert></div>` : nothing;
+const drawn = (node) => {
+    const assigned = node instanceof HTMLSlotElement ? node.assignedNodes({ flatten: true }) : [];
+    return [...(assigned.length ? assigned : (node.shadowRoot ?? node).childNodes)];
+};
+export const boxOf = (element) => {
+    if (getComputedStyle(element).display !== 'contents') {
+        return element.getBoundingClientRect();
+    }
+    let [left, top, right, bottom] = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const node of drawn(element)) {
+        const box = node instanceof Element && boxOf(node);
+        if (box && (box.width || box.height)) {
+            left = Math.min(left, box.left);
+            top = Math.min(top, box.top);
+            right = Math.max(right, box.right);
+            bottom = Math.max(bottom, box.bottom);
+        }
+    }
+    return left <= right ? new DOMRect(left, top, right - left, bottom - top) : new DOMRect();
+};
+export const dragPreviewOf = (node, placed, origin) => {
+    if (node instanceof Text) {
+        return [node.cloneNode()];
+    }
+    const style = node instanceof Element ? getComputedStyle(node) : undefined;
+    if (!style || style.display === 'none') {
+        return [];
+    }
+    const element = node;
+    const tag = element.localName;
+    const whole = /^(img|svg)$/.test(tag);
+    const copy = whole
+        ? element.cloneNode(true)
+        : document.createElement(/-|^slot$/.test(tag) ? 'div' : tag);
+    const contents = style.display === 'contents';
+    const box = element.getBoundingClientRect();
+    let written = '';
+    for (let index = 0; index < style.length; index += 1) {
+        const name = style.item(index);
+        if (!/^--|block|inline|start-|end-/.test(name)) {
+            written += `${name}:${style.getPropertyValue(name)};`;
+        }
+    }
+    copy.style.cssText =
+        placed && !contents
+            ? `${written}position:absolute;inset:auto;left:${box.left - origin.x}px;top:${box.top - origin.y}px;width:${box.width}px;height:${box.height}px;margin:0;box-sizing:border-box;grid-area:auto`
+            : written;
+    if (!whole) {
+        const inner = !contents && (placed || style.position !== 'static')
+            ? { x: box.left + element.clientLeft, y: box.top + element.clientTop }
+            : origin;
+        const grid = contents ? placed : style.display.endsWith('grid');
+        copy.append(...drawn(element).flatMap((child) => dragPreviewOf(child, grid, inner)));
+    }
+    return [copy];
+};

package/dist/utils/reorder/reorder.d.ts

@@ -0,0 +1,178 @@
+/**
+ * The state and the arithmetic of moving one item to a new place in its
+ * collection: rows of a list or a data table, or a table's columns.
+ *
+ * Pure, so every transition and every sum has a spec with no DOM.
+ * `ReorderController` holds the state, listens to the pointer and the keys, and
+ * runs the effects each change of state calls for.
+ */
+/** Which way a collection runs: rows down the block axis, columns along the inline one. */
+export type ReorderAxis = 'block' | 'inline';
+/** What holds the item: a key or a press on its grip, or a pointer dragging it. */
+export type ReorderHold = 'keyboard' | 'pointer';
+/**
+ * Where a move stands.
+ *
+ * - `idle`: nothing is held.
+ * - `pressed`: a pointer is down on a grip and has not traveled far enough to
+ *   be a drag.
+ * - `held`: an item is held, and `to` is where it would go.
+ * - `dropped` and `canceled`: the move has ended, for one step, so the
+ *   controller can run what each calls for before it settles to `idle`.
+ *
+ * `from` and `to` count from 0 in the order the items are drawn.
+ */
+export type ReorderState = {
+    phase: 'idle';
+} | {
+    from: number;
+    key: string;
+    phase: 'pressed';
+    pointer: number;
+    x: number;
+    y: number;
+} | {
+    by: ReorderHold;
+    from: number;
+    key: string;
+    phase: 'held';
+    to: number;
+} | {
+    by: ReorderHold;
+    from: number;
+    key: string;
+    phase: 'dropped';
+    to: number;
+} | {
+    by: ReorderHold;
+    key: string;
+    phase: 'canceled';
+};
+/**
+ * What can happen to a move.
+ *
+ * - `press`: a pointer went down on a grip.
+ * - `drag`: the pointer moved, and `to` is the place under it.
+ * - `release`: the pointer went up.
+ * - `pick`: a grip was pressed with a key or a click. It holds the item, or
+ *   drops the item that grip already holds.
+ * - `step`: a key moved the held item to `to`.
+ * - `target`: a click on another item dropped the held one at `to`.
+ * - `drop` and `cancel`: Enter or Space, and Escape.
+ * - `settle`: the controller has run the effects of a drop or a cancel.
+ */
+export type ReorderInput = {
+    from: number;
+    key: string;
+    pointer: number;
+    type: 'press';
+    x: number;
+    y: number;
+} | {
+    slop: number;
+    to: number;
+    type: 'drag';
+    x: number;
+    y: number;
+} | {
+    type: 'release';
+} | {
+    from: number;
+    key: string;
+    type: 'pick';
+} | {
+    to: number;
+    type: 'step';
+} | {
+    to: number;
+    type: 'target';
+} | {
+    type: 'cancel';
+} | {
+    type: 'drop';
+} | {
+    type: 'settle';
+};
+/** The state with nothing held. */
+export declare const IDLE: ReorderState;
+/**
+ * The state after an input, or `null` where the input changes nothing.
+ *
+ * A press becomes a drag only once the pointer has traveled `slop` pixels, so a
+ * click on a grip stays a click. A click on a grip holds the item for the
+ * keys, and a second click on the same grip drops it, which is the move a
+ * single pointer makes without dragging.
+ */
+export declare const reorderStep: (state: ReorderState, input: ReorderInput) => ReorderState | null;
+/**
+ * How many of the other items the pointer has passed: the place the held item
+ * goes, among the others.
+ *
+ * `centers` are the middles of the other items along the axis, in the order
+ * drawn. `reversed` is a row laid out from the right, a right-to-left page,
+ * where passing an item means being left of its middle.
+ */
+export declare const passedCount: (centers: readonly number[], at: number, reversed?: boolean) => number;
+/**
+ * The middles of the items along the axis, from their boxes, for
+ * `passedCount`.
+ *
+ * An item with no box is one a window did not draw. One before every drawn
+ * item counts as passed, one after them as not passed, and one between two
+ * drawn items as where the drawn one before it is. `reversed` is the same
+ * question on a row laid out from the right.
+ */
+export declare const centersOf: (spans: readonly ({
+    end: number;
+    start: number;
+} | undefined)[], reversed?: boolean) => number[];
+/**
+ * Where a key moves a held item, or `null` for a key that does not move one.
+ *
+ * The arrows along the axis move it one place, and Home and End move it to
+ * either end. Along the inline axis the arrows follow the writing direction,
+ * so on a right-to-left page the left arrow moves it forward. The answer is
+ * held to the collection, so an arrow at an end returns where it already is.
+ */
+export declare const reorderKey: (key: string, { axis, count, rtl, to }: {
+    axis: ReorderAxis;
+    count: number;
+    rtl: boolean;
+    to: number;
+}) => number | null;
+/**
+ * Where the drop indicator goes for a held item: before or after the item at
+ * an index of the order drawn, or nowhere while the item would stay where it
+ * is.
+ *
+ * Moving back, the item lands before the one now at `to`. Moving forward, it
+ * lands after it.
+ */
+export declare const dropMark: (from: number, to: number) => {
+    edge: 'after' | 'before';
+    index: number;
+} | undefined;
+/**
+ * Every key in a new order: `key` taken out and put back at `to` among the
+ * shown ones.
+ *
+ * `all` is the whole order, which can hold keys that are not drawn: a hidden
+ * column, or a row a search left out. `shown` is the order drawn. The key goes
+ * after the shown one it now follows, or before the first shown one where it
+ * moves to the front, so a key that is not drawn keeps its place among the
+ * rest.
+ */
+export declare const placeKey: (all: readonly string[], shown: readonly string[], key: string, to: number) => string[];
+/**
+ * How far to scroll a box in one frame while a held item is near one of its
+ * edges, in pixels: negative toward the start, positive toward the end, and 0
+ * away from both.
+ *
+ * `at` is the pointer along the axis, and `start` and `end` are the box's
+ * edges. The speed rises from nothing at `zone` pixels in to `most` at the
+ * edge and past it.
+ */
+export declare const edgeSpeed: (at: number, start: number, end: number, { most, zone }?: {
+    most?: number;
+    zone?: number;
+}) => number;