@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/react/useAnalysisResult.d.ts

@@ -0,0 +1,168 @@
+import { AnalysisColumnView, AnalysisProjection, ChartData, ChartFit, Picked } from '../analysis/index.js';
+import { FilterSummaryItem } from '../filter/index.js';
+import { AnalysisViewConfig, ChartSpec, ChartType, RecordData } from '../model/index.js';
+import { ViewRuntime } from '../runtime/index.js';
+import { AnalysisEditorController } from './useAnalysisEditor.js';
+import { WorkbenchController } from './useWorkbench.js';
+/** A dimension a group can be split by: a field the result is not grouped on. */
+export interface SplitOption {
+    field: string;
+    label: string;
+}
+/**
+ * One thing the follow-up menu offers on a group (D20 追问). The menu draws
+ * each kind its own way — an icon and a word are a host's to choose — and
+ * runs it; which kinds are offered, in what order, and what running one
+ * does are decided here, so a new follow-up is a new member of this union
+ * and one more entry in `followUp`, not another pair of props on the menu.
+ */
+export type FollowUpAction = 
+/**
+ * Open the records behind the group, in a record view of their own. The
+ * view is named `title`: wording, so the menu says it — of `subject`, the
+ * definition's name for its records, and the group.
+ *
+ * With `gap`, offered and greyed with the reason it cannot run (D38): a
+ * group counted over elements of elements, which no condition over the
+ * records reaches (`drillGap`) — the menu says so rather than leave the
+ * reader to wonder where 「查看这些记录」 went — and `run` does nothing.
+ */
+{
+    kind: 'records';
+    subject: string;
+    run(title: string): void;
+    gap?: 'nested-elements';
+}
+/**
+ * Ask the same question of the group by another dimension, as a view of
+ * its own beside this one (`WorkbenchController.follow`), as `focus`
+ * does. Named `title`, of `subject` — this view's name — and the group.
+ */
+ | {
+    kind: 'split';
+    subject: string;
+    options: readonly SplitOption[];
+    run(field: string, title: string): void;
+}
+/**
+ * Ask the same question of the group alone, as a view of its own beside
+ * this one (`WorkbenchController.follow`), so the way back is this result
+ * as it stands. Named `title`, of `subject` — this view's name — and the
+ * group.
+ */
+ | {
+    kind: 'focus';
+    subject: string;
+    run(title: string): void;
+}
+/**
+ * Set a board's filter to the stretch of time the menu is about (D33
+ * Q52): offered on a dashboard panel only, over a span, for each date
+ * filter wired to the field it spans. The panel it was set from keeps
+ * every group, as a press that sets a filter leaves it (D23 Q18). `filter`
+ * is that filter's label, for the item to name it by.
+ */
+ | {
+    kind: 'filter';
+    filter: string;
+    run(): void;
+};
+/** One dimension of the group pressed, for the menu to name it by. */
+export interface FollowUpGroup {
+    /**
+     * The conditions that select it, as the applied bar names them — a date
+     * bucket's range as its period, a number band's two comparisons as the
+     * one segment they bound — so the menu, the name of a view opened from it
+     * and that view's applied bar say one sentence.
+     */
+    conditions: readonly FilterSummaryItem[];
+}
+/** What the menu over one pressed group shows. */
+export interface FollowUp {
+    /** The group, one dimension each, in the order the result is grouped. */
+    groups: readonly FollowUpGroup[];
+    actions: readonly FollowUpAction[];
+}
+export interface AnalysisResultController {
+    /** The rows on screen, or null while there are none of an analysis. */
+    view: AnalysisProjection | null;
+    /** The config those rows ran on: what a chart and a follow-up address. */
+    ran: AnalysisViewConfig | undefined;
+    /**
+     * The question the result answers or will answer: `ran` once rows are on
+     * screen; before any are, the config on its way or the one that failed.
+     * Undefined while nothing has been asked (`hasAsked`). What the rows are
+     * *shaped* by — the reading, the chart types that fit, the slots a chart
+     * can name — is known from the moment the question is sent, so the
+     * toolbar and the visualization panel work while the first answer is on
+     * its way and after it failed; only what needs the rows waits for them.
+     */
+    question: AnalysisViewConfig | undefined;
+    /**
+     * Every column of that question, as the result names them — the rows' own
+     * schema, or the same projection over no rows while none have landed —
+     * and the ones the table draws, in its order (`AnalysisProjection.columns`).
+     * Both empty while nothing has been asked. The toolbar reads the first
+     * out; a skeleton standing in for the table draws a bar per the second.
+     */
+    columns: readonly AnalysisColumnView[];
+    tableColumns: readonly AnalysisColumnView[];
+    /** The chart drawn over those rows, as the draft says to draw it. */
+    chart: ChartSpec;
+    /** The rows shaped for `chart`, or undefined while there is nothing to draw. */
+    chartData: ChartData | undefined;
+    /**
+     * Which chart types the question's shape can draw, its rows included once
+     * there are any (`fitCharts`); before anything was asked, the draft's
+     * shape and the stages its chart names.
+     */
+    fits: Record<ChartType, ChartFit>;
+    /** What the visualization panel shows as chosen. */
+    picked: Picked;
+    /**
+     * Draw the rows as this type, or as the table. Over a question — rows on
+     * screen, the first answer on its way, or a query that failed — it
+     * redraws and never runs; with none asked — a saved chart refused, so
+     * nothing ran — it fits the type to the draft's shape and runs (`repair`).
+     */
+    choose(next: Picked): void;
+    /**
+     * Whether a group of this result can be followed up at all. Over one
+     * level of expanded elements its records are asked of one element (D38);
+     * over elements of elements the menu opens and says why it cannot; over
+     * an array the definition lets no condition match into, not at all.
+     */
+    pickable: boolean;
+    /**
+     * The menu over one pressed group, or null when no condition can say it.
+     * With `through`, over a span instead (D33 Q52): every bucket of a time
+     * axis from `row`'s to `through`'s, read as one range (`drillSpan`) — a
+     * brush along the axis, or a second row picked with Shift in the table.
+     */
+    followUp(row: RecordData, through?: RecordData): FollowUp | null;
+}
+/**
+ * The analysis result as a host draws it (phase-2 review, developer #9):
+ * which rows, which chart over them, what the picker offers, and what a
+ * press on one group can do next. Everything here reads a kernel and writes
+ * the runtime; the component that draws it keeps only what is about the
+ * screen — which panel is open, where the keyboard is, which mark was
+ * pressed and where. `/ui` consumes this and nothing below it, which is
+ * the contract its entry states.
+ *
+ * **The rows are the config that ran; how they are looked at is the
+ * draft.** A result's rows and columns come from the config it was shaped
+ * by, and nothing else can name them. The layout and the chart are
+ * presentation (D20, `ANALYSIS_PRESENTATION_MEMBERS`): drawn from those
+ * rows as the draft says, so switching to a chart or picking another type
+ * redraws without a run. The draft's chart is fitted to the shape that ran
+ * **only while the two shapes differ** — a dimension added in the tray but
+ * not yet run is no column of these rows — because `fitChartSlots` opens a
+ * narrowed slot back up, which is right when the shape moved under the
+ * chart and wrong on every render of a chart narrowed on purpose.
+ *
+ * A follow-up is read off the same config the rows ran on, not the draft:
+ * the group pressed is a group of that result, not of what is being edited.
+ */
+export declare function useAnalysisResult(runtime: ViewRuntime<AnalysisViewConfig> | null, analysis: AnalysisEditorController, workbench: Pick<WorkbenchController, 'state' | 'canDrill' | 'drill' | 'follow'>): AnalysisResultController;
+//# sourceMappingURL=useAnalysisResult.d.ts.map

