@sheetxl/primitives 0.7.22 → 0.7.23-beta.1

package/types/src/IFormulaContext.d.ts

@@ -0,0 +1,533 @@
+import { Scalar } from './Scalar';
+import { FormulaError } from './FormulaError';
+import { IRange } from './IRange';
+import { IReferenceRange } from './IReferenceRange';
+import { IFunction } from './IFunction';
+import { IRuntime } from './IRuntime';
+/**
+ * Everything a formula function is allowed to know about the world outside its arguments.
+ *
+ * @remarks
+ * Formula functions are pure — they cannot reach the workbook, the sheet they sit on, or
+ * the clock. `FormulaContext` is the one channel that gives them sheet data, cell
+ * coordinates, date and number parsing, and evaluation hints without giving up that purity.
+ *
+ * Import it and call its methods directly; there is nothing to construct or thread through
+ * arguments. Every call is already scoped to the cell being evaluated:
+ *
+ * ```typescript
+ * import { FormulaContext } from '@sheetxl/primitives';
+ *
+ * export function ROWNUMBER(): number {
+ *   return FormulaContext.getRow() + 1;
+ * }
+ * ```
+ *
+ * ### Capabilities
+ *
+ * | Category | Key methods |
+ * |---|---|
+ * | Evaluation lifecycle | `markVolatile`, `getRow`, `getColumn`, `getEntireCoords` |
+ * | Output hints | `formatResults` |
+ * | Range construction | `createRange`, `filterHidden` |
+ * | Dynamic references | `getReference`, `getValueAt`, `getFormulaAt`, `getSpillAt` |
+ * | Function lookup | `getFunction` |
+ * | Dates | `getNow`, `toSerialDate`, `fromSerialDate`, `getDateParts`, `getSerialDate`, `parseAsDate`, `parseAsSerialDate`, `isValidDate` |
+ * | Coercion | `parseAsNumber`, `parseAsLiteral`, `toText`, `compare` |
+ * | Criteria | `createCriteria` |
+ * | Sheet introspection | `getSheetCount`, `getSheetIndex`, `getAddress`, `getNumberFormat` |
+ *
+ * ### Implementors
+ *
+ * The calculation engine provides the implementation. Third-party code (UDF packages, test
+ * harnesses) may supply its own for isolated evaluation or unit testing.
+ */
+export interface IFormulaContext {
+    /**
+     * Creates a range to return as a dynamic array result.
+     *
+     * @param rows The number of rows of the range. Default is 0.
+     * @param columns The number of columns of the range. Default is 0.
+     * @param values A single value to fill the range with, a grid of values, or a callback
+     * invoked per cell. Default is `null` (an empty range).
+     */
+    createRange<TS extends Scalar = Scalar>(rows?: number, columns?: number, values?: Scalar | Scalar[][] | ((value: TS, coords: IRange.CellCoords, range: IRange<TS>) => TS)): IRange;
+    /**
+     * Returns coordinates as an address string.
+     *
+     * @param coords The coordinates to get the address for. If not provided the current position is used.
+     * @param r1c1 If `true`, the address will be in R1C1 format. Default is `false` (A1 format).
+     */
+    getAddress(coords?: Readonly<IRange.FixableCoords | IRange.FixableCellCoords>, r1c1?: boolean): string;
+    /**
+     * Looks up another formula function so it can be called from yours.
+     *
+     * @param name The name of the function. Case-insensitive.
+     * @returns The function, or `null` if no function is registered under that name.
+     */
+    getFunction(name: string): IFunction | null;
+    /**
+     * Returns the coordinates of the entire sheet.
+     *
+     * @remarks
+     * Useful for bounds-checking a range before building it.
+     */
+    getEntireCoords(): IRange.Coords;
+    /**
+     * Formats a value with a number format, as a cell would display it.
+     *
+     * @param formatText The number format to apply.
+     * @param value The value to format.
+     * @returns The formatted text, or `null` if the format cannot be applied.
+     *
+     * @remarks
+     * This backs the `TEXT` function. For plain coercion to text use {@link toText}.
+     */
+    getNumberFormat(formatText: string, value: Scalar): string | null;
+    /**
+     * Returns the 0-based row of the cell being evaluated.
+     */
+    getRow(): number;
+    /**
+     * Returns the 0-based column of the cell being evaluated.
+     */
+    getColumn(): number;
+    /**
+     * Resolves a range reference at runtime, returning an {@link IReferenceRange}.
+     *
+     * Use this when the address is computed from arguments rather than known at parse time,
+     * as `INDIRECT`, `OFFSET`, and `SUMIF` do.
+     *
+     * @param coords The coordinates or address string of the range to resolve. If not provided
+     * the current location is used.
+     * @param r1c1 If `true`, the string is interpreted in R1C1 format.
+     * @returns An {@link IReferenceRange} representing the resolved range.
+     * @throws `#REF!` If the range cannot be parsed or resolved.
+     * @throws `#NAME?` If the string resolves to an unknown named formula or sheet.
+     *
+     * @remarks
+     * Each call adds a tracked dependency: the function is re-evaluated whenever the resolved
+     * range's data changes or its address moves. Prefer {@link getValueAt} when a plain value
+     * will do.
+     */
+    getReference(coords?: Readonly<IRange.Coords> | string, r1c1?: boolean): IReferenceRange<any>;
+    /**
+     * Resolves an ANCHOR-PLUS-LENGTH argument at runtime, returning an {@link IReferenceRange}
+     * clamped to the grid.
+     *
+     * A few arguments honor only their top-left corner and are re-sized to the shape of the range
+     * that drives them — `SUMIF`'s `sum_range`, `LOOKUP`'s `result_vector`. The window can therefore
+     * run off the bottom or right of the grid: `SUMIF(A1:A5,">0",A1048574)` asks for five rows
+     * starting three from the end. Excel reads the part that fits and treats the rest as blank, which
+     * is what this returns; positions past the clamp read as `undefined` from `getValueAt`.
+     *
+     * @param anchor The coords of the argument as written; only its top-left corner is honored.
+     * @param rowCount The height the driving range gives the window.
+     * @param colCount The width the driving range gives the window.
+     *
+     * @remarks
+     * Use {@link getReference} for a reference that is the function's RESULT: an unformable window is
+     * `#REF!` there rather than a short read. The clamp belongs to this handful of arguments only.
+     *
+     * The extent clamped against is the ANCHOR's sheet, which is not necessarily the sheet being
+     * evaluated — {@link getEntireCoords} answers for the latter.
+     */
+    getResizedReference(anchor: Readonly<IRange.Coords>, rowCount: number, colCount: number): IReferenceRange<any>;
+    /**
+     * Reads the formula text of a cell.
+     *
+     * @param row The row of the cell.
+     * @param column The column of the cell.
+     * @param sheetName The name of the sheet. If not provided the current sheet is used.
+     * @returns The formula text, or `null` if the cell has no formula.
+     */
+    getFormulaAt(row: number, column: number, sheetName?: string): string | null;
+    /**
+     * Returns the spill range anchored at a cell.
+     *
+     * @param row The row where the spill starts.
+     * @param column The column where the spill starts.
+     * @param sheetName The name of the sheet. If not provided the current sheet is used.
+     * @returns The spilled range, or `null` if nothing spills from that cell.
+     */
+    getSpillAt(row: number, column: number, sheetName?: string): IReferenceRange | null;
+    /**
+     * Reads the value of a cell.
+     *
+     * @param row The row of the cell.
+     * @param column The column of the cell.
+     * @param sheetName The name of the sheet. If not provided the current sheet is used.
+     * @param options Optional parameters for retrieving the value.
+     * @returns The value at the cell, or `null` if the cell is empty.
+     *
+     * @remarks
+     * Unlike {@link getReference}, this does not add a tracked dependency.
+     */
+    getValueAt(row: number, column: number, sheetName?: string, options?: IRange.ValueOptions): Scalar | null;
+    /**
+     * Returns the number of sheets in the workbook.
+     */
+    getSheetCount(): number | null;
+    /**
+     * Returns the 0-based index of a sheet.
+     *
+     * @param sheet The name of a sheet, or a reference to resolve to the sheet it is on.
+     *              If not provided the current sheet is used.
+     * @returns -1 If the sheet does not exist.
+     */
+    getSheetIndex(sheet?: string | IReferenceRange): number;
+    /**
+     * Returns a copy of a range with hidden rows or columns removed.
+     *
+     * @param range The range to filter.
+     * @param axes Which axis to filter on. Default is `IRange.AxisSelection.Row`.
+     * @returns A new range without the hidden rows or columns.
+     *
+     * @remarks
+     * Use this for functions that ignore hidden data, such as `SUBTOTAL`.
+     */
+    filterHidden(range: IRange, axes?: IRange.AxisSelection): IRange;
+    /**
+     * Returns a copy of a range with any cell whose formula is a nested total removed.
+     *
+     * @param range The range to filter.
+     * @returns A new range without the nested totals, or `range` itself when there are none.
+     *
+     * @remarks
+     * Use this for functions that must not double-count a total that sits inside their own data —
+     * `SUBTOTAL` and `AGGREGATE`, which is also the pair being looked for. Excluding a cell and
+     * blanking it are equivalent for every code either function offers (all are order-independent
+     * and all ignore blanks), so removal is the simpler contract.
+     *
+     * A cell qualifies when its formula CALLS `SUBTOTAL` or `AGGREGATE` anywhere in its tree —
+     * `=SUM(SUBTOTAL(9,A1:A3))` is excluded — and not when it merely references one: `=A4`, where A4
+     * holds a subtotal, is ordinary data. `function_num` is irrelevant, and the two functions are
+     * symmetric (either excludes either).
+     *
+     * Exclusion is per CELL, not per row: with a subtotal in `A4` and a plain `99` in `B4`,
+     * `SUBTOTAL(9,A1:B4)` drops only `A4` and keeps the 99.
+     */
+    filterTotals(range: IRange): IRange;
+    /**
+     * Suggests a number format for this function's result.
+     *
+     * @param numFmt The number format to apply to the result.
+     *
+     * @remarks
+     * A hint, not a command — the format is applied only where the user has not already
+     * chosen one. When a range is returned every cell takes the same format.
+     */
+    formatResults(numFmt: string): void;
+    /**
+     * Marks this function as volatile, so it re-evaluates on every calculation.
+     *
+     * @remarks
+     * Call this when the result depends on something outside the arguments, such as the clock.
+     * A function can also be declared volatile in its registration instead.
+     */
+    markVolatile(): void;
+    /**
+     * Coerces a value to a serial date.
+     *
+     * @param textOrNumber The text or number to parse.
+     * @param requireDate If `true`, text must carry a date component; a time alone is rejected.
+     * @returns The serial date.
+     * @throws `#VALUE!` If the value cannot be read as a date.
+     * @throws The original error, unchanged, if the value is already an error (`#N/A` stays `#N/A`).
+     */
+    parseAsSerialDate(textOrNumber: Scalar, requireDate?: boolean): number;
+    /**
+     * Coerces a value to a JavaScript `Date`.
+     *
+     * @param serialOrString The serial number, text, or `Date` to parse.
+     * @param requireDate If `true`, text must carry a date component; a time alone is rejected.
+     * @returns The date.
+     * @throws `#VALUE!` If the value cannot be read as a date.
+     * @throws The original error, unchanged, if the value is already an error (`#N/A` stays `#N/A`).
+     *
+     * @remarks
+     * Prefer {@link getDateParts} for calendar arithmetic — see the note there.
+     */
+    parseAsDate(serialOrString: string | number | Date | any, requireDate?: boolean): Date;
+    /**
+     * Coerces a value to a number.
+     *
+     * @param textOrNumber The text or number to parse.
+     * @param options Additional parsing options.
+     * @returns The number.
+     * @throws `#VALUE!` If the value cannot be read as a number.
+     * @throws The original error, unchanged, if the value is already an error (`#N/A` stays `#N/A`).
+     */
+    parseAsNumber(textOrNumber: Scalar, options?: IFormulaContext.ParseNumberOptions): number;
+    /**
+     * `undefined` passes straight through, so an optional argument that was omitted stays omitted.
+     */
+    parseAsNumber(textOrNumber: Scalar | undefined, options?: IFormulaContext.ParseNumberOptions): number | undefined;
+    /**
+     * Compiles criteria text into a predicate.
+     *
+     * @param criteria The criteria, exactly as the user wrote it — a comparison (`">10"`, `"<>x"`),
+     * a wildcard pattern (`"a*"`), or a literal of any type.
+     * @returns A predicate to test cell values with. Call it once per cell.
+     *
+     * @remarks
+     * This is the rule behind `COUNTIF`/`SUMIF`/`AVERAGEIF`, their `*IFS` forms, and the `D`
+     * functions' criteria table, so reach for it in any function that takes a criteria rather than
+     * parsing one — a criteria touches all three localization planes at once (a number in the
+     * workbook's locale, a boolean word or error label in its language, text in its collation), and
+     * they are easy to get subtly wrong one at a time.
+     *
+     * Compile ONCE and apply the predicate across the range; the parse is not free, and a criteria
+     * does not vary per cell.
+     *
+     * Offer BLANK cells to the predicate rather than skipping them — a blank is what `""` and `"<>"`
+     * select, and `"<>x"` matches one too.
+     *
+     * @example
+     * ```typescript
+     * const matches = FormulaContext.createCriteria(">10");
+     * const count = range.reduce((total, value) => matches(value) ? total + 1 : total, 0);
+     * ```
+     */
+    createCriteria(criteria: Scalar): IFormulaContext.CriteriaEvaluator;
+    /**
+     * Reads a typed literal in the workbook's language — the parse side of {@link toText}.
+     *
+     * @param text The text to read.
+     * @returns The boolean or error the text spells, or `undefined` when it spells neither and is
+     * therefore just text.
+     *
+     * @remarks
+     * Booleans and error labels are the two values whose SPELLING follows the spreadsheet language
+     * rather than the workbook locale — `WAHR` is `TRUE` and `#WERT!` is `#VALUE!` in a German
+     * workbook, the same plane {@link toText} writes them on. Reach for this wherever a function
+     * interprets text the user typed; criteria (`COUNTIF(range, "WAHR")`) is the built-in case.
+     *
+     * The canonical English spelling is ALWAYS accepted alongside the localized one, so text that
+     * came from storage or an API reads the same under every language. This is how the formula
+     * compiler reads a typed literal, and matching it is the point.
+     *
+     * Numbers are not literals here. They follow the workbook LOCALE (the decimal separator) rather
+     * than the language, and belong to {@link parseAsNumber}.
+     */
+    parseAsLiteral(text: string): boolean | FormulaError.Known | undefined;
+    /**
+     * Coerces a value to text — the same rendering `&` and `CONCAT` produce.
+     *
+     * @param value The value to render. Text passes through unchanged, a blank
+     * (`null`/`undefined`) becomes `''`, and a boolean takes the workbook language's word
+     * (`TRUE`, `WAHR`). Numbers get 15 significant digits, plain decimal while the digits fit
+     * in 20 characters and scientific beyond that, using the workbook's decimal separator.
+     * @returns The rendered text.
+  
+     * @remarks
+     * Reach for this whenever a function needs to treat an argument as text.
+     *
+     * This is coercion, not display. A cell's General format and `TEXT(value, "General")` are
+     * fitted to the column and round much harder — `TEXT(2^0.5, "General")` is `1.414213562`
+     * where coercion gives `1.4142135623731`. Use {@link getNumberFormat} when you want what
+     * the user sees.
+     */
+    toText(value: Scalar | undefined): string;
+    /**
+     * Orders two values the way the comparison operators do.
+     *
+     * @param a The left value.
+     * @param b The right value.
+     * @param options Overrides the collator strength. Text only — see remarks.
+     * @returns Negative, zero, or positive, like any JS comparator.
+     *
+     * @remarks
+     * This is the single rule behind `=`, `<>`, `<`, `<=`, `>`, `>=`, so use it for any
+     * comparison, equality included (`compare(a, b) === 0`). It ranks across types
+     * (`number` &lt; `text` &lt; `FALSE` &lt; `TRUE`) rather than coercing, reads a blank as
+     * the other operand's zero value, rounds numbers before comparing, and collates text
+     * case-insensitively in the workbook locale.
+     *
+     * Do not reach for `localeCompare` instead: it uses the host's locale rather than the
+     * workbook's, and does not sort the way a spreadsheet does.
+     *
+     * Errors order last so the comparator stays total, though operators never see that case —
+     * an error operand propagates first.
+     *
+     * `options` is for functions like `SORT` and `SORTBY` that expose case sensitivity as a
+     * user-facing toggle. It affects the text branch only; ranking, blanks, and numeric
+     * rounding are fixed.
+     */
+    compare(a: Scalar, b: Scalar, options?: Intl.CollatorOptions): number;
+    /**
+     * Returns the current date and time as a serial date.
+     *
+     * @returns The current date-time as a serial number.
+     *
+     * @remarks
+     * Always read the clock through this, never `Date.now()`. The time is fixed for the whole
+     * calculation pass, so every cell in one pass agrees, collaborators evaluating the same
+     * workbook agree, and tests can pin it. Pair it with {@link markVolatile} so the function
+     * picks up a fresh time on the next pass.
+     *
+     * This is a calendar clock, not a stopwatch — use `performance.now()` to measure elapsed time.
+     *
+     * @example
+     * ```typescript
+     * export function NOW(): number {
+     *   FormulaContext.markVolatile();
+     *   return FormulaContext.getNow();
+     * }
+     * ```
+     */
+    getNow(): number;
+    /**
+     * Returns `true` if the value is a usable date — either a `Date` or a number in the
+     * workbook's serial date range.
+     *
+     * @param value Any value to check.
+     * @param jsDateOnly If `true`, only a `Date` without a time component is accepted.
+     */
+    isValidDate(value: any, jsDateOnly?: boolean): boolean;
+    /**
+     * Converts a `Date` to a serial date.
+     *
+     * @param date The date to convert.
+     * @param dateOnly If `true`, the time of day is dropped and a whole-day serial is returned.
+     * Use this for calendar arithmetic (day counts, coupon schedules) so a stray time component
+     * cannot leak into the result.
+     *
+     * @remarks
+     * Serial dates are wall-clock: the date's local fields become the serial and no timezone
+     * enters the conversion. Read such dates back with `getFullYear`/`getMonth`/`getDate`,
+     * never the `getUTC*` accessors.
+     */
+    toSerialDate(date: Date, dateOnly?: boolean): number;
+    /**
+     * Converts a serial date to a `Date`.
+     *
+     * @param serialDate The serial date to convert.
+     * @param dateOnly If `true`, the fractional part is dropped and the time is midnight.
+     *
+     * @remarks
+     * The serial becomes the date's local fields — see {@link toSerialDate}. For date
+     * arithmetic prefer {@link getDateParts}.
+     */
+    fromSerialDate(serialDate: number, dateOnly?: boolean): Date;
+    /**
+     * Splits a serial date into its calendar and clock fields.
+     *
+     * @param serialDate The serial date to split.
+     * @param reuseParts Avoids allocating a fresh {@link IFormulaContext.DateParts}:
+     * - An object: the fields are written into THIS object, which is returned. The caller owns
+     *   the buffer's lifetime — do not hold onto a previous result across a reused call, each
+     *   call overwrites it in place. For code that calls this once per cell over a large range.
+     * - `true`: the fields are written into a shared scratch object and returned — for a
+     *   one-off caller (a single-value function like `YEAR`/`MONTH`/`DAY`) that just wants to
+     *   avoid the allocation without owning a buffer itself. The result must be consumed
+     *   immediately (read a field, done) — a second `true` call anywhere overwrites it.
+     * @throws `#NUM!` If the serial falls outside the workbook's calendar.
+     *
+     * @remarks
+     * Prefer this to {@link fromSerialDate} inside date functions. The spreadsheet calendar
+     * has two days a JS `Date` cannot hold — serial 0 (`1900-01-00`) and the legacy
+     * `1900-02-29` at serial 60 — and converting to a `Date` silently shifts them.
+     * {@link IFormulaContext.DateParts} is plain numbers and represents both.
+     */
+    getDateParts(serialDate: number, reuseParts?: IFormulaContext.DateParts | boolean): IFormulaContext.DateParts;
+    /**
+     * Builds a serial date from calendar and clock fields — the inverse of {@link getDateParts}.
+     *
+     * @remarks
+     * Fields may fall outside their normal range and carry, which is what makes `DATE` and
+     * `TIME` arithmetic work: month 13 is January of the next year, hour 50 is two days plus
+     * two hours, and `getSerialDate(1900, 1, 0)` is serial 0. The `day` carries in SERIAL
+     * space, so it runs through the phantom `1900-02-29` — measured 25/25 by
+     * `probe-date-1900-day-overflow.ps1`.
+     *
+     * **This validates nothing, and that is deliberate — a caller MUST choose its own
+     * policy.** No range check, no clamping, no bounds on any field, and no `DATE`-style
+     * `0..1899 -> +1900` year offset. Those belong to `DATE`'s ARGUMENTS, not to the
+     * calendar, and the three things that prove it were measured together
+     * (`probe-date-arg-layer.ps1`, 2026-08-20):
+     *
+     * * **The day policy is the caller's.** `DATE` and `DATEDIF`'s `md`/`yd` re-anchoring
+     *   want the raw carry above — `DATEDIF("2020-01-31","2020-03-01","md")` is `-1`
+     *   because Jan 31 rolls into March. `EDATE`/`EOMONTH` want the opposite and CLAMP to
+     *   the target month's length, so they pre-clamp before calling here. One conversion,
+     *   two opposite rules, both matching Excel. Baking either one in breaks the other.
+     * * **Results may legitimately leave the calendar.** `YEARFRAC` basis 1 anchors a year
+     *   length on January 1 of `laterYear + 1`, which at the top of the calendar is
+     *   `10000-01-01`; Excel answers `1.9972602739726026` for
+     *   `YEARFRAC(DATE(9998,1,1),DATE(9999,12,31),1)` rather than `#NUM!`. A range check
+     *   here would break it.
+     * * **The 16-bit argument limits are per-function.** `DATE`'s month errors outside
+     *   `[-32767, 32766]` while its day saturates to `32767`, and `TIME` errors outside
+     *   `[0, 32767]` on every argument — same magic number, three different rules.
+     *
+     * Note the asymmetry with {@link getDateParts}, which DOES throw `#NUM!` outside the
+     * calendar because it answers a user-facing question. An internal intermediate that
+     * steps one day past the end must therefore not be round-tripped through it; compute
+     * on the fields instead. That mistake made `YEARFRAC(DATE(9999,1,1),DATE(9999,12,31),0)`
+     * `#NUM!` where Excel says `1`.
+     */
+    getSerialDate(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millis?: number): number;
+    /**
+     * Returns information about the environment the formula is running in.
+     *
+     * @remarks
+     * Mostly for diagnostics; the built-in `INFO` function is built on it.
+     */
+    getRuntime(): IRuntime;
+}
+/**
+ * {@inheritDoc IFormulaContext}
+ *
+ * @see
+ * ### **Interface**
+ *
+ * {@link IFormulaContext}
+ */
+export declare namespace IFormulaContext {
+    /**
+     * Options for {@link IFormulaContext.parseAsNumber}.
+     */
+    interface ParseNumberOptions {
+    }
+    /**
+     * The predicate {@link IFormulaContext.createCriteria} returns.
+     *
+     * @remarks
+     * A blank cell arrives as `null` and is a meaningful input, not a value to skip — see the note
+     * there.
+     */
+    type CriteriaEvaluator = (value: Scalar) => boolean;
+    /**
+     * A serial date split into fields — see {@link IFormulaContext.getDateParts}.
+     *
+     * @remarks
+     * These are the spreadsheet calendar's fields, not the Gregorian one's: `day` may be
+     * `0` (`1900-01-00`) and February 1900 has 29 days.
+     */
+    interface DateParts {
+        /** Full year. */
+        readonly year: number;
+        /** 1 = January ... 12 = December. */
+        readonly month: number;
+        /** Day of month, 1-based. `0` for `1900-01-00`. */
+        readonly day: number;
+        /** Hour on a 24-hour clock. */
+        readonly hour: number;
+        /** Minute of the hour. */
+        readonly minute: number;
+        /** Second of the minute. */
+        readonly second: number;
+        /** Milliseconds. */
+        readonly millis: number;
+        /**
+         * Day of week, 1 = Monday ... 7 = Sunday.
+         *
+         * @remarks
+         * Derived from the serial throughout, so below serial 61 it follows the legacy
+         * calendar rather than the real one. This is the same value `ddd`/`dddd` render.
+         */
+        readonly dow: number;
+    }
+}
+//# sourceMappingURL=IFormulaContext.d.ts.map

package/types/src/IFormulaContext.d.ts.map

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