panelui-native 0.44.0 → 0.49.0

package/lib/typescript/src/components/markdown-editor/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * MarkdownEditor — a field for writing markdown, and a way to see it rendered.
+ *
+ * ```tsx
+ * const [draft, setDraft] = useState('');
+ *
+ * <MarkdownEditor value={draft} onValueChange={setDraft} rows={12} />
+ * ```
+ *
+ * ## Writing and reading are two modes, not two panes
+ *
+ * Side by side is how this is done on a desktop, and it does not survive the
+ * trip to a phone: two columns of a phone's width are two columns too narrow to
+ * read, and the keyboard covers the bottom half of the screen exactly when the
+ * writer is using it. So there is one pane and a switch — write, or read what
+ * you wrote. The toolbar carries the switch, because the toolbar is the one
+ * thing on screen in both modes.
+ *
+ * ## The toolbar edits the selection
+ *
+ * Every button here is a function of the text and where the caret is in it, and
+ * the answer that matters is not which characters get inserted but where the
+ * caret lands afterwards. Bolding a selected phrase leaves it selected, so it
+ * can be italicised next; bolding nothing puts the caret between the new
+ * markers, where the writing is about to go; and pressing the same button again
+ * takes the markers off. Those rules live in `markdown-transforms.ts` as pure
+ * functions over `(text, selection)`, away from anything to do with a field.
+ *
+ * ## Why it renders through Response
+ *
+ * The preview is `Response`, the same reader that renders a model's answer, so
+ * markdown means the same thing everywhere in the library and there is one
+ * parser to be right rather than two to keep in step. It renders through
+ * `Typography`, `CodeBlock` and `Table`, which is to say through the app's own
+ * type and colours — a preview that looked like a document viewer would be
+ * showing the writer something they are not going to ship.
+ *
+ * Nothing here reaches for a platform markdown renderer. `Text` in SwiftUI can
+ * parse markdown and Jetpack Compose's cannot, so a platform-backed editor
+ * would render on one of the two and be a plain string on the other.
+ *
+ * Works controlled (`value` + `onValueChange`) or uncontrolled (`defaultValue`).
+ */
+import { type ReactNode } from 'react';
+import { View, type TextInput, type ViewProps } from 'react-native';
+import { type TextareaProps } from '../textarea/index.js';
+export type { EditorSelection, EditResult } from './markdown-transforms.js';
+/** Which pane the editor is showing. */
+export type MarkdownEditorMode = 'write' | 'preview';
+/** A formatting action the toolbar can offer. */
+export type MarkdownEditorAction = 'bold' | 'italic' | 'heading' | 'quote' | 'code' | 'bulletList' | 'orderedList' | 'link';
+export interface MarkdownEditorProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Controlled text. Leave unset and pass `defaultValue` to run uncontrolled. */
+    value?: string;
+    /** Starting text when uncontrolled. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Controlled pane. */
+    mode?: MarkdownEditorMode;
+    /** Starting pane when uncontrolled. */
+    defaultMode?: MarkdownEditorMode;
+    onModeChange?: (mode: MarkdownEditorMode) => void;
+    /** Stop the field being edited and the toolbar being pressed. */
+    disabled?: boolean;
+    /**
+     * The parts, in the order they should stack. Left out, the editor draws its
+     * toolbar, its field and its preview in that order — which is the whole
+     * component, and the reason it usually needs no children.
+     */
+    children?: ReactNode;
+    /** Forwarded to the field when the editor draws its own. */
+    placeholder?: string;
+    /** Height of the field, in lines. Forwarded to the field the editor draws. */
+    rows?: number;
+}
+export interface MarkdownEditorToolbarProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** Which formatting actions to offer, in the order given. */
+    actions?: MarkdownEditorAction[];
+    /**
+     * Show the write/preview switch. On by default — a preview nobody can reach
+     * is a pane that does not exist.
+     */
+    showModeSwitch?: boolean;
+    /** Anything else to put on the row: a word count, a save state, a submit. */
+    children?: ReactNode;
+}
+export interface MarkdownEditorInputProps extends Omit<TextareaProps, 'value' | 'onChangeText' | 'defaultValue'> {
+    className?: string;
+}
+export interface MarkdownEditorPreviewProps extends Omit<ViewProps, 'children'> {
+    className?: string;
+    /** What to show when there is nothing written yet. */
+    emptyText?: string;
+}
+export declare const MarkdownEditor: import("react").ForwardRefExoticComponent<MarkdownEditorProps & import("react").RefAttributes<View>> & {
+    Toolbar: import("react").ForwardRefExoticComponent<MarkdownEditorToolbarProps & import("react").RefAttributes<View>>;
+    Input: import("react").ForwardRefExoticComponent<MarkdownEditorInputProps & import("react").RefAttributes<TextInput>>;
+    Preview: import("react").ForwardRefExoticComponent<MarkdownEditorPreviewProps & import("react").RefAttributes<View>>;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/markdown-editor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/markdown-editor/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,OAAO,EAQL,KAAK,SAAS,EACf,MAAM,OAAO,CAAC;AACf,OAAO,EACL,IAAI,EAEJ,KAAK,SAAS,EAEd,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAmBtB,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,sBAAa,CAAC;AAW3D,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,0BAAuB,CAAC;AAEzE,wCAAwC;AACxC,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD,iDAAiD;AACjD,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,QAAQ,GACR,SAAS,GACT,OAAO,GACP,MAAM,GACN,YAAY,GACZ,aAAa,GACb,MAAM,CAAC;AAwGX,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gFAAgF;IAChF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,uBAAuB;IACvB,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,uCAAuC;IACvC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAClD,iEAAiE;IACjE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA0HD,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACjC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAmED,MAAM,WAAW,wBACf,SAAQ,IAAI,CAAC,aAAa,EAAE,OAAO,GAAG,cAAc,GAAG,cAAc,CAAC;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAoDD,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CAAC,SAAS,EAAE,UAAU,CAAC;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA+BD,eAAO,MAAM,cAAc;;;;CAIzB,CAAC"}

package/lib/typescript/src/components/markdown-editor/markdown-transforms.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The edits a formatting toolbar makes, as functions of the text and where the
+ * caret is in it.
+ *
+ * Pure, and deliberately so. Every one of these takes `(text, selection)` and
+ * returns the text that should replace it together with where the selection
+ * should end up — no component, no ref, no input. What makes a formatting
+ * toolbar feel broken is never the characters it inserts; it is where the caret
+ * lands afterwards, and that is a property of these functions rather than of
+ * the field they are wired to.
+ *
+ * Three rules they all keep:
+ *
+ * - **Applying twice undoes it.** A toolbar button that only ever adds is a
+ *   button you can press once, and every press after that damages the text.
+ * - **A selection stays selected.** Bolding three words and then italicising
+ *   the same three has to be two presses, not a press and a re-selection.
+ * - **With nothing selected, the caret lands where the writing goes** — between
+ *   the new markers rather than after them.
+ */
+export interface EditorSelection {
+    start: number;
+    end: number;
+}
+export interface EditResult {
+    text: string;
+    selection: EditorSelection;
+}
+/**
+ * Wraps the selection in `marker`, or unwraps it if it is already wrapped.
+ *
+ * "Already wrapped" is checked both ways round: the markers may be inside the
+ * selection (the writer selected `**bold**`) or immediately outside it (they
+ * selected `bold` in the middle of `**bold**`). Both are the same intent, and a
+ * toolbar that only recognised one of them would add a second pair of asterisks
+ * to text that already had them.
+ */
+export declare function toggleWrap(text: string, selection: EditorSelection, marker: string): EditResult;
+/**
+ * Puts `prefix` on the front of every line the selection touches, or takes it
+ * off if every one of them already has it.
+ *
+ * Every one, not any one: a mixed block is a block the writer is trying to make
+ * uniform, so the useful answer there is to add rather than to remove.
+ */
+export declare function toggleLinePrefix(text: string, selection: EditorSelection, prefix: string): EditResult;
+/**
+ * Numbers the lines the selection touches, or unnumbers them.
+ *
+ * Counted from one within the block rather than continuing whatever came above
+ * it: the numbers a writer types are not the numbers that get rendered — every
+ * markdown reader renumbers an ordered list from its first item — so the useful
+ * thing is for the source to read the way the output will.
+ */
+export declare function toggleOrderedList(text: string, selection: EditorSelection): EditResult;
+/** Placeholder left where a link's target goes. */
+export declare const LINK_PLACEHOLDER = "url";
+/**
+ * Turns the selection into a link, and selects the part that still needs
+ * filling in.
+ *
+ * Which part that is depends on what was selected. With text selected, the
+ * label is written and the target is not, so the placeholder target is left
+ * selected and typing replaces it. With nothing selected there is neither, and
+ * the label comes first because it is the half the writer is thinking about.
+ */
+export declare function insertLink(text: string, selection: EditorSelection): EditResult;
+/**
+ * Puts the selected lines in a fence, or takes them out of one.
+ *
+ * A fence is the one construct that has to sit on lines of its own, so this
+ * makes room for itself: a blank line before it when it is not already at the
+ * start of a paragraph, and one after it at the end.
+ */
+export declare function toggleFence(text: string, selection: EditorSelection): EditResult;
+//# sourceMappingURL=markdown-transforms.d.ts.map

package/lib/typescript/src/components/markdown-editor/markdown-transforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-transforms.d.ts","sourceRoot":"","sources":["../../../../../src/components/markdown-editor/markdown-transforms.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,eAAe,CAAC;CAC5B;AAaD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,eAAe,EAC1B,MAAM,EAAE,MAAM,GACb,UAAU,CAmCZ;AAiCD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,eAAe,EAC1B,MAAM,EAAE,MAAM,GACb,UAAU,CASZ;AAKD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,eAAe,GACzB,UAAU,CAQZ;AAMD,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AAEtC;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,GAAG,UAAU,CAY/E;AAMD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,GAAG,UAAU,CAiBhF"}

package/lib/typescript/src/components/pie-chart/index.d.ts

@@ -0,0 +1,245 @@
+/**
+ * PieChart — one whole, divided between its parts.
+ *
+ * ```tsx
+ * <PieChart data={spend} innerRadius={0.58}>
+ *   <PieChart.Header title="This month" value="$18,420" legend />
+ *   <PieChart.Slices />
+ *   <PieChart.Center />
+ * </PieChart>
+ * ```
+ *
+ * ## What it is, against the ring beside it
+ *
+ * A ring chart draws a value against *its own* target, so three rings can all
+ * sit at ninety percent of three unrelated numbers and nothing has to add up.
+ * A pie is the opposite claim: every slice is a share of one total, the angles
+ * must come to a full turn, and a slice only means anything next to the others.
+ * That is why nothing here takes a `maxValue` and why every value is normalised
+ * against the sum — the sum *is* the subject.
+ *
+ * It follows that a pie is the wrong shape for a great many things. Two numbers
+ * that do not belong to one whole, a series over time, anything a reader has to
+ * compare precisely: all of those are a bar chart, because an angle is the
+ * hardest quantity to read off a page and the fifth-largest slice of eleven is
+ * not a fact anybody is going to extract. Use it for a handful of parts of one
+ * obvious total, and put the number in the middle.
+ *
+ * ## Drawing
+ *
+ * Each slice is a filled path rather than a stroked arc, because a slice is a
+ * *region* — two arcs and two radial edges — and a stroke is a band of even
+ * thickness with no ends of its own. `wedgePath` builds it, and rebuilds it on
+ * the UI thread on every frame of the reveal.
+ *
+ * That is what makes the reveal an unroll rather than a fade: one angle sweeps
+ * clockwise from the start and each slice is drawn only as far as it has got
+ * to. The pie fills the way it would be drawn by hand, and the slices arrive in
+ * the order they are listed rather than all at once.
+ *
+ * Touch, not hover: a slice is selected by pressing it, and pressing the same
+ * one again clears the selection. There is no equivalent of a pointer resting
+ * somewhere without committing, so a chart that only revealed its numbers on
+ * hover would never reveal them at all.
+ */
+import { type ReactNode } from 'react';
+import { type ViewProps } from 'react-native';
+/** Whether the chart is showing data or waiting for it. */
+export type PieChartStatus = 'loading' | 'ready';
+/** One slice. Its share is worked out from the others, so there is no maximum. */
+export interface PieDatum {
+    /** Name for the legend, the centre readout and the accessibility label. */
+    label: string;
+    /** How much of the whole this slice is. Negatives are treated as zero. */
+    value: number;
+    /** Explicit colour, overriding the `--color-chart-*` token. */
+    color?: string;
+}
+/** The selected slice and its share, for something rendered inside the chart. */
+export declare function usePieChart(): {
+    activeIndex: number;
+    activeSlice: PieDatum | null;
+    /** The selected slice's share of the whole, 0 to 1. */
+    activeFraction: number;
+};
+export interface PieChartProps extends ViewProps {
+    className?: string;
+    /** One entry per slice, in the order they are drawn clockwise. */
+    data: PieDatum[];
+    /** Fixed diameter in points. Measured from the container when omitted. */
+    size?: number;
+    /**
+     * The hole, as a share of the radius. `0` is a pie; anything above it is a
+     * donut, and `0.55`–`0.65` is the range that leaves room for a readout in the
+     * middle without the band getting thin enough to be hard to hit.
+     *
+     * Given as a share rather than in points so a chart keeps its proportions at
+     * whatever size it is measured at.
+     */
+    innerRadius?: number;
+    /** Where the first slice begins, in degrees clockwise from twelve o'clock. */
+    startAngle?: number;
+    /**
+     * Where the last one ends, on the same clock. Leaving a turn's worth between
+     * the two gives a closed pie; anything less leaves a gap and reads as a dial.
+     */
+    endAngle?: number;
+    /** Gap between one slice and the next, in degrees. */
+    padAngle?: number;
+    /**
+     * The smallest angle any non-zero slice is drawn at, in degrees.
+     *
+     * A slice worth a fifth of a percent is a hairline nobody can see and nobody
+     * can press, so it reads as missing rather than as small — and "missing" is a
+     * different claim from "nearly none". The angle it borrows comes off the
+     * others in proportion, so the turn still closes.
+     */
+    minAngle?: number;
+    /** Milliseconds for the pie to unroll. */
+    animationDuration?: number;
+    /** `loading` draws a plain muted ring until the data arrives. */
+    status?: PieChartStatus;
+    /** Selected slice. Leave unset to let the chart track it. */
+    activeIndex?: number;
+    /** Fires with the selected slice, or `-1` when the selection is cleared. */
+    onActiveIndexChange?: (index: number) => void;
+    children?: ReactNode;
+}
+/** Imperative handle: re-run the unroll, for a "replay" control. */
+export interface PieChartHandle {
+    replay: () => void;
+}
+export interface PieChartSlicesProps {
+    /** Rounds the four turns of each slice, in points. */
+    cornerRadius?: number;
+    /** How far a selected slice lifts out of the pie, in points. */
+    popOut?: number;
+    /** Opacity of the slices that are not selected, once one is. */
+    dimOpacity?: number;
+}
+/**
+ * Every slice, drawn in the order the data lists them.
+ *
+ * One part rather than one per datum, unlike the rings next door. A ring is
+ * configured on its own — its own thickness, its own cap, its own segment count
+ * — because it is its own measurement. Slices of a pie are not: they share a
+ * radius, a hole and a dial by definition, and a chart where one of them could
+ * be given a different radius would be a chart drawing a lie.
+ */
+declare function PieChartSlices({ cornerRadius, popOut, dimOpacity, }: PieChartSlicesProps): import("react").JSX.Element | null;
+declare namespace PieChartSlices {
+    var displayName: string;
+    var slot: "svg";
+}
+export interface PieChartSkeletonProps {
+    color?: string;
+}
+/**
+ * The loading state: the dial as one plain band, with nothing divided up yet.
+ *
+ * Deliberately undivided. Placeholder slices would be a made-up split, and a
+ * reader has no way to tell an invented one from a real one until it changes
+ * under them — which is worse than showing nothing, because it is showing
+ * something wrong.
+ */
+declare function PieChartSkeleton({ color }: PieChartSkeletonProps): import("react").JSX.Element | null;
+declare namespace PieChartSkeleton {
+    var displayName: string;
+    var slot: "svg";
+}
+export interface PieChartCenterProps {
+    /** Heading shown when no slice is selected. */
+    defaultLabel?: string;
+    /** Format the number under the label. Defaults to a compact number. */
+    formatValue?: (value: number, slice: PieDatum | null) => string;
+    /**
+     * Draw the middle yourself. Given the selected slice, or `null` when nothing
+     * is selected.
+     */
+    children?: (slice: PieDatum | null) => ReactNode;
+    className?: string;
+}
+/**
+ * The hole's readout: the total, and the selected slice's own figures once one
+ * is picked.
+ *
+ * Unlike the ring chart's centre, the default here *is* an aggregate, and it is
+ * the honest one — the whole point of a pie is that its parts belong to a total,
+ * so the total is the number the chart is about. Selecting a slice swaps it for
+ * that slice's value and its share.
+ */
+declare function PieChartCenter({ defaultLabel, formatValue, children, className, }: PieChartCenterProps): import("react").JSX.Element | null;
+declare namespace PieChartCenter {
+    var displayName: string;
+    var slot: "overlay";
+}
+export interface PieChartLegendProps extends ViewProps {
+    className?: string;
+    /** Show each slice's share of the whole beside its name. */
+    showValue?: boolean;
+}
+/**
+ * A swatch, a name and a share per slice, under the chart and across the width
+ * of it. Pressable in the same way the slices are — the legend is usually the
+ * easier target of the two, and a slice worth a couple of percent is not a
+ * target at all.
+ *
+ * It wraps rather than stacking, so five or six entries take two lines instead
+ * of six. A key is a lookup table, and a lookup table read down a column of one
+ * word each is a column the eye has to walk.
+ */
+declare function PieChartLegend({ className, showValue, ...props }: PieChartLegendProps): import("react").JSX.Element | null;
+declare namespace PieChartLegend {
+    var displayName: string;
+    var slot: "footer";
+}
+export interface PieChartHeaderProps extends ViewProps {
+    className?: string;
+    /** Small line above the value — what the chart is of. */
+    title?: string;
+    /** The readout. The largest thing on the card, and the first thing read. */
+    value?: string;
+    /** One muted line under the value — a period, a comparison, a caveat. */
+    caption?: string;
+    /** Prettier names for the slices, keyed by their `label`. */
+    labels?: Record<string, string>;
+    /**
+     * Draw a swatch and a name per slice along the trailing edge.
+     *
+     * For two or three short names. Past that use `PieChart.Legend`, which runs
+     * under the chart across the full width: a key of five long names crammed
+     * into the trailing corner of a header wraps to a column and leaves the title
+     * beside it a few points wide.
+     */
+    legend?: boolean;
+    /** Trailing slot — a control, a badge, a range picker. Wins over `legend`. */
+    children?: ReactNode;
+}
+/**
+ * The strip above the pie: what the chart is of, what it reads, and what the
+ * colours mean.
+ *
+ * It belongs to the chart rather than to the card around it because it is about
+ * the *slices* — the number changes as one is selected, and the legend is the
+ * list the chart itself is holding. The card's header is a caption on the tray
+ * the chart sits in; this is the chart introducing itself.
+ *
+ * The value is not derived here even though there is a total to derive it from,
+ * because the formatting is not the chart's to guess: a total of 18420 is a
+ * count, a currency or a percentage depending on what was counted, and only the
+ * caller knows which.
+ */
+declare function PieChartHeader({ className, title, value, caption, labels, legend, children, ...props }: PieChartHeaderProps): import("react").JSX.Element;
+declare namespace PieChartHeader {
+    var displayName: string;
+    var slot: "header";
+}
+export declare const PieChart: import("react").ForwardRefExoticComponent<PieChartProps & import("react").RefAttributes<PieChartHandle>> & {
+    Header: typeof PieChartHeader;
+    Slices: typeof PieChartSlices;
+    Center: typeof PieChartCenter;
+    Legend: typeof PieChartLegend;
+    Skeleton: typeof PieChartSkeleton;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/components/pie-chart/index.d.ts.map

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