package/dist/react/useAnalysisResult.d.ts.map

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

package/dist/react/useAutoRefresh.d.ts

@@ -0,0 +1,115 @@
+import { ViewConfig } from '../model/index.js';
+import { ViewRuntime } from '../runtime/index.js';
+/**
+ * How often this view renews its own answer, and the way to run one now.
+ *
+ * There is no state here beside the config: the interval *is*
+ * `ViewConfigBase.refresh.interval`, saved with the view and read by the
+ * runtime's one timer. A control that kept its own copy would give the saved
+ * config, the timer and the screen three opinions about the same number. The
+ * two numbers below are one member read at its two ages — what is running
+ * and what is set — not two states.
+ */
+export interface RefreshController {
+    /**
+     * The interval **in force**: seconds between automatic refreshes, or
+     * `null` when the view does not refresh itself.
+     *
+     * It is `applied`'s, because that is the one the runtime's timer reads. A
+     * credential about what is happening has to answer to what is happening —
+     * the same reason `AppliedBar` describes the result rather than the draft.
+     * Choosing an interval edits and applies in one gesture, so this and
+     * {@link chosen} agree except while a draft the kernel refuses holds
+     * `apply` back, and then it is this one that is true.
+     *
+     * A stored value the kernel would refuse — fractional, or outside the
+     * budget — reads as `null` rather than as itself: the timer will never use
+     * it (an `applied` the kernel refuses can only come from a draft it
+     * refuses, which is already holding the timer), so naming it would promise
+     * a cadence nothing keeps. The refusal is the strip's to report.
+     */
+    interval: number | null;
+    /**
+     * What the view is **set** to: the draft's interval, which is what a save
+     * would write and what the menu marks as picked.
+     *
+     * It is the editor's value, like the layout or the page size, and it is
+     * kept apart from {@link interval} rather than folded into it because one
+     * mark saying two things is how a credential starts lying. When they
+     * differ, the draft is refused and the strip above the result says so.
+     */
+    chosen: number | null;
+    /**
+     * The intervals on offer, ascending, already cut to what
+     * `RuntimeLimits.minRefreshInterval` and `maxRefreshInterval` admit. An
+     * interval the limits refuse is absent rather than disabled (D4), so an
+     * empty list means this view has no interval to choose and a control over
+     * it has nothing to open.
+     */
+    intervals: readonly number[];
+    /**
+     * Whether admission has something to say about this view's `refresh`
+     * member: missing, not an object, or an interval that is not a whole
+     * number of seconds in range.
+     *
+     * A control reads it to know it still has work to do when it has nothing
+     * to offer. Turning refresh **off** writes `{ interval: null }`, which is
+     * the repair for every one of those refusals, so a menu that hid itself
+     * because the limits left no rung would strand the user on a config that
+     * blocks Apply and Save with no control on screen able to mend it — the
+     * package's own rule is that a reported error is always reachable.
+     */
+    unsound: boolean;
+    /**
+     * Writes `refresh.interval` and applies it, the way a sort or a column
+     * change does: without the apply the runtime's timer, which reads
+     * `applied`, would never hear about it.
+     */
+    setInterval(interval: number | null): void;
+    /** One refresh, now. Unchanged by any of the above. */
+    now(): void;
+    /** True while a query of this view is in flight. */
+    loading: boolean;
+    /**
+     * When the next automatic refresh is due, on the runtime's clock, or `null`
+     * while no timer is armed — the interval is off, or the runtime is holding
+     * the timer for one of its four reasons.
+     *
+     * It is the runtime's `nextRefreshAt`, handed on as it stands. A control
+     * counts down to it; it does not count for itself, because a second clock
+     * beside the timer's is a second opinion about when the data will move.
+     */
+    dueAt: number | null;
+    /**
+     * Whole seconds from now until {@link dueAt}, read against the runtime's
+     * own clock, or `null` when nothing is armed. Never negative: a timer that
+     * is late is at zero, not behind.
+     *
+     * A function rather than a number, because it answers "now", and the
+     * controller is built once per render while a countdown asks once a second.
+     * {@link useRefreshCountdown} is what asks.
+     */
+    remaining(): number | null;
+}
+/**
+ * The auto-refresh of one open view, as a control can offer it.
+ *
+ * The runtime decides when the timer runs and when it pauses — an invalid
+ * draft, an editor with focus, a hidden page, a request in flight — and this
+ * adds no rule of its own. All it does is make the interval reachable.
+ */
+export declare function useAutoRefresh(runtime: ViewRuntime<ViewConfig> | null): RefreshController;
+/**
+ * Whole seconds until the next automatic refresh, redrawn once a second.
+ *
+ * The ticker is a pulse, not a measurement: every reading comes from the
+ * runtime's due time against the runtime's clock, so a tick that arrives
+ * late, early or not at all changes when the number is redrawn and never
+ * what it says. It runs only while a timer is armed — no interval, or a
+ * runtime holding its timer, means no ticker — and only while the component
+ * asking is mounted, which is the control that draws the count and not the
+ * workbench around it: a view re-rendering its whole result once a second to
+ * move one digit is the cost this hook exists to keep out of the table.
+ */
+export declare function useRefreshCountdown(refresh: RefreshController): number | null;
+//# sourceMappingURL=useAutoRefresh.d.ts.map

