@rowsncolumns/utils 9.2.35

package/dist/cjs/typeguards.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNilOrBlank = exports.isNil = exports.isDefined = void 0;
+// Typeguards
+var isDefined = function (val) {
+    return val !== undefined && val !== null;
+};
+exports.isDefined = isDefined;
+// Typeguards isNil
+var isNil = function (value) { return !(0, exports.isDefined)(value); };
+exports.isNil = isNil;
+var isNilOrBlank = function (value) {
+    return (0, exports.isNil)(value) || String(value).trim() === "";
+};
+exports.isNilOrBlank = isNilOrBlank;

package/dist/cjs/uuid.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generate a random uuid
+ * Conform to Google Sheet 9 Digit ID
+ * @returns
+ */
+export declare const uuid: () => number;
+export declare const uuidString: () => string;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/cjs/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../uuid.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,IAAI,cAA0D,CAAC;AAE5E,eAAO,MAAM,UAAU,cAqBtB,CAAC"}

package/dist/cjs/uuid.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidString = exports.uuid = void 0;
+/**
+ * Generate a random uuid
+ * Conform to Google Sheet 9 Digit ID
+ * @returns
+ */
+var uuid = function () { return Math.floor(Math.random() * 900000000) + 100000000; };
+exports.uuid = uuid;
+var uuidString = function () {
+    // Check for crypto in various environments (Node.js, browser, etc.)
+    var cryptoObj = typeof crypto !== "undefined"
+        ? crypto
+        : typeof window !== "undefined" && window.crypto
+            ? window.crypto
+            : typeof global !== "undefined" && global.crypto
+                ? global.crypto
+                : null;
+    if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+        return cryptoObj.randomUUID();
+    }
+    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    var result = "";
+    for (var i = 0; i < 9; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+};
+exports.uuidString = uuidString;

package/dist/cjs/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/cjs/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAKG"}

package/dist/cjs/vitest.config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        globals: true,
+        environment: "node",
+    },
+});

package/dist/esm/array.d.ts

@@ -0,0 +1,3 @@
+export declare function findLastIndex<T>(array: Array<T>, predicate: (value: T, index: number, obj: T[]) => boolean): number;
+export declare const createArrayRange: (start: number, end: number) => number[];
+//# sourceMappingURL=array.d.ts.map

package/dist/esm/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../array.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,GACxD,MAAM,CAMR;AAED,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,KAAG,MAAM,EAKnE,CAAC"}

package/dist/esm/array.js

@@ -0,0 +1,14 @@
+export function findLastIndex(array, predicate) {
+    let l = array.length;
+    while (l--) {
+        if (predicate(array[l], l, array))
+            return l;
+    }
+    return -1;
+}
+export const createArrayRange = (start, end) => {
+    if (end < start) {
+        return [];
+    }
+    return Array.from({ length: end - start + 1 }, (_, index) => start + index);
+};

package/dist/esm/cell-data-helpers.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utility functions for CellData property access with fallback logic
+ * Prioritizes short keys (ue, ev) over long keys (userEnteredValue, effectiveValue)
+ *
+ * Note: These functions use generic types to avoid circular dependencies
+ */
+import type { CellData, CellFormat, StyleReference } from "@rowsncolumns/common-types";
+export declare const getCellUserEnteredValue: <T extends CellData>(cell?: T | null) => T["ue"];
+export declare const getCellEffectiveValue: <T extends CellData>(cell?: T | null) => T["ev"];
+export declare const getCellUserEnteredFormat: <T extends CellData>(cell?: T | null) => T["uf"];
+export declare const getCellEffectiveFormat: <T extends CellData>(cell?: T | null) => CellFormat | StyleReference | null | undefined;
+export declare const getCellFormattedValue: <T extends CellData>(cell?: T | null) => string | undefined | null;
+export declare const getStyleId: (styleRef: Record<string, any>) => string;
+export declare const getExtendedValueNumber: (extValue?: Record<string, any> | null) => number | undefined;
+export declare const getExtendedValueString: (extValue?: Record<string, any> | null) => string | undefined;
+export declare const getExtendedValueBool: (extValue?: Record<string, any> | null) => boolean | undefined;
+export declare const getExtendedValueFormula: (extValue?: Record<string, any> | null) => string | undefined;
+export declare const getExtendedValueError: (extValue?: Record<string, any> | null) => any | undefined;
+//# sourceMappingURL=cell-data-helpers.d.ts.map

