@aceshooting/lyra-ui 2.0.0 → 2.2.0

package/dist/components/sparkline/sparkline.js

@@ -1,115 +1,5 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { html, svg } from 'lit';
-import { property } from 'lit/decorators.js';
-import { LyraElement } from '../../internal/lyra-element.js';
+export * from './sparkline.class.js';
+import { LyraSparkline } from './sparkline.class.js';
 import { defineElement } from '../../internal/prefix.js';
-import { styles } from './sparkline.styles.js';
-const VIEW = 100;
-// A <rect> per bar doesn't collapse into one path the way line/area do, so an
-// unbounded `values` array turns directly into that many shadow-DOM nodes --
-// and an uncapped line/area path string grows without bound too. Capping the
-// point count up front (shared by every render type) keeps worst-case
-// DOM/compute bounded without affecting any realistically-sized chart.
-const MAX_POINTS = 500; // shared point-count cap for every render type (line/area/bar)
-function decimate(arr, max) {
-    if (arr.length <= max)
-        return [...arr];
-    const step = (arr.length - 1) / (max - 1); // anchors both the first AND last sample exactly
-    return Array.from({ length: max }, (_, i) => arr[Math.round(i * step)]);
-}
-/**
- * `<lyra-sparkline>` — a zero-dependency inline SVG trend chart.
- * Mirrors the Web Awesome `<wa-sparkline>` API under the `lyra-` prefix.
- *
- * @customElement lyra-sparkline
- * @csspart line - The stroked line path (type="line" and type="area").
- * @csspart area - The filled area under the line (type="area").
- * @csspart bar - Each bar rectangle (type="bar").
- */
-export class LyraSparkline extends LyraElement {
-    constructor() {
-        super(...arguments);
-        /** The data series to plot. */
-        this.values = [];
-        /** Rendering style. */
-        this.type = 'line';
-    }
-    static { this.styles = [LyraElement.styles, styles]; }
-    points() {
-        // Auto min/max is scanned from the full, pre-decimation `values` -- doing
-        // this after decimating would silently narrow the scale to whatever the
-        // sampled subset happens to contain, which can clip or misproportion a
-        // real extreme value that decimation happened to drop.
-        const raw = this.values;
-        let autoLo = raw[0];
-        let autoHi = raw[0];
-        for (const n of raw) {
-            if (n < autoLo)
-                autoLo = n;
-            if (n > autoHi)
-                autoHi = n;
-        }
-        const lo = this.min ?? autoLo;
-        const hi = this.max ?? autoHi;
-        const v = raw.length > MAX_POINTS ? decimate(raw, MAX_POINTS) : raw;
-        const span = hi - lo;
-        return v.map((n, i) => {
-            const x = v.length > 1 ? (i / (v.length - 1)) * VIEW : VIEW / 2;
-            const y = span === 0 ? VIEW / 2 : VIEW - ((n - lo) / span) * VIEW;
-            return [x, y];
-        });
-    }
-    willUpdate() {
-        const v = this.values;
-        this.setAttribute('role', 'img');
-        this.setAttribute('aria-label', v.length ? `Trend of ${v.length} values, last ${v.at(-1)}` : 'No data');
-    }
-    render() {
-        const v = this.values;
-        if (!v.length) {
-            return html `<svg viewBox="0 0 ${VIEW} ${VIEW}" aria-hidden="true"></svg>`;
-        }
-        const pts = this.points();
-        if (this.type === 'bar') {
-            // Narrow the bar width as the (already decimated-to-MAX_POINTS) point
-            // count grows, so bars stop overlapping once there are more than a
-            // handful -- VIEW / pts.length is each bar's full "slot" width; keep a
-            // small gap between slots by drawing at 70% of it, floored at 1px and
-            // capped at the original fixed 4px for small point counts.
-            const slot = VIEW / pts.length;
-            const barWidth = Math.min(4, Math.max(1, slot * 0.7));
-            const bars = pts.map(([x, y]) => {
-                const barY = Math.min(y, VIEW);
-                return svg `<rect part="bar" x="${x - barWidth / 2}" y="${barY}" width="${barWidth}" height="${VIEW - barY}"></rect>`;
-            });
-            return html `<svg viewBox="0 0 ${VIEW} ${VIEW}" preserveAspectRatio="none" aria-hidden="true">
-        ${bars}
-      </svg>`;
-        }
-        const d = pts.length > 1
-            ? pts.map(([x, y], i) => `${i ? 'L' : 'M'}${x},${y}`).join(' ')
-            : `M${pts[0][0]},${pts[0][1]} L${pts[0][0]},${pts[0][1]}`;
-        return html `<svg viewBox="0 0 ${VIEW} ${VIEW}" preserveAspectRatio="none" aria-hidden="true">
-      ${this.type === 'area' ? svg `<path part="area" d="${d} L${VIEW},${VIEW} L0,${VIEW} Z"></path>` : ''}
-      <path part="line" d="${d}"></path>
-    </svg>`;
-    }
-}
-__decorate([
-    property({ type: Array })
-], LyraSparkline.prototype, "values", void 0);
-__decorate([
-    property()
-], LyraSparkline.prototype, "type", void 0);
-__decorate([
-    property({ type: Number })
-], LyraSparkline.prototype, "min", void 0);
-__decorate([
-    property({ type: Number })
-], LyraSparkline.prototype, "max", void 0);
 defineElement('sparkline', LyraSparkline);