package/dist/react/useAutoRefresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoRefresh.d.ts","sourceRoot":"","sources":["../../src/react/useAutoRefresh.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAGV,UAAU,EACX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAEV,WAAW,EAEZ,MAAM,qBAAqB,CAAC;AAsC7B;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;;;;;;;OAQG;IACH,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB;;;;;;OAMG;IACH,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B;;;;;;;;;;;OAWG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;IAC3C,uDAAuD;IACvD,GAAG,IAAI,IAAI,CAAC;IACZ,oDAAoD;IACpD,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;;OAQG;IACH,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;;;;;;OAQG;IACH,SAAS,IAAI,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI,GACtC,iBAAiB,CAqEnB;AAaD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,GAAG,IAAI,CAc7E"}

package/dist/react/useDashboard.d.ts

@@ -0,0 +1,204 @@
+import { AnalysisDateUnit, DashboardWidth, DashboardField, DashboardFilters, DashboardPanel, DashboardTab, DashboardTimeGrouping, DataViewConfig, FieldDefinition, FieldOption, FilterValue, Issue, PanelClick, PanelLayout, RecordData } from '../model/index.js';
+import { FilterReach } from '../dashboard/index.js';
+import { CrossFilterOutcome, DashboardEditing, DashboardFilterEditing, DashboardRuntime, DestinationBoard, EditHistoryState, HandOver, OptionSource, PanelGrouping, PressDestination, ValueCandidateSource, ViewRuntime } from '../runtime/index.js';
+import { FieldKindRegistry } from '../filter/index.js';
+/** One panel, ready to place: geometry, what runs inside, what is wrong. */
+export interface DashboardPanelView {
+    id: string;
+    title: string | undefined;
+    panel: DashboardPanel;
+    layout: PanelLayout;
+    /** The runtime of a data panel that can run; `null` otherwise. */
+    runtime: ViewRuntime<DataViewConfig> | null;
+    issues: Issue[];
+    /**
+     * The fields of the view a data panel shows, which its findings are
+     * named by (`DashboardPanelState.fields`); empty otherwise.
+     */
+    fields: readonly FieldDefinition[];
+    /** True when this panel alone cannot show anything. */
+    broken: boolean;
+    /** The tab it is on; `null` on a board without tabs. */
+    tab: string | null;
+    /** What each filter does to it, by filter name (`filterReach`). */
+    reach: Readonly<Record<string, FilterReach>>;
+    /** What the time grouping does to it (`PanelGrouping`). */
+    grouping: PanelGrouping;
+    /**
+     * What a press on one of its groups does (D22 I), or `null` for the
+     * follow-up menu (`DashboardPanelState.click`).
+     */
+    click: PanelClick | null;
+}
+export interface DashboardController {
+    panels: DashboardPanelView[];
+    /** Columns a layout is placed in; the kernel admits against the same number. */
+    columns: number;
+    /**
+     * How wide the board on screen is laid out (D31, `boardWidth`): `full`
+     * while no board is open, and for one saved before a board could say.
+     */
+    width: DashboardWidth;
+    /** The tab on screen, whose panels alone run; `null` without tabs. */
+    tab: string | null;
+    /** Shows another tab (`DashboardRuntime.showTab`). */
+    showTab(tabId: string): void;
+    /**
+     * What the board says about itself, above its panels (`boardFindings`):
+     * its own findings — "too many panels" among them — and a panel's the
+     * draft raised that no panel wears yet. Everything else a panel says in
+     * its own frame.
+     */
+    issues: Issue[];
+    /** True while a panel reference is still loading. */
+    resolving: boolean;
+    /**
+     * True while any panel has a query in flight.
+     *
+     * A dashboard runs nothing of its own — `state.query` never leaves `idle`
+     * — so "is something running here" is only answerable by asking the
+     * panels, which is what the dashboard's own timer does before it fires
+     * (`PanelChildren.loading`). A control that read the dashboard's
+     * query state instead would call a board of twelve loading panels idle.
+     */
+    loading: boolean;
+    /**
+     * When the panels on the tab shown were read, on the runtime's clock
+     * (`ViewResult.receivedAt`): the **earliest** of their last answers, so
+     * 「更新于 10:32」 is true of every number on screen — a panel whose
+     * refresh failed keeps its older rows, and the time says so. `null` until
+     * one of them has answered. Panels on another tab are not on screen and
+     * do not count.
+     */
+    readAt: number | null;
+    dirty: boolean;
+    /**
+     * Moves or resizes one panel, and applies that alone, like sorting a
+     * table: the panels it lands on are pushed down out of its way, and a
+     * global filter still being edited stays unapplied
+     * (`DashboardRuntime.place`).
+     */
+    place(panelId: string, layout: PanelLayout, grown?: ReadonlyMap<string, number>): void;
+    /** Re-runs every panel at once. */
+    refresh(): void;
+    /** Re-runs one panel: the retry on a panel whose query failed. */
+    refreshPanel(panelId: string): void;
+    /**
+     * Whether the board is being built — 「编辑」 pressed, not yet 「完成」 or
+     * 「取消」 (`DashboardRuntimeState.building`). The runtime's, so its auto
+     * refresh waits for it (D26 Q39) and every surface reads the same one.
+     */
+    building: boolean;
+    /** Starts or ends building the board (`DashboardRuntime.setBuilding`). */
+    setBuilding(active: boolean): void;
+    /**
+     * Building the board (D22 A–E): the runtime's own commands, each written
+     * into the draft and onto the screen at once; `null` while no board is
+     * open. Whether they are on offer is the UI's to say, by permission.
+     */
+    edit: (DashboardEditing & DashboardFilterEditing) | null;
+    /**
+     * What building the board can take back and make again — the step
+     * `edit.undo()` and `edit.redo()` would, or `null` (`DashboardRuntimeState.history`).
+     */
+    history: EditHistoryState;
+    /**
+     * The board's filters as on screen, in the bar's order (D22 F); the same
+     * list the draft and the applied config hold, since every edit writes
+     * both.
+     */
+    filterFields: readonly DashboardField[];
+    /** The board's time grouping; `null` on a board without one. */
+    timeGrouping: DashboardTimeGrouping | null;
+    /** What the filters hold now: the reader's, never the config's. */
+    filters: DashboardFilters;
+    /**
+     * The step at which the filters' values last went out to the panels
+     * (`DashboardRuntimeState.filtersRun`): what a change of them ran.
+     */
+    filtersRun: number;
+    /**
+     * Sets what one filter holds, `null` clearing it; the panels run on it a
+     * moment later (`DashboardRuntime.setFilterValue`). Answers why a value
+     * was refused.
+     */
+    setFilterValue(name: string, value: FilterValue | null): Issue[];
+    setGroupingUnit(unit: AnalysisDateUnit): void;
+    /** 「清空」: every filter cleared, the required ones to their defaults. */
+    clearFilters(): void;
+    /**
+     * The filters whose control asks for a value it does not hold yet — a
+     * date filter turned to 「指定日期」 with no day picked — by name. The
+     * value in force is not what the bar shows, so a panel wired to one says
+     * a date is to be picked rather than show the numbers of the value that
+     * was (2026-09-26 review, P1-1).
+     */
+    awaiting: readonly string[];
+    /** Says a filter's control is (or is no longer) awaiting a value. */
+    setAwaiting(name: string, awaiting: boolean): void;
+    /** What a text filter offers to pick from (`DashboardRuntime.valueCandidates`). */
+    filterCandidates(name: string): ValueCandidateSource | null;
+    /**
+     * The list a filter without one of its own picks from, as its wired
+     * fields declare it (`DashboardRuntime.wiredOptions`); `null` for none.
+     */
+    filterChoices(name: string): FieldOption[] | null;
+    /** An id filter's candidates, by the host's source key (`optionSource`). */
+    filterOptions(remote: string): OptionSource | null;
+    /** The field kinds the board's filters are edited with; `null` without a board. */
+    kinds: FieldKindRegistry | null;
+    /**
+     * The board's tabs in the order of its bar, as they are on screen (D22
+     * E); none on a board without. Fewer than two draw no bar.
+     */
+    tabs: readonly DashboardTab[];
+    /**
+     * Loads a saved view before a panel shows it, so the panel is added at
+     * the size of what it shows (`DashboardRuntime.preload`); never rejects.
+     */
+    preload(instanceId: string): Promise<void>;
+    /**
+     * A press on one group of a panel whose click sets a filter (D22 I,
+     * `DashboardRuntime.crossFilter`): set from it, or cleared on a second
+     * press of the same group.
+     */
+    crossFilter(panelId: string, row: RecordData): CrossFilterOutcome;
+    /**
+     * Whether a group is one its panel's press set a filter to — the click's,
+     * or a span of its time axis (`pressSpan`).
+     */
+    pressed(panelId: string, row: RecordData): boolean;
+    /**
+     * The date filters a span of a panel's time axis can set
+     * (`DashboardRuntime.spanFilters`, D33 Q52).
+     */
+    spanFilters(panelId: string): readonly DashboardField[];
+    /**
+     * A span of a panel's time axis set into one of those filters
+     * (`DashboardRuntime.pressSpan`): the panel keeps every group.
+     */
+    pressSpan(panelId: string, name: string, row: RecordData, through: RecordData): CrossFilterOutcome;
+    /** Where a press on a panel with a custom destination goes. */
+    destination(panelId: string, row: RecordData): Promise<PressDestination | null>;
+    /**
+     * Another board a click opens, read for 「点击时…」 to list its filters
+     * (`DashboardRuntime.destinationBoard`); `null` for one gone or unreadable.
+     */
+    destinationBoard(instanceId: string): Promise<DestinationBoard | null>;
+    /**
+     * What one data panel's view takes off the board as it stands
+     * (`DashboardRuntime.handOver`, D26 Q30): every way off it — 「在工作台中
+     * 打开」, the follow-ups, a view destination — hands this over.
+     */
+    handOver(panelId: string): HandOver | null;
+}
+/**
+ * A dashboard as a grid of panels.
+ *
+ * It reports the applied panels rather than the draft's, because a panel is
+ * a running query and not a form field: what the grid shows is what is
+ * executing. Geometry is the exception the design allows — moving a panel
+ * applies that move alone in one gesture, so a drag lands immediately.
+ */
+export declare function useDashboard(runtime: DashboardRuntime | null): DashboardController;
+//# sourceMappingURL=useDashboard.d.ts.map

package/dist/react/useDashboard.d.ts.map

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