package/dist/esm/cell-data-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-data-helpers.d.ts","sourceRoot":"","sources":["../../cell-data-helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EACV,cAAc,EACf,MAAM,4BAA4B,CAAC;AAEpC,eAAO,MAAM,uBAAuB,GAAI,CAAC,SAAS,QAAQ,EACxD,OAAO,CAAC,GAAG,IAAI,KACd,CAAC,CAAC,IAAI,CAER,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EACtD,OAAO,CAAC,GAAG,IAAI,KACd,CAAC,CAAC,IAAI,CAER,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,CAAC,SAAS,QAAQ,EACzD,OAAO,CAAC,GAAG,IAAI,KACd,CAAC,CAAC,IAAI,CAER,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,QAAQ,EACvD,OAAO,CAAC,GAAG,IAAI,KACd,UAAU,GAAG,cAAc,GAAG,IAAI,GAAG,SAEvC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,CAAC,SAAS,QAAQ,EACtD,OAAO,CAAC,GAAG,IAAI,KACd,MAAM,GAAG,SAAS,GAAG,IAEvB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,UAAU,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAG,MAE1D,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,WAAW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,KACpC,MAAM,GAAG,SAEX,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,WAAW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,KACpC,MAAM,GAAG,SAEX,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,KACpC,OAAO,GAAG,SAEZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,WAAW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,KACpC,MAAM,GAAG,SAEX,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,WAAW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,KACpC,GAAG,GAAG,SAER,CAAC"}

package/dist/esm/cell-data-helpers.js

@@ -0,0 +1,39 @@
+/**
+ * Utility functions for CellData property access with fallback logic
+ * Prioritizes short keys (ue, ev) over long keys (userEnteredValue, effectiveValue)
+ *
+ * Note: These functions use generic types to avoid circular dependencies
+ */
+export const getCellUserEnteredValue = (cell) => {
+    return cell?.ue ?? cell?.userEnteredValue;
+};
+export const getCellEffectiveValue = (cell) => {
+    return cell?.ev ?? cell?.effectiveValue;
+};
+export const getCellUserEnteredFormat = (cell) => {
+    return cell?.uf ?? cell?.userEnteredFormat;
+};
+export const getCellEffectiveFormat = (cell) => {
+    return cell?.ef ?? cell?.effectiveFormat;
+};
+export const getCellFormattedValue = (cell) => {
+    return cell?.fv ?? cell?.formattedValue;
+};
+export const getStyleId = (styleRef) => {
+    return styleRef.sid ?? styleRef.styleId;
+};
+export const getExtendedValueNumber = (extValue) => {
+    return extValue?.nv ?? extValue?.numberValue;
+};
+export const getExtendedValueString = (extValue) => {
+    return extValue?.sv ?? extValue?.stringValue;
+};
+export const getExtendedValueBool = (extValue) => {
+    return extValue?.bv ?? extValue?.boolValue;
+};
+export const getExtendedValueFormula = (extValue) => {
+    return extValue?.fv ?? extValue?.formulaValue;
+};
+export const getExtendedValueError = (extValue) => {
+    return extValue?.ev ?? extValue?.errorValue;
+};

package/dist/esm/color.d.ts