+//# sourceMappingURL=sparkline.js.map

package/dist/components/sparkline/sparkline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline.js","sourceRoot":"","sources":["../../../src/components/sparkline/sparkline.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,aAAa,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC"}

package/dist/components/sparkline/sparkline.styles.d.ts

@@ -1 +1,2 @@
 export declare const styles: import("lit").CSSResult;
+//# sourceMappingURL=sparkline.styles.d.ts.map

package/dist/components/sparkline/sparkline.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline.styles.d.ts","sourceRoot":"","sources":["../../../src/components/sparkline/sparkline.styles.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,yBA6BlB,CAAC"}

package/dist/components/sparkline/sparkline.styles.js

@@ -2,8 +2,8 @@ import { css } from 'lit';
 export const styles = css `
   :host {
     display: inline-block;
-    inline-size: 6em;
-    block-size: 1.5em;
+    inline-size: var(--lyra-size-6em);
+    block-size: var(--lyra-size-1-5em);
     vertical-align: middle;
   }
   svg {
@@ -29,3 +29,4 @@ export const styles = css `
     fill: var(--lyra-color-brand);
   }
 `;
+//# sourceMappingURL=sparkline.styles.js.map

package/dist/components/sparkline/sparkline.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparkline.styles.js","sourceRoot":"","sources":["../../../src/components/sparkline/sparkline.styles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAE1B,MAAM,CAAC,MAAM,MAAM,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxB,CAAC"}

package/dist/components/split/split.class.d.ts

@@ -0,0 +1,293 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+/** A fixed-pixel-range constraint for one panel; index-aligned with `sizes`/
+ *  `panelConstraints`. Either bound may be omitted to leave that side
+ *  unconstrained (falls back to the component's percent-based `min`). */
+export interface PanelConstraint {
+    minPx?: number;
+    maxPx?: number;
+}
+export type SplitConstraintIssueReason = 'minimum-total' | 'maximum-total' | 'minimum-exceeds-maximum';
+export interface SplitConstraintIssueDetail {
+    reason: SplitConstraintIssueReason;
+    panelCount: number;
+    minimumTotal: number;
+    maximumTotal: number | null;
+    containerSize: number;
+}
+/** Which pane (if any) participates in responsive collapse (see `collapse`). */
+export type SplitCollapseMode = 'start' | 'end' | 'none';
+/** The collapsing pane's current responsive state — `'wide'` is the normal
+ *  drag-resizable percent layout (identical to `collapse="none"`); `'rail'`
+ *  clamps it to `railWidth`; `'floating'` lifts it out of the flex flow as an
+ *  overlay above the other pane. */
+export type SplitCollapseState = 'wide' | 'rail' | 'floating';
+/** What can be *assigned* to `collapseState` -- `'auto'` is a write-only
+ *  sentinel; see the `collapseState` accessor doc. */
+export type SplitCollapseStateInput = SplitCollapseState | 'auto';
+export interface SplitCollapseChangeDetail {
+    state: SplitCollapseState;
+}
+export interface SplitResizeDetail {
+    sizes: number[];
+}
+/**
+ * `<lyra-split>` — resizable panels for dashboard layouts. Direct light-DOM
+ * children are the panels; a divider is auto-inserted between each pair.
+ *
+ * Optionally, one pane can opt in to responsive collapse via `collapse`
+ * (`"start"`/`"end"`, default `"none"` — no behavior change when unset): as
+ * the split's own container narrows past `railBreakpoint` that pane clamps
+ * to a fixed `railWidth`, and past the narrower `floatBreakpoint` it instead
+ * becomes an absolutely-positioned overlay "floating card" above the other
+ * pane. This component only handles the width-collapse mechanics and
+ * signals the current state — via the `collapseState`-derived
+ * `data-collapse-state` attribute (set on both the host and the collapsing
+ * panel itself) and the `lyra-split-collapse-change` event — it renders no
+ * icon-only/collapsed UI of its own; slotted content is expected to adapt to
+ * its own clamped width (e.g. via its own container query).
+ *
+ * `collapseState` is a public accessor with force/auto semantics mirroring
+ * `<lyra-app-rail>`'s `mode`: it's normally derived automatically from the
+ * measured container width (via a `ResizeObserver` on `[part="base"]`)
+ * whenever it crosses `railBreakpoint`/`floatBreakpoint`, but assigning it a
+ * concrete `'wide'`/`'rail'`/`'floating'` value pins it there and stops that
+ * automatic tracking — useful for a consumer-driven toggle (e.g. a button
+ * that forces `'floating'` regardless of width). Assigning the write-only
+ * `'auto'` sentinel releases the pin and immediately re-derives the state
+ * from the current measured width, resuming automatic tracking. `'auto'` is
+ * never a value this getter returns.
+ *
+ * The `'floating'` state is a hidden-by-default drawer, gated by `open`
+ * (mirrors `<lyra-app-rail>`'s mobile overlay): while `collapseState` is
+ * `'floating'` and `open` is `false` (the default), the collapsing panel
+ * renders nothing — `hidden`, out of the accessibility tree, not just
+ * visually hidden — instead of the always-visible overlay card this state
+ * rendered before `open` existed. Setting `open = true` reveals it as a
+ * focus-trapped floating panel with a `[part="backdrop"]` scrim; Escape or a
+ * backdrop click set `open` back to `false`. `open` is preserved (not reset)
+ * while `collapseState` isn't `'floating'`, but no drawer chrome renders
+ * until it is again — except that leaving `'floating'` while `open` is
+ * `true` (a breakpoint crossing back to `'wide'`/`'rail'`, or a forced
+ * reassignment) also closes it, the same way `<lyra-app-rail>` closes its
+ * mobile overlay when leaving `'mobile'` while open.
+ *
+ * @customElement lyra-split
+ * @event lyra-resize - `detail: { sizes }`, fired on every drag step/release
+ *   and every keyboard step.
+ * @event lyra-split-collapse-change - `detail: { state }` (`SplitCollapseChangeDetail`),
+ *   fired whenever the responsive `collapseState` actually transitions between
+ *   `'wide'`/`'rail'`/`'floating'` — whether from a breakpoint crossing or an
+ *   explicit `collapseState` assignment. Only relevant when `collapse` isn't
+ *   `"none"`; never fires otherwise. Not fired for a redundant reassignment
+ *   to the state already in effect.
+ * @event lyra-split-constraints-invalid - `detail: SplitConstraintIssueDetail`,
+ *   fired once when the configured panel minimums/maximums cannot describe a
+ *   layout that fits the track. The splitter rejects that infeasible set for
+ *   interaction and falls back to a normalized percent minimum.
+ * @slot - Panels to arrange side by side (or stacked, when `orientation="vertical"`); each direct child becomes one resizable panel.
+ * @csspart base - The flex layout wrapper (`position: relative`, so the `'floating'` collapse state can anchor to it).
+ * @csspart divider - Each divider between two panels; carries `aria-disabled="true"` and is drag/keyboard-inert while its adjacent panel is collapsed (`'rail'`/`'floating'`).
+ * @csspart backdrop - The `'floating'` drawer's scrim. Only rendered while `collapseState === 'floating'` and `open`.
+ */
+export interface LyraSplitEventMap {
+    'lyra-resize': CustomEvent<SplitResizeDetail>;
+}
+export declare class LyraSplit extends LyraElement<LyraSplitEventMap> {
+    static styles: import("lit").CSSResultGroup[];
+    static properties: {
+        collapseState: {
+            reflect: boolean;
+            attribute: string;
+            noAccessor: boolean;
+        };
+    };
+    sizes: number[];
+    min: number;
+    orientation: 'horizontal' | 'vertical';
+    storageKey?: string;
+    /** Optional fixed-pixel min/max per panel, index-aligned with `sizes`. A
+     *  `null`/missing entry leaves that panel purely percent-based (the
+     *  existing `min`-only behavior). `sizes`, the `lyra-resize` payload, and
+     *  localStorage persistence stay percent-based regardless — only the
+     *  effective clamp bounds change for a constrained panel. */
+    panelConstraints: (PanelConstraint | null)[];
+    /** Opts a pane in to responsive collapse: `'start'` is the first light-DOM
+     *  panel (index 0), `'end'` is the last. Both are LOGICAL positions, same
+     *  as CSS `inset-inline-start`/`-end` — see the `collapsingIndex` getter
+     *  for why that already resolves to the same physical index under RTL for
+     *  this component (panels are never re-`order`ed for RTL, only the drag
+     *  delta sign mirrors). Default `'none'`: none of the collapse behavior
+     *  below applies, and rendering/behavior is identical to before this
+     *  property existed. */
+    collapse: SplitCollapseMode;
+    /** Fixed CSS length the collapsing pane clamps to in the `'rail'` state. */
+    railWidth: string;
+    /** Container width (px, measured on `[part="base"]`) below which the
+     *  collapsing pane switches from its normal percent width to the fixed
+     *  `railWidth` (`'rail'` state). Must stay above `floatBreakpoint`. */
+    railBreakpoint: number;
+    /** Container width (px) below which the collapsing pane instead becomes an
+     *  absolutely-positioned overlay above the other pane (`'floating'` state). */
+    floatBreakpoint: number;
+    /** Whether the `'floating'` collapse state's drawer is shown. Only
+     *  meaningful while `collapseState` is `'floating'` — the value is
+     *  preserved (not reset) while another state is active, but no drawer
+     *  chrome renders until `collapseState` is `'floating'` again. Defaults to
+     *  `false`: the collapsing pane renders nothing while floating until a
+     *  consumer opts in by setting this (or it's forced open programmatically)
+     *  — see the class doc. */
+    open: boolean;
+    /** Overrides the auto-inserted divider's `aria-label` — receives the divider's 0-based index
+     *  and the total panel count (`lyra-split` supports N panels, so a single fixed string can't
+     *  express every divider's label; a function can). Unset (the default) keeps today's exact
+     *  `` `Resize divider between panel ${i + 1} and panel ${i + 2}` `` template. */
+    dividerLabel?: (index: number, panelCount: number) => string;
+    private panelCount;
+    private _collapseState;
+    private _forced;
+    private overlayActive;
+    private justOpened;
+    private releaseScrollLock?;
+    private overlayHandle?;
+    private drags;
+    private stylizedPanels;
+    private constraintIssueKey;
+    private baseEl?;
+    private collapseResizeObserver?;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected firstUpdated(): void;
+    /** Both branches here derive one reactive property from another with no
+     *  DOM measurement involved, so they belong in `willUpdate()` rather than
+     *  `updated()`: setting a reactive property from `updated()`/
+     *  `firstUpdated()` schedules a *second* update on top of the one that
+     *  just finished, which Lit's dev-mode console flags ("scheduled an
+     *  update ... after an update completed"). Both of these were real and
+     *  reproducible in normal usage, not just test artifacts --
+     *  `ensureSizes()` on any direct `sizes` assignment whose length doesn't
+     *  match `panelCount` (e.g. a consumer correcting a stale layout), and the
+     *  `collapseState` reset on every `collapse` -> `'none'` transition. The
+     *  `collapse !== 'none'` re-arm path in `syncCollapseObserver()` still
+     *  needs a freshly measured container width and stays in `updated()` --
+     *  see `armCollapseObserver()`'s own doc comment for why *that* one is the
+     *  documented exception instead (mirrors virtual-list.ts's
+     *  `attachContainerListeners()`). */
+    protected willUpdate(changed: PropertyValues): void;
+    /**
+     * The collapsing pane's current responsive state. Always one of the three
+     * real states — never `'auto'` — reflecting either the live measured
+     * width or, once forced, whatever was last assigned. See the class doc for
+     * the full force/auto contract (mirrors `<lyra-app-rail>`'s `mode`).
+     */
+    get collapseState(): SplitCollapseState;
+    set collapseState(next: SplitCollapseStateInput);
+    /** The container width (px) `[part="base"]` is measured at right now --
+     *  used to re-derive `collapseState` immediately when a forced value is
+     *  released back to `'auto'`, outside of the `ResizeObserver`'s own
+     *  (async, entry-driven) callback. Mirrors the synchronous initial read
+     *  `armCollapseObserver()` already does when it (re-)arms. */
+    private currentMeasuredWidth;
+    /** Resets `collapseState` back to its `'wide'` default and releases any
+     *  force, bypassing the public accessor's pin/event-emit side effects --
+     *  used only for the `collapse -> 'none'` housekeeping reset in
+     *  `willUpdate()`, which is purely internal bookkeeping (the feature is
+     *  off entirely), not a state transition a consumer forced or observed. */
+    private resetCollapseState;
+    /** Applies an actual `collapseState` transition (no-op if `next` matches
+     *  the current value): updates the field, triggers Lit's reflect/re-render
+     *  via `requestUpdate`, and fires `lyra-split-collapse-change`. Shared by
+     *  both the `ResizeObserver`-driven measurement path (`updateCollapseState`)
+     *  and the accessor's forced-value assignment, so the two never duplicate
+     *  this logic. Leaving `'floating'` while `open` is still `true` also
+     *  closes the drawer -- mirrors `<lyra-app-rail>` closing its mobile
+     *  overlay when `mode` leaves `'mobile'` while open. */
+    private applyCollapseStateChange;
+    private get storageFullKey();
+    private loadPersisted;
+    private persist;
+    private ensureSizes;
+    private onSlotChange;
+    /** The container extent (px) along the resize axis, read live so a
+     *  container resize between calls is always picked up — same live read
+     *  `onPointerMove` already does via `drag.base.clientWidth/clientHeight`. */
+    private getContainerSize;
+    /** The physical panel index `collapse: 'start' | 'end'` resolves to, or
+     *  `-1` when collapse is off (`'none'`) or there are fewer than 2 panels
+     *  to collapse one of. Panels are laid out via ascending inline `order`
+     *  (see `updated()`) and that ordering is never re-swapped for RTL — only
+     *  the drag/keyboard *delta sign* mirrors for RTL, exactly like
+     *  `onPointerMove`/`onDividerKeyDown` — so panel index 0 already renders
+     *  at the logical inline-start edge under both LTR and RTL (confirmed by
+     *  the pointer-drag RTL test elsewhere in this file: panel 0 renders on
+     *  the visual *right*, i.e. the RTL inline-start side). `'start'` therefore
+     *  always resolves to index 0 and `'end'` to `panelCount - 1`, regardless
+     *  of `isRtl(this)` — consulting it here would swap collapse onto the
+     *  panel that visually sits at the *other* logical edge, which would be a
+     *  bug against this component's own RTL rendering, not a fix for one.
+     */
+    private get collapsingIndex();
+    /** Whether a pane is actually collapsed (rail or floating) right now —
+     *  `false` whenever `collapse === 'none'`, since `collapseState` then
+     *  never leaves its `'wide'` default. */
+    private get collapseActive();
+    /** Dragging/keyboard-resizing is disabled on the one divider immediately
+     *  adjacent to the currently-collapsed pane (its other side has nothing
+     *  meaningful to resize against while the pane is rail/floating-width). */
+    private isDividerDisabled;
+    /** Classifies a measured container width into the collapsing pane's
+     *  responsive state and, only on an actual transition, applies it (via the
+     *  same `applyCollapseStateChange()` the accessor's forced-value path
+     *  uses). Gated behind `_forced` so a pinned `collapseState` is never
+     *  silently overwritten by a subsequent resize — this is also what the
+     *  accessor's `'auto'` release calls (with the current measured width) to
+     *  re-derive the state without duplicating the width-vs-breakpoint logic. */
+    private updateCollapseState;
+    /** Creates (idempotently) and (re-)observes `[part="base"]` with the
+     *  collapse-state `ResizeObserver` — a no-op until `baseEl` exists (see
+     *  `firstUpdated()`/`connectedCallback()`). The observer's first callback
+     *  supplies the initial layout measurement; keeping the read there avoids
+     *  mutating reactive state from `firstUpdated()`/`updated()`, which would
+     *  create a redundant lifecycle update and a Lit warning. */
+    private armCollapseObserver;
+    /** Reacts to a live `collapse` property change (as opposed to the
+     *  connect/first-render arming above): turns the observer on/off. The
+     *  `collapseState` reset for the `'none'` case lives in `willUpdate()`
+     *  instead (see its doc comment) so no stale rail/floating styling
+     *  survives switching collapse off, without the extra render pass a
+     *  property set here would cost. */
+    private syncCollapseObserver;
+    /** The safe fallback for a shared percent minimum. A value above the
+     *  available share is still useful as a consumer intent, but it cannot be
+     *  honored for every panel at once, so reduce it proportionally. */
+    private normalizedDefaultMin;
+    /** Resolves all panel bounds together so aggregate feasibility is checked
+     *  before an individual divider is asked to clamp a pair. An invalid set is
+     *  rejected as a whole: interaction uses the safe shared minimum instead of
+     *  exposing a divider whose minimum is greater than its maximum. */
+    private resolveConstraintBounds;
+    private percentBounds;
+    private clampPair;
+    private applyDelta;
+    /** The collapsing pane's light-DOM element itself — the `'floating'`
+     *  drawer's focus-trap/backdrop target. There's no separate shadow-DOM
+     *  panel to trap focus within (unlike `<lyra-app-rail>`'s `[part="panel"]`):
+     *  the slotted panel *is* the floating drawer, just repositioned via
+     *  inline styles in `updated()`. */
+    private get floatingPanelEl();
+    private activateFloatingOverlay;
+    private deactivateFloatingOverlay;
+    private onBackdropClick;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private onDividerKeyDown;
+    protected updated(changed: PropertyValues): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-split': LyraSplit;
+    }
+}
+//# sourceMappingURL=split.class.d.ts.map

package/dist/components/split/split.class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.class.d.ts","sourceRoot":"","sources":["../../../src/components/split/split.class.ts"],"names":[],"mappings":"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"}