@rowsncolumns/toolkit 24.4.1

package/dist/cjs/exporter/xlsx/sparkline-builder.js

@@ -0,0 +1,489 @@
+import { __assign, __read, __rest, __values } from "tslib";
+import { cellToAddress } from "@rowsncolumns/utils";
+/**
+ * Parse a SPARKLINE formula to extract data range and options
+ * Formula format: =SPARKLINE(A1:E1,{"charttype","column","color","#FF0000"})
+ */
+export function parseSparklineFormula(formula, sheetName) {
+    // Match SPARKLINE formula
+    var sparklineMatch = formula.match(/^=SPARKLINE\s*\(\s*([^,)]+)(?:\s*,\s*\{([^}]*)\})?\s*\)$/i);
+    if (!sparklineMatch)
+        return null;
+    var dataRange = sparklineMatch[1].trim();
+    var optionsStr = sparklineMatch[2];
+    // If the range doesn't have a sheet prefix, add current sheet name
+    if (!dataRange.includes("!")) {
+        dataRange = "".concat(sheetName, "!").concat(dataRange);
+    }
+    // Parse options
+    var chartType = "line";
+    var color;
+    var opts = {};
+    var parseBool = function (v) {
+        var upper = v.toUpperCase();
+        if (upper === "TRUE" || upper === "1")
+            return true;
+        if (upper === "FALSE" || upper === "0")
+            return false;
+        return undefined;
+    };
+    var parseNum = function (v) {
+        var n = parseFloat(v);
+        return Number.isFinite(n) ? n : undefined;
+    };
+    if (optionsStr) {
+        // Tokenize on commas, strip outer quotes. The grammar is loose —
+        // Sheets accepts both `{"key","value", "key2","value2"}` and
+        // semicolon-separated pair forms — but our parser side always
+        // emits the comma form, so that's what we accept on the way back.
+        var tokens = optionsStr
+            .split(/[,;]/)
+            .map(function (t) { return t.trim().replace(/^"|"$/g, ""); });
+        for (var i = 0; i < tokens.length - 1; i += 2) {
+            var key = tokens[i].toLowerCase();
+            var value = tokens[i + 1];
+            switch (key) {
+                case "charttype":
+                    if (value === "column")
+                        chartType = "column";
+                    else if (value === "winloss")
+                        chartType = "stacked";
+                    break;
+                case "color":
+                    color = value;
+                    break;
+                case "emptycells":
+                    if (value === "gap" || value === "zero" || value === "span") {
+                        opts.emptyCellsAs = value;
+                    }
+                    break;
+                case "dateaxis": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.dateAxis = true;
+                    break;
+                }
+                case "markers": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.markers = true;
+                    break;
+                }
+                // Two key spellings are accepted for the highlight flags:
+                // the new `high`/`low`/…  names that match
+                // `SparkLineResultOptions` and the legacy `highpoint`/
+                // `lowpoint`/… names that the parser used to emit. Keep both
+                // so user-typed formulas and round-tripped files both work.
+                case "high":
+                case "highpoint": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.high = true;
+                    break;
+                }
+                case "low":
+                case "lowpoint": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.low = true;
+                    break;
+                }
+                case "first":
+                case "firstpoint": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.first = true;
+                    break;
+                }
+                case "last":
+                case "lastpoint": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.last = true;
+                    break;
+                }
+                case "negative":
+                case "negativepoints": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.negative = true;
+                    break;
+                }
+                case "colorhigh":
+                    opts.colorHigh = value;
+                    break;
+                case "colorlow":
+                    opts.colorLow = value;
+                    break;
+                case "colorfirst":
+                    opts.colorFirst = value;
+                    break;
+                case "colorlast":
+                    opts.colorLast = value;
+                    break;
+                case "colormarkers":
+                    opts.colorMarkers = value;
+                    break;
+                case "colornegative":
+                    opts.colorNegative = value;
+                    break;
+                case "axis": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.displayXAxis = true;
+                    break;
+                }
+                case "rtl": {
+                    // Sheets' SPARKLINE option name for OOXML `rightToLeft`.
+                    var b = parseBool(value);
+                    if (b)
+                        opts.rightToLeft = true;
+                    break;
+                }
+                case "displayhidden": {
+                    var b = parseBool(value);
+                    if (b)
+                        opts.displayHidden = true;
+                    break;
+                }
+                case "lineweight": {
+                    var n = parseNum(value);
+                    if (n != null)
+                        opts.lineWeight = n;
+                    break;
+                }
+                case "max": {
+                    var n = parseNum(value);
+                    if (n != null)
+                        opts.manualMax = n;
+                    break;
+                }
+                case "min": {
+                    var n = parseNum(value);
+                    if (n != null)
+                        opts.manualMin = n;
+                    break;
+                }
+                case "minaxistype":
+                    if (value === "individual" ||
+                        value === "group" ||
+                        value === "custom") {
+                        opts.minAxisType = value;
+                    }
+                    break;
+                case "maxaxistype":
+                    if (value === "individual" ||
+                        value === "group" ||
+                        value === "custom") {
+                        opts.maxAxisType = value;
+                    }
+                    break;
+            }
+        }
+    }
+    return __assign({ dataRange: dataRange, chartType: chartType, color: color }, opts);
+}
+/**
+ * Detect SPARKLINE formulas in a sheet and extract sparkline info
+ */
+export function detectSparklines(sheet, rowData) {
+    var e_1, _a, e_2, _b;
+    var _c, _d;
+    var sparklines = [];
+    try {
+        for (var _e = __values(Object.entries(rowData)), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var _g = __read(_f.value, 2), rowIndexStr = _g[0], row = _g[1];
+            var rowIndex = parseInt(rowIndexStr, 10);
+            try {
+                for (var _h = (e_2 = void 0, __values(Object.entries(row))), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var _k = __read(_j.value, 2), colIndexStr = _k[0], cell = _k[1];
+                    var columnIndex = parseInt(colIndexStr, 10);
+                    var formula = ((_c = cell === null || cell === void 0 ? void 0 : cell.ue) === null || _c === void 0 ? void 0 : _c.fv) || ((_d = cell === null || cell === void 0 ? void 0 : cell.userEnteredValue) === null || _d === void 0 ? void 0 : _d.formulaValue);
+                    if (formula && formula.toUpperCase().startsWith("=SPARKLINE(")) {
+                        var parsed = parseSparklineFormula(formula, sheet.title);
+                        if (parsed) {
+                            var targetCell = cellToAddress({
+                                rowIndex: rowIndex,
+                                columnIndex: columnIndex,
+                            });
+                            if (targetCell) {
+                                var dataRange = parsed.dataRange, chartType = parsed.chartType, color = parsed.color, axis = __rest(parsed, ["dataRange", "chartType", "color"]);
+                                sparklines.push(__assign({ targetCell: targetCell, dataRange: dataRange, type: chartType, color: color, rowIndex: rowIndex, columnIndex: columnIndex }, axis));
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return sparklines;
+}
+/**
+ * Group sparklines by their full style fingerprint — type + color +
+ * every axis option that affects rendering. Two sparklines only share
+ * a `<x14:sparklineGroup>` when every attribute matches, otherwise
+ * OOXML's "one set of attrs per group" model would silently merge
+ * different settings into one.
+ */
+function groupSparklines(sparklines) {
+    var e_3, _a;
+    var groups = new Map();
+    var fingerprintAxis = function (s) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        return [
+            (_a = s.emptyCellsAs) !== null && _a !== void 0 ? _a : "",
+            s.dateAxis ? "1" : "",
+            s.markers ? "1" : "",
+            s.high ? "1" : "",
+            s.low ? "1" : "",
+            s.first ? "1" : "",
+            s.last ? "1" : "",
+            s.negative ? "1" : "",
+            s.displayXAxis ? "1" : "",
+            s.displayHidden ? "1" : "",
+            s.rightToLeft ? "1" : "",
+            (_b = s.lineWeight) !== null && _b !== void 0 ? _b : "",
+            (_c = s.manualMax) !== null && _c !== void 0 ? _c : "",
+            (_d = s.manualMin) !== null && _d !== void 0 ? _d : "",
+            (_e = s.minAxisType) !== null && _e !== void 0 ? _e : "",
+            (_f = s.maxAxisType) !== null && _f !== void 0 ? _f : "",
+            (_g = s.colorHigh) !== null && _g !== void 0 ? _g : "",
+            (_h = s.colorLow) !== null && _h !== void 0 ? _h : "",
+            (_j = s.colorFirst) !== null && _j !== void 0 ? _j : "",
+            (_k = s.colorLast) !== null && _k !== void 0 ? _k : "",
+            (_l = s.colorMarkers) !== null && _l !== void 0 ? _l : "",
+            (_m = s.colorNegative) !== null && _m !== void 0 ? _m : "",
+        ].join("|");
+    };
+    try {
+        for (var sparklines_1 = __values(sparklines), sparklines_1_1 = sparklines_1.next(); !sparklines_1_1.done; sparklines_1_1 = sparklines_1.next()) {
+            var sparkline = sparklines_1_1.value;
+            var key = "".concat(sparkline.type, "|").concat(sparkline.color || "", "|").concat(fingerprintAxis(sparkline));
+            if (!groups.has(key)) {
+                groups.set(key, {
+                    type: sparkline.type,
+                    color: sparkline.color,
+                    sparklines: [],
+                    emptyCellsAs: sparkline.emptyCellsAs,
+                    dateAxis: sparkline.dateAxis,
+                    markers: sparkline.markers,
+                    high: sparkline.high,
+                    low: sparkline.low,
+                    first: sparkline.first,
+                    last: sparkline.last,
+                    negative: sparkline.negative,
+                    displayXAxis: sparkline.displayXAxis,
+                    displayHidden: sparkline.displayHidden,
+                    rightToLeft: sparkline.rightToLeft,
+                    lineWeight: sparkline.lineWeight,
+                    manualMax: sparkline.manualMax,
+                    manualMin: sparkline.manualMin,
+                    minAxisType: sparkline.minAxisType,
+                    maxAxisType: sparkline.maxAxisType,
+                    colorHigh: sparkline.colorHigh,
+                    colorLow: sparkline.colorLow,
+                    colorFirst: sparkline.colorFirst,
+                    colorLast: sparkline.colorLast,
+                    colorMarkers: sparkline.colorMarkers,
+                    colorNegative: sparkline.colorNegative,
+                });
+            }
+            groups.get(key).sparklines.push(sparkline);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (sparklines_1_1 && !sparklines_1_1.done && (_a = sparklines_1.return)) _a.call(sparklines_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return Array.from(groups.values());
+}
+/**
+ * Convert hex color #RRGGBB to Excel's ARGB format FFRRGGBB
+ */
+function toExcelColor(color) {
+    // Remove # if present
+    var hex = color.replace(/^#/, "");
+    // Add alpha channel (FF = fully opaque)
+    return "FF".concat(hex.toUpperCase());
+}
+// Default colors for sparklines (Excel theme colors)
+var DEFAULT_SPARKLINE_COLOR = "#4472C4"; // Excel default blue
+var DEFAULT_MARKER_COLOR = "#4472C4"; // Same as line color
+var DEFAULT_HIGH_COLOR = "#56A26B"; // Green for high point
+var DEFAULT_LOW_COLOR = "#C55A5A"; // Red for low point
+var DEFAULT_NEGATIVE_COLOR = "#C55A5A"; // Red for negative values
+/**
+ * Build sparkline groups XML for worksheet extLst
+ * Returns null if no sparklines detected
+ */
+export function buildSparklineGroupsXml(sheet, rowData) {
+    var e_4, _a, e_5, _b;
+    var _c, _d, _e, _f;
+    var sparklines = detectSparklines(sheet, rowData);
+    if (sparklines.length === 0) {
+        return null;
+    }
+    var groups = groupSparklines(sparklines);
+    var groupsXml = "";
+    try {
+        for (var groups_1 = __values(groups), groups_1_1 = groups_1.next(); !groups_1_1.done; groups_1_1 = groups_1.next()) {
+            var group = groups_1_1.value;
+            // Use specified color or default
+            var seriesColor = group.color || DEFAULT_SPARKLINE_COLOR;
+            // Build sparkline group attributes. Each axis option round-trips
+            // 1:1 with its OOXML attribute name. When a value was explicitly
+            // parsed off the formula we emit it verbatim; otherwise we keep
+            // the legacy "sensible defaults" path so plain `SPARKLINE(range)`
+            // formulas still get readable highlights when exported.
+            var groupAttrs = "";
+            if (group.type !== "line") {
+                groupAttrs += " type=\"".concat(group.type, "\"");
+            }
+            if (group.lineWeight != null) {
+                groupAttrs += " lineWeight=\"".concat(group.lineWeight, "\"");
+            }
+            if (group.dateAxis)
+                groupAttrs += " dateAxis=\"1\"";
+            if (group.emptyCellsAs) {
+                groupAttrs += " displayEmptyCellsAs=\"".concat(group.emptyCellsAs, "\"");
+            }
+            if (group.markers)
+                groupAttrs += " markers=\"1\"";
+            if (group.high)
+                groupAttrs += " high=\"1\"";
+            if (group.low)
+                groupAttrs += " low=\"1\"";
+            if (group.first)
+                groupAttrs += " first=\"1\"";
+            if (group.last)
+                groupAttrs += " last=\"1\"";
+            if (group.negative)
+                groupAttrs += " negative=\"1\"";
+            if (group.displayXAxis)
+                groupAttrs += " displayXAxis=\"1\"";
+            if (group.displayHidden)
+                groupAttrs += " displayHidden=\"1\"";
+            if (group.rightToLeft)
+                groupAttrs += " rightToLeft=\"1\"";
+            if (group.manualMax != null)
+                groupAttrs += " manualMax=\"".concat(group.manualMax, "\"");
+            if (group.manualMin != null)
+                groupAttrs += " manualMin=\"".concat(group.manualMin, "\"");
+            if (group.minAxisType)
+                groupAttrs += " minAxisType=\"".concat(group.minAxisType, "\"");
+            if (group.maxAxisType)
+                groupAttrs += " maxAxisType=\"".concat(group.maxAxisType, "\"");
+            // Legacy "sensible defaults" — only when the formula didn't
+            // explicitly set markers / high / low / negative. Preserves the
+            // existing behavior for plain `SPARKLINE(range)` formulas that
+            // came through without options.
+            var hasExplicitHighlights = group.markers ||
+                group.high ||
+                group.low ||
+                group.first ||
+                group.last ||
+                group.negative;
+            if (!hasExplicitHighlights) {
+                if (group.type === "line") {
+                    groupAttrs += " markers=\"1\" high=\"1\" low=\"1\"";
+                }
+                else if (group.type === "column" || group.type === "stacked") {
+                    groupAttrs += " high=\"1\" low=\"1\" negative=\"1\"";
+                }
+            }
+            // Build color elements. Per-point colors come from the original
+            // workbook when present (round-trip path); otherwise we fall back
+            // to readable defaults so plain `SPARKLINE(range)` formulas still
+            // get sensible highlights.
+            var colorsXml = "";
+            colorsXml += "<x14:colorSeries rgb=\"".concat(toExcelColor(seriesColor), "\"/>");
+            if (group.type === "column" || group.type === "stacked") {
+                colorsXml += "<x14:colorNegative rgb=\"".concat(toExcelColor((_c = group.colorNegative) !== null && _c !== void 0 ? _c : DEFAULT_NEGATIVE_COLOR), "\"/>");
+            }
+            else if (group.colorNegative) {
+                colorsXml += "<x14:colorNegative rgb=\"".concat(toExcelColor(group.colorNegative), "\"/>");
+            }
+            if (group.type === "line") {
+                colorsXml += "<x14:colorMarkers rgb=\"".concat(toExcelColor((_d = group.colorMarkers) !== null && _d !== void 0 ? _d : seriesColor), "\"/>");
+            }
+            else if (group.colorMarkers) {
+                colorsXml += "<x14:colorMarkers rgb=\"".concat(toExcelColor(group.colorMarkers), "\"/>");
+            }
+            if (group.colorFirst) {
+                colorsXml += "<x14:colorFirst rgb=\"".concat(toExcelColor(group.colorFirst), "\"/>");
+            }
+            if (group.colorLast) {
+                colorsXml += "<x14:colorLast rgb=\"".concat(toExcelColor(group.colorLast), "\"/>");
+            }
+            colorsXml += "<x14:colorHigh rgb=\"".concat(toExcelColor((_e = group.colorHigh) !== null && _e !== void 0 ? _e : DEFAULT_HIGH_COLOR), "\"/>");
+            colorsXml += "<x14:colorLow rgb=\"".concat(toExcelColor((_f = group.colorLow) !== null && _f !== void 0 ? _f : DEFAULT_LOW_COLOR), "\"/>");
+            // Build individual sparklines
+            var sparklinesXml = "";
+            try {
+                for (var _g = (e_5 = void 0, __values(group.sparklines)), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var sparkline = _h.value;
+                    sparklinesXml += "<x14:sparkline><xm:f>".concat(sparkline.dataRange, "</xm:f><xm:sqref>").concat(sparkline.targetCell, "</xm:sqref></x14:sparkline>");
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            groupsXml += "<x14:sparklineGroup".concat(groupAttrs, ">").concat(colorsXml, "<x14:sparklines>").concat(sparklinesXml, "</x14:sparklines></x14:sparklineGroup>");
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (groups_1_1 && !groups_1_1.done && (_a = groups_1.return)) _a.call(groups_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return "<ext uri=\"{05C60535-1F16-4fd2-B633-F4F36F0B64E0}\" xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\" xmlns:xm=\"http://schemas.microsoft.com/office/excel/2006/main\"><x14:sparklineGroups xmlns:xm=\"http://schemas.microsoft.com/office/excel/2006/main\">".concat(groupsXml, "</x14:sparklineGroups></ext>");
+}
+/**
+ * Build combined extLst for worksheet (sparklines + slicers)
+ */
+export function buildWorksheetExtLst(sparklineExtXml, slicerExtXml) {
+    var parts = [];
+    if (sparklineExtXml) {
+        parts.push(sparklineExtXml);
+    }
+    if (slicerExtXml) {
+        parts.push(slicerExtXml);
+    }
+    if (parts.length === 0) {
+        return "";
+    }
+    return "<extLst>".concat(parts.join(""), "</extLst>");
+}
+/**
+ * Check if a cell has a SPARKLINE formula and should NOT be exported as a formula
+ * (the formula will be converted to native Excel sparkline instead)
+ */
+export function isSparklineCell(cell) {
+    var _a, _b;
+    var formula = ((_a = cell === null || cell === void 0 ? void 0 : cell.ue) === null || _a === void 0 ? void 0 : _a.fv) || ((_b = cell === null || cell === void 0 ? void 0 : cell.userEnteredValue) === null || _b === void 0 ? void 0 : _b.formulaValue);
+    return (typeof formula === "string" &&
+        formula.toUpperCase().startsWith("=SPARKLINE("));
+}

package/dist/cjs/exporter/xlsx/style-builder.d.ts

@@ -0,0 +1,93 @@
+import type { CellData, CellFormat, Color, TextFormat } from "@rowsncolumns/spreadsheet";
+import { type CellXfs } from "@rowsncolumns/spreadsheet-state";
+type NamedCellStyleRecord = {
+    name: string;
+    xfId: number;
+    builtinId?: number;
+    iLevel?: number;
+    hidden?: boolean;
+    customBuiltin?: boolean;
+};
+type CustomTableStyleRecord = {
+    name: string;
+    pivot?: boolean;
+    elements: Array<{
+        type: string;
+        size?: number;
+        backgroundColor?: Color;
+        textColor?: Color;
+        bold?: boolean;
+        italic?: boolean;
+    }>;
+};
+export declare class StyleBuilder {
+    private numberFormats;
+    private fonts;
+    private fills;
+    private borders;
+    private namedCellStyles;
+    private customTableStyles;
+    /**
+     * Replace the named-cell-styles list emitted in `<cellStyles>`.
+     * Used for round-tripping the OOXML Heading 1 / Accent / Total /
+     * Good-Bad-Neutral gallery — the importer parses these from
+     * `xl/styles.xml` and exposes them on `workbook.workbookStyles.
+     * namedCellStyles`; hosts can forward that list back here.
+     *
+     * Excel requires at least a "Normal" entry pointing at xfId=0,
+     * builtinId=0 — when the supplied list doesn't contain one, we
+     * keep the default at the head of the list rather than risk
+     * emitting a file Excel rejects.
+     */
+    setNamedCellStyles(entries: NamedCellStyleRecord[]): void;
+    /**
+     * Replace the user-authored table-style list emitted in the
+     * `<tableStyles>` block. The exporter registers each element's
+     * format as a dxf at `toXml()` time, so callers pass self-contained
+     * records (no dxfIds to manage). Used for round-tripping the
+     * OOXML custom-table-style list from
+     * `workbook.workbookStyles.getCustomTableStyleExports()`.
+     */
+    setCustomTableStyles(entries: CustomTableStyleRecord[]): void;
+    private cellXfs;
+    private fontMap;
+    private fillMap;
+    private borderMap;
+    private formatMap;
+    private xfMap;
+    private dxfs;
+    private dxfMap;
+    constructor();
+    /**
+     * Replace the workbook default font (font id 0 — what every cell without
+     * an explicit font inherits). Callers pass the source workbook's parsed
+     * default (`WorkBook.getDefaultFont()`) so an imported workbook keeps its
+     * default typeface/size instead of the hardcoded Calibri 11. Must be
+     * called before any cell registration: cells explicitly styled with the
+     * old default must not collapse into font id 0.
+     */
+    setDefaultFont(format?: TextFormat | null): void;
+    registerCell<T extends CellData>(cell: T | null | undefined, cellXfs: CellXfs | null | undefined, 
+    /**
+     * Number format to use when the cell itself has none. Used by the
+     * exporter to layer in the precedent-derived number format on formula
+     * cells so Excel displays them correctly without requiring a recalc.
+     */
+    derivedNumberFormat?: CellFormat["numberFormat"]): number;
+    registerDifferentialFormat(format?: CellFormat | null): number | undefined;
+    private getNumberFormatId;
+    private getFontId;
+    private getFillId;
+    private getBorderId;
+    private serializeFont;
+    private buildFontRecord;
+    private buildFontXml;
+    private buildFillXml;
+    private buildGradientFillXml;
+    private serializeFill;
+    private serializeBorder;
+    private serializeDxf;
+    toXml(): string;
+}
+export {};
+//# sourceMappingURL=style-builder.d.ts.map

package/dist/cjs/exporter/xlsx/style-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"style-builder.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/style-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,QAAQ,EACR,UAAU,EACV,KAAK,EAEL,UAAU,EACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,iCAAiC,CAAC;AAwF/D,KAAK,oBAAoB,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAKF,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,eAAe,CAAC,EAAE,KAAK,CAAC;QACxB,SAAS,CAAC,EAAE,KAAK,CAAC;QAClB,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;CACJ,CAAC;AAEF,qBAAa,YAAY;IACvB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,KAAK,CAKX;IACF,OAAO,CAAC,KAAK,CAA+D;IAC5E,OAAO,CAAC,OAAO,CAAwB;IACvC,OAAO,CAAC,eAAe,CAErB;IACF,OAAO,CAAC,iBAAiB,CAAgC;IAEzD;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,OAAO,EAAE,oBAAoB,EAAE;IAUlD;;;;;;;OAOG;IACH,oBAAoB,CAAC,OAAO,EAAE,sBAAsB,EAAE;IAOtD,OAAO,CAAC,OAAO,CAOb;IAEF,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,SAAS,CAA6B;IAC9C,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,IAAI,CAAmB;IAC/B,OAAO,CAAC,MAAM,CAA6B;;IAU3C;;;;;;;OAOG;IACH,cAAc,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI;IASzC,YAAY,CAAC,CAAC,SAAS,QAAQ,EAC7B,IAAI,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC1B,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS;IACnC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,UAAU,CAAC,cAAc,CAAC,GAC/C,MAAM;IAsET,0BAA0B,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI;IA0BrD,OAAO,CAAC,iBAAiB;IAoCzB,OAAO,CAAC,SAAS;IAcjB,OAAO,CAAC,SAAS;IA2DjB,OAAO,CAAC,WAAW;IA2BnB,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,eAAe;IA8BvB,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,YAAY;IAqCpB,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,aAAa;IAerB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,YAAY;IAMpB,KAAK;CAuJN"}