@@ -0,0 +1,20 @@
+export declare const getSelectionColorAtIndex: (key: number) => string;
+export type RGBA = {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+};
+export declare function normalizeColor(color: string): RGBA | null;
+export declare const rgbaToArgbHex: ({ r, g, b, a }: RGBA) => string;
+export declare const isSameColor: (colorA: string | undefined, colorB: string | undefined) => boolean | undefined;
+export declare const colorStringToHex: (color: string | undefined) => string | undefined;
+export declare const lightenColor: (unit: number | undefined, color: string) => string | undefined;
+export declare const hexToRgb: (hex: string) => {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare const rgbToHex: (r: number, g: number, b: number) => string;
+export declare const getContrastColor: (backgroundColor: string, lightColor: string, darkColor: string) => string | undefined;
+//# sourceMappingURL=color.d.ts.map

package/dist/esm/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../color.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,wBAAwB,GAAI,KAAK,MAAM,WAoCnD,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAYnE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAkBzD;AAED,eAAO,MAAM,aAAa,GAAI,gBAAoB,IAAI,WAUrD,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,QAAQ,MAAM,GAAG,SAAS,EAC1B,QAAQ,MAAM,GAAG,SAAS,wBAiB3B,CAAC;AAQF,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,GAAG,SAAS,uBAczD,CAAC;AAGF,eAAO,MAAM,YAAY,GAAI,wBAAU,EAAE,OAAO,MAAM,uBAGrD,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM;;;;CAOnC,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,WAGvD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,iBAAiB,MAAM,EACvB,YAAY,MAAM,EAClB,WAAW,MAAM,uBAUlB,CAAC"}

package/dist/esm/color.js

@@ -0,0 +1,152 @@
+import { isNil } from "./typeguards";
+// Shared by editor decorator + spreadsheet
+export const getSelectionColorAtIndex = (key) => {
+    let hash = 0;
+    const colors = [
+        "#11a9cc",
+        "#a61d4c",
+        "#4285f4",
+        "#f4b400",
+        "#65b045",
+        "#e51c23",
+        "#e91e63",
+        "#9c27b0",
+        "#673ab7",
+        "#3f51b5",
+        "#5677fc",
+        "#03a9f4",
+        "#00bcd4",
+        "#009688",
+        "#259b24",
+        "#8bc34a",
+        "#afb42b",
+        "#ff9800",
+        "#ff5722",
+        "#795548",
+        "#607d8b",
+        "#880e4f",
+        "#827717",
+        "#f7981d", // orange
+        "#7e3794",
+    ];
+    const str = key.toString();
+    for (let i = 0; i < str.length; i++) {
+        hash = str.charCodeAt(i) + ((hash << 5) - hash);
+        hash = hash & hash;
+    }
+    hash = ((hash % colors.length) + colors.length) % colors.length;
+    return colors[hash];
+};
+function parseRGBA(rgbString) {
+    const regex = /^rgba?\((\d+),\s*(\d+),\s*(\d+),?\s*([01]?(\.\d+)?)?\)$/;
+    const match = rgbString.match(regex);
+    if (match) {
+        const [, r, g, b, a] = match.map(Number);
+        return { r, g, b, a: a === undefined || isNaN(a) ? 1 : a };
+    }
+    return undefined;
+}
+export function normalizeColor(color) {
+    if (color.startsWith("#")) {
+        // Hex to RGB conversion
+        const hex = color.slice(1);
+        const bigint = parseInt(hex, 16);
+        const r = (bigint >> 16) & 255;
+        const g = (bigint >> 8) & 255;
+        const b = bigint & 255;
+        return { r, g, b };
+    }
+    else if (color.startsWith("rgb")) {
+        // RGB string parsing
+        const parsedColor = parseRGBA(color);
+        if (parsedColor) {
+            return parsedColor;
+        }
+    }
+    return null; // Unsupported color format
+}
+export const rgbaToArgbHex = ({ r, g, b, a = 1 }) => {
+    const alpha = Math.round(a * 255);
+    const hex = [alpha, r, g, b]
+        .map((value) => {
+        const hex = value.toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+    })
+        .join("");
+    return hex;
+};
+export const isSameColor = (colorA, colorB) => {
+    if (colorA === colorB) {
+        return true;
+    }
+    const normalizedColorA = isNil(colorA) ? undefined : normalizeColor(colorA);
+    const normalizedColorB = isNil(colorB) ? undefined : normalizeColor(colorB);
+    if (normalizedColorA && normalizedColorB) {
+        return (normalizedColorA.r === normalizedColorB.r &&
+            normalizedColorA.g === normalizedColorB.g &&
+            normalizedColorA.b === normalizedColorB.b);
+    }
+    return undefined;
+};
+// Returns a `#RRGGBB` hex string, or undefined if the input isn't a recognized
+// color form (rgb()/rgba() function or already-hex). The previous fallback
+// `return color` let CSS fragments like `font-family:"…"` flow through as
+// "colors", which then ended up in cell formatting and broke xlsx export.
+const HEX_COLOR_RE = /^#?[0-9A-Fa-f]{3}([0-9A-Fa-f])?([0-9A-Fa-f]{2})?([0-9A-Fa-f]{2})?$/;
+export const colorStringToHex = (color) => {
+    if (isNil(color)) {
+        return undefined;
+    }
+    const trimmed = color.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith("rgb")) {
+        const rgb = parseRGBA(trimmed);
+        return rgb ? rgbToHex(rgb.r, rgb.g, rgb.b) : undefined;
+    }
+    if (HEX_COLOR_RE.test(trimmed)) {
+        return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+    }
+    return undefined;
+};
+// Lighten a color
+export const lightenColor = (unit = 0.2, color) => {
+    const rgbColor = normalizeColor(color);
+    return rgbColor ? shade(unit, rgbColor) : undefined;
+};
+export const hexToRgb = (hex) => {
+    const bigint = parseInt(hex.slice(1), 16);
+    const r = (bigint >> 16) & 255;
+    const g = (bigint >> 8) & 255;
+    const b = bigint & 255;
+    return { r, g, b };
+};
+export const rgbToHex = (r, g, b) => {
+    const hex = ((r << 16) | (g << 8) | b).toString(16);
+    return "#" + ("000000" + hex).slice(-6);
+};
+export const getContrastColor = (backgroundColor, lightColor, darkColor) => {
+    const rgbColor = normalizeColor(backgroundColor);
+    if (rgbColor) {
+        const { r, g, b } = rgbColor;
+        const yiq = (r * 299 + g * 587 + b * 114) / 1000;
+        return yiq >= 128 ? lightColor : darkColor;
+    }
+    return undefined;
+};
+const shade = (light, { r, g, b, a }) => {
+    if (a === 0) {
+        return undefined;
+    }
+    if (light < 0) {
+        r = (1 + light) * r;
+        g = (1 + light) * g;
+        b = (1 + light) * b;
+    }
+    else {
+        r = (1 - light) * r + light * 255;
+        g = (1 - light) * g + light * 255;
+        b = (1 - light) * b + light * 255;
+    }
+    return rgbToHex(r, g, b);
+};

package/dist/esm/colors.d.ts

@@ -0,0 +1,2 @@
+export declare const IndexedColors: readonly string[];
+//# sourceMappingURL=colors.d.ts.map

package/dist/esm/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../colors.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,aAAa,mBAyExB,CAAC"}

package/dist/esm/colors.js

@@ -0,0 +1,75 @@
+// Excel indexed colors mapping used for legacy color references
+export const IndexedColors = Object.freeze([
+    // 0-7
+    "#000000",
+    "#FFFFFF",
+    "#FF0000",
+    "#00FF00",
+    "#0000FF",
+    "#FFFF00",
+    "#FF00FF",
+    "#00FFFF",
+    // 8-15
+    "#000000",
+    "#FFFFFF",
+    "#FF0000",
+    "#00FF00",
+    "#0000FF",
+    "#FFFF00",
+    "#FF00FF",
+    "#00FFFF",
+    // 16-23
+    "#800000",
+    "#008000",
+    "#000080",
+    "#808000",
+    "#800080",
+    "#008080",
+    "#C0C0C0",
+    "#808080",
+    // 24-31
+    "#9999FF",
+    "#993366",
+    "#FFFFCC",
+    "#CCFFFF",
+    "#660066",
+    "#FF8080",
+    "#0066CC",
+    "#CCCCFF",
+    // 32-39
+    "#000080",
+    "#FF00FF",
+    "#FFFF00",
+    "#00FFFF",
+    "#800080",
+    "#800000",
+    "#008080",
+    "#0000FF",
+    // 40-47
+    "#00CCFF",
+    "#CCFFFF",
+    "#CCFFCC",
+    "#FFFF99",
+    "#99CCFF",
+    "#FF99CC",
+    "#CC99FF",
+    "#FFCC99",
+    // 48-55
+    "#3366FF",
+    "#33CCCC",
+    "#99CC00",
+    "#FFCC00",
+    "#FF9900",
+    "#FF6600",
+    "#666699",
+    "#969696",
+    // 56-63
+    "#003366",
+    "#339966",
+    "#003300",
+    "#333300",
+    "#993300",
+    "#993366",
+    "#333399",
+    "#333333",
+]);

package/dist/esm/conditional-format.d.ts

@@ -0,0 +1,49 @@
+import type { BooleanCondition } from "@rowsncolumns/common-types";
+/**
+ * Minimal structural shape of a conditional-format rule needed by the
+ * predicate/builder below. The full `ConditionalFormatRule` type lives in the
+ * `@rowsncolumns/spreadsheet` package and is structurally compatible with
+ * this shape.
+ */
+export type ConditionalFormatRuleLike = {
+    booleanRule?: {
+        condition?: BooleanCondition | null;
+    } | null;
+};
+/**
+ * Whether a CF rule is evaluated via the calculator (formula path) instead of
+ * the synchronous `checkBooleanRule` path used in
+ * `apps/spreadsheet/hooks/use-conditional-formatting.ts`.
+ *
+ * Returns `true` for every condition type that `buildConditionalFormatExpression`
+ * can express as a single-cell formula: CUSTOM_FORMULA, all NUMBER_/DATE_/TEXT_
+ * comparisons, BETWEEN/NOT_BETWEEN, CONTAINS/NOT_CONTAINS, STARTS_WITH/ENDS_WITH,
+ * ONE_OF_LIST/ONE_OF_RANGE, BLANK/NOT_BLANK, BOOLEAN, TEXT_IS_EMAIL/TEXT_IS_URL.
+ * The calculator stores the per-cell boolean on
+ * `cellData.conditionalFormattingResultById[ruleId]`.
+ *
+ * Returns `false` — leaving the rule on the sync path — for rules that aren't
+ * expressible as a single-cell formula:
+ *   - Aggregate-over-range: gradient/heatmap, TOP/BOTTOM N, DUPLICATE/UNIQUE,
+ *     NUMBER_ABOVE_AVERAGE / NUMBER_BELOW_AVERAGE — the result depends on
+ *     other cells in the range, not just the current cell.
+ *   - Loop-state: NUMBER_GREATER_THAN_PREVIOUS and the other `*_PREVIOUS`
+ *     variants — compare against the prior row's value held in iteration state.
+ *   - Calendar-relative dates: DATE_TODAY / DATE_THIS_WEEK / DATE_THIS_MONTH
+ *     and the surrounding family, plus DATE_IS_VALID. Could be expressed via
+ *     TODAY()-based formulas if we ever want to migrate them.
+ *   - Cell error state: ERROR / NOT_ERROR — read directly from the extended
+ *     value in `getValidationValue`.
+ *
+ * The consumers (rule create/update/delete enqueueing in spreadsheet-state,
+ * `getConditionalFormatFormula` building the expression, `getValidationValue`
+ * choosing where to read the per-cell value, and the `isFormulaRule` branch
+ * in `use-conditional-formatting.ts`) MUST stay in lockstep with this
+ * predicate — if it returns `true`, the calculator owns the result and the
+ * sync `checkBooleanRule` path must not run for that rule. Delegating to
+ * `buildConditionalFormatExpression` keeps the predicate and the builder from
+ * drifting.
+ */
+export declare const isConditionalFormatFormulaRule: (rule: ConditionalFormatRuleLike | undefined) => boolean;
+export declare const buildConditionalFormatExpression: (rule: ConditionalFormatRuleLike | undefined, baseCellRef: string, locale?: string) => string | undefined;
+//# sourceMappingURL=conditional-format.d.ts.map

package/dist/esm/conditional-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-format.d.ts","sourceRoot":"","sources":["../../conditional-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,4BAA4B,CAAC;AAKpC;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,WAAW,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CAC9D,CAAC;AA+DF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,8BAA8B,GACzC,MAAM,yBAAyB,GAAG,SAAS,YAK5C,CAAC;AAEF,eAAO,MAAM,gCAAgC,GAC3C,MAAM,yBAAyB,GAAG,SAAS,EAC3C,aAAa,MAAM,EACnB,SAAS,MAAM,uBA8HhB,CAAC"}