impact-ui 4.0.13 → 4.0.14-tableV36-beta.1

package/dist/components/TableV36/columnsSettingsVirtualList.d.ts

@@ -0,0 +1,39 @@
+import { default as React } from 'react';
+
+/** Row height (px) — must match Table.styles.scss (26px min-height + 4px padding). */
+export declare const SETTINGS_ROW_HEIGHT = 28;
+/** Above this many painted rows, use the flat virtualized list instead of nested DOM. */
+export declare const SETTINGS_VIRTUALIZE_THRESHOLD = 300;
+export declare const SETTINGS_FROZEN_LIST_MAX_HEIGHT = 204;
+export declare const SETTINGS_SCROLL_LIST_MAX_HEIGHT = 408;
+/** Scroll a windowed settings list when the pointer sits on its top/bottom edge during drag. */
+export declare const scrollListTowardPointer: (listEl: any, clientY: any) => boolean;
+/** One bottom-up pass: colId → { checked, indeterminate } for the whole column tree. */
+export declare const buildCheckStateMap: (columnGroups: any) => Map<any, any>;
+/** Flatten a filtered column tree into painted rows (respects collapsed groups). */
+export declare const flattenColumnRows: (columns: any, collapsedMap: any, section: any) => any[];
+/** Split measured panel height between frozen and scrollable virtual lists. */
+export declare const computeSettingsListHeights: ({ shouldVirtualize, listViewportHeight, frozenRowCount, scrollableRowCount, }: {
+    shouldVirtualize: any;
+    listViewportHeight: any;
+    frozenRowCount: any;
+    scrollableRowCount: any;
+}) => {
+    frozen: number;
+    scrollable: number;
+};
+export declare const FrozenListOuter: React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+export declare const ScrollableListOuter: React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+/**
+ * react-window list with a detached scrollbar (AG Grid pattern) so thumb drag is not
+ * fighting row mount/unmount on the same scroll element.
+ */
+export declare const VirtualColumnList: ({ className, itemData, maxHeight, outerElementType, outerRef, rows, }: {
+    className: any;
+    itemData: any;
+    maxHeight: any;
+    outerElementType: any;
+    outerRef: any;
+    rows: any;
+}) => React.JSX.Element | null;
+//# sourceMappingURL=columnsSettingsVirtualList.d.ts.map

package/dist/components/TableV36/columnsSettingsVirtualList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnsSettingsVirtualList.d.ts","sourceRoot":"","sources":["../../../src/components/TableV36/columnsSettingsVirtualList.tsx"],"names":[],"mappings":"AACA;;;GAGG;AACH,OAAO,KAAgE,MAAM,OAAO,CAAC;AAIrF,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,yFAAyF;AACzF,eAAO,MAAM,6BAA6B,MAAM,CAAC;AAEjD,eAAO,MAAM,+BAA+B,MAAM,CAAC;AACnD,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAYnD,gGAAgG;AAChG,eAAO,MAAM,uBAAuB,GAAI,WAAM,EAAE,YAAO,YAatD,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,kBAAkB,GAAI,iBAAY,kBAwB9C,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,iBAAiB,GAAI,YAAO,EAAE,iBAAY,EAAE,YAAO,UAe/D,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,0BAA0B,GAAI;;;;;CAK1C;;;CAuCA,CAAC;AAiDF,eAAO,MAAM,eAAe,+DAAwC,CAAC;AACrE,eAAO,MAAM,mBAAmB,+DAA4C,CAAC;AAO7E;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI;;;;;;;CAOjC,6BAyIA,CAAC"}

package/dist/components/TableV36/columnsSettingsVirtualList.js

@@ -0,0 +1,294 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import React__default, { useRef, useCallback, useEffect, useLayoutEffect, memo } from "react";
+import { FixedSizeList } from "react-window";
+import { SortableColumnItem, NestedColumnItem } from "./columnsSettingsColumnRow.js";
+const SETTINGS_ROW_HEIGHT = 28;
+const SETTINGS_VIRTUALIZE_THRESHOLD = 300;
+const SETTINGS_FROZEN_LIST_MAX_HEIGHT = 204;
+const SETTINGS_SCROLL_LIST_MAX_HEIGHT = 408;
+const SETTINGS_FROZEN_SECTION_CHROME = 31;
+const SETTINGS_SCROLL_SECTION_CHROME = 68;
+const SETTINGS_SECTION_GAP = 8;
+const SETTINGS_LIST_SAFETY_MARGIN = 4;
+const SETTINGS_MIN_LIST_HEIGHT = SETTINGS_ROW_HEIGHT * 2;
+const SETTINGS_FROZEN_HEIGHT_SHARE = 0.35;
+const SETTINGS_AUTO_SCROLL_EDGE = 36;
+const SETTINGS_AUTO_SCROLL_STEP = 16;
+const scrollListTowardPointer = (listEl, clientY) => {
+  if (!listEl || clientY == null) return false;
+  const rect = listEl.getBoundingClientRect();
+  if (clientY < rect.top || clientY > rect.bottom) return false;
+  if (clientY - rect.top < SETTINGS_AUTO_SCROLL_EDGE) {
+    listEl.scrollTop -= SETTINGS_AUTO_SCROLL_STEP;
+    return true;
+  }
+  if (rect.bottom - clientY < SETTINGS_AUTO_SCROLL_EDGE) {
+    listEl.scrollTop += SETTINGS_AUTO_SCROLL_STEP;
+    return true;
+  }
+  return false;
+};
+const buildCheckStateMap = (columnGroups) => {
+  const map = /* @__PURE__ */ new Map();
+  const visit = (column) => {
+    var _a;
+    if (!((_a = column.children) == null ? void 0 : _a.length)) {
+      map.set(column.colId, { checked: !!column.isVisible, indeterminate: false });
+      return { leaves: 1, visible: column.isVisible ? 1 : 0 };
+    }
+    let leaves = 0;
+    let visible = 0;
+    column.children.forEach((child) => {
+      const result = visit(child);
+      leaves += result.leaves;
+      visible += result.visible;
+    });
+    map.set(column.colId, {
+      checked: visible > 0,
+      indeterminate: visible > 0 && visible < leaves
+    });
+    return { leaves, visible };
+  };
+  columnGroups.forEach((columns) => (columns || []).forEach(visit));
+  return map;
+};
+const flattenColumnRows = (columns, collapsedMap, section) => {
+  const rows = [];
+  const walk = (cols, level) => {
+    (cols || []).forEach((column) => {
+      if (level === 0 && column.headerName === "N/A") return;
+      const hasChildren = Array.isArray(column.children) && column.children.length > 0;
+      const isCollapsed = !!collapsedMap[column.colId];
+      rows.push({ column, level, section, hasChildren, isCollapsed });
+      if (hasChildren && !isCollapsed) {
+        walk(column.children, level + 1);
+      }
+    });
+  };
+  walk(columns, 0);
+  return rows;
+};
+const computeSettingsListHeights = ({
+  shouldVirtualize,
+  listViewportHeight,
+  frozenRowCount,
+  scrollableRowCount
+}) => {
+  const frozenNatural = frozenRowCount * SETTINGS_ROW_HEIGHT;
+  const scrollNatural = scrollableRowCount * SETTINGS_ROW_HEIGHT;
+  if (!shouldVirtualize || !listViewportHeight) {
+    return {
+      frozen: Math.min(frozenNatural, SETTINGS_FROZEN_LIST_MAX_HEIGHT),
+      scrollable: Math.min(scrollNatural, SETTINGS_SCROLL_LIST_MAX_HEIGHT)
+    };
+  }
+  const hasFrozen = frozenRowCount > 0;
+  const hasScrollable = scrollableRowCount > 0;
+  const chrome = (hasFrozen ? SETTINGS_FROZEN_SECTION_CHROME : 0) + (hasScrollable ? SETTINGS_SCROLL_SECTION_CHROME : 0) + (hasFrozen && hasScrollable ? SETTINGS_SECTION_GAP : 0) + SETTINGS_LIST_SAFETY_MARGIN;
+  const available = listViewportHeight - chrome;
+  if (frozenNatural + scrollNatural <= available) {
+    return { frozen: frozenNatural, scrollable: scrollNatural };
+  }
+  if (!hasFrozen || !hasScrollable) {
+    const single = Math.max(SETTINGS_MIN_LIST_HEIGHT, available);
+    return {
+      frozen: hasFrozen ? single : 0,
+      scrollable: hasScrollable ? single : 0
+    };
+  }
+  const frozenCap = Math.max(
+    SETTINGS_MIN_LIST_HEIGHT,
+    Math.floor(available * SETTINGS_FROZEN_HEIGHT_SHARE)
+  );
+  const frozen = Math.min(frozenNatural, frozenCap);
+  return {
+    frozen,
+    scrollable: Math.max(SETTINGS_MIN_LIST_HEIGHT, available - frozen)
+  };
+};
+const VirtualizedColumnRow = memo(function VirtualizedColumnRow2({ index, style, data }) {
+  const { column, level, section, hasChildren, isCollapsed } = data.rows[index];
+  const isFrozen = section === "frozen";
+  const checkState = data.checkStateMap.get(column.colId) || {
+    checked: !!column.isVisible,
+    indeterminate: false
+  };
+  const rowProps = {
+    checkboxChecked: checkState.checked,
+    column,
+    dragIconClass: isFrozen ? "table-setting-frozen-columns-list-drag-icon" : "table-setting-scroll-columns-list-drag-icon",
+    hasChildren,
+    isCollapsed,
+    isIndeterminate: checkState.indeterminate,
+    level,
+    reserveCollapseSlot: isFrozen ? hasChildren : true,
+    rowClassName: isFrozen ? "table-setting-frozen-columns-list-item" : "table-setting-scroll-inner-column",
+    onToggleCollapse: isFrozen ? data.onToggleFrozenCollapse : data.onToggleScrollCollapse,
+    onToggleVisibility: isFrozen ? data.onToggleVisibilityFrozen : data.onToggleVisibilityScroll
+  };
+  return /* @__PURE__ */ jsx("div", { className: "table-setting-column-virtual-row", style, children: column.isVisible !== false ? /* @__PURE__ */ jsx(SortableColumnItem, { ...rowProps, onKeyboardReorder: data.onKeyboardReorder }) : /* @__PURE__ */ jsx(NestedColumnItem, { ...rowProps }) });
+});
+const getVirtualRowKey = (index, data) => data.rows[index].column.colId;
+const createTreeListOuter = (ariaLabel) => {
+  const TreeListOuter = React__default.forwardRef((props, ref) => /* @__PURE__ */ jsx("div", { ref, "aria-label": ariaLabel, role: "tree", ...props }));
+  TreeListOuter.displayName = `TreeListOuter(${ariaLabel})`;
+  return TreeListOuter;
+};
+const FrozenListOuter = createTreeListOuter("Frozen columns");
+const ScrollableListOuter = createTreeListOuter("Scrollable columns");
+const getScrollRange = (el) => Math.max(0, el.scrollHeight - el.clientHeight);
+const getListScrollRange = (rowCount, viewportHeight) => Math.max(0, rowCount * SETTINGS_ROW_HEIGHT - viewportHeight);
+const VirtualColumnList = ({
+  className,
+  itemData,
+  maxHeight,
+  outerElementType,
+  outerRef,
+  rows
+}) => {
+  const fixedListRef = useRef(null);
+  const listOuterRef = useRef(null);
+  const scrollbarRef = useRef(null);
+  const isDraggingBarRef = useRef(false);
+  const releaseBarRef = useRef(null);
+  const listScrollRangeRef = useRef(0);
+  const setOuterRef = useCallback(
+    (node) => {
+      listOuterRef.current = node;
+      if (typeof outerRef === "function") {
+        outerRef(node);
+      } else if (outerRef) {
+        outerRef.current = node;
+      }
+    },
+    [outerRef]
+  );
+  const scrollListToOffset = useCallback((offset) => {
+    var _a;
+    const range = listScrollRangeRef.current;
+    const clamped = Math.max(0, Math.min(offset, range));
+    if ((_a = fixedListRef.current) == null ? void 0 : _a.scrollTo) {
+      fixedListRef.current.scrollTo(clamped);
+    } else if (listOuterRef.current) {
+      listOuterRef.current.scrollTop = clamped;
+    }
+  }, []);
+  const syncBarToListOffset = useCallback((listOffset) => {
+    const bar = scrollbarRef.current;
+    const listRange = listScrollRangeRef.current;
+    if (!bar || listRange <= 0) return;
+    const barRange = getScrollRange(bar);
+    const ratio = listOffset / listRange;
+    bar.scrollTop = ratio * barRange;
+  }, []);
+  const handleScrollbarPointerDown = useCallback((event) => {
+    isDraggingBarRef.current = true;
+    if (event.currentTarget.setPointerCapture) {
+      event.currentTarget.setPointerCapture(event.pointerId);
+    }
+    const release = (ev) => {
+      var _a;
+      isDraggingBarRef.current = false;
+      if (((_a = scrollbarRef.current) == null ? void 0 : _a.releasePointerCapture) && (ev == null ? void 0 : ev.pointerId) != null) {
+        try {
+          scrollbarRef.current.releasePointerCapture(ev.pointerId);
+        } catch {
+        }
+      }
+      window.removeEventListener("pointerup", release);
+      window.removeEventListener("pointercancel", release);
+      releaseBarRef.current = null;
+    };
+    releaseBarRef.current = release;
+    window.addEventListener("pointerup", release);
+    window.addEventListener("pointercancel", release);
+  }, []);
+  useEffect(() => () => {
+    var _a;
+    return (_a = releaseBarRef.current) == null ? void 0 : _a.call(releaseBarRef);
+  }, []);
+  const handleListScroll = useCallback(
+    ({ scrollOffset }) => {
+      if (isDraggingBarRef.current) return;
+      syncBarToListOffset(scrollOffset);
+    },
+    [syncBarToListOffset]
+  );
+  const handleScrollbarScroll = useCallback(
+    (event) => {
+      const bar = event.currentTarget;
+      const barRange = getScrollRange(bar);
+      const listRange = listScrollRangeRef.current;
+      if (barRange <= 0 || listRange <= 0) return;
+      const ratio = bar.scrollTop / barRange;
+      scrollListToOffset(ratio * listRange);
+    },
+    [scrollListToOffset]
+  );
+  const contentHeight = rows.length * SETTINGS_ROW_HEIGHT;
+  const height = Math.max(
+    SETTINGS_ROW_HEIGHT,
+    Math.min(contentHeight || SETTINGS_ROW_HEIGHT, maxHeight)
+  );
+  const needsScrollbar = rows.length > 0 && contentHeight > height;
+  listScrollRangeRef.current = getListScrollRange(rows.length, height);
+  useLayoutEffect(() => {
+    var _a;
+    if (!needsScrollbar) return;
+    const listOffset = ((_a = listOuterRef.current) == null ? void 0 : _a.scrollTop) ?? 0;
+    syncBarToListOffset(listOffset);
+  }, [needsScrollbar, height, rows.length, syncBarToListOffset]);
+  if (rows.length === 0) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: `table-setting-column-virtual-wrapper ${needsScrollbar ? "has-detached-scrollbar" : ""}`,
+      style: { height },
+      children: [
+        /* @__PURE__ */ jsx(
+          FixedSizeList,
+          {
+            ref: fixedListRef,
+            className: `${className} table-setting-column-virtual-list`,
+            height,
+            itemCount: rows.length,
+            itemData,
+            itemKey: getVirtualRowKey,
+            itemSize: SETTINGS_ROW_HEIGHT,
+            outerElementType,
+            outerRef: setOuterRef,
+            overscanCount: 8,
+            width: "100%",
+            onScroll: handleListScroll,
+            children: VirtualizedColumnRow
+          }
+        ),
+        needsScrollbar && /* @__PURE__ */ jsx(
+          "div",
+          {
+            ref: scrollbarRef,
+            "aria-hidden": "true",
+            className: "table-setting-column-virtual-scrollbar",
+            style: { height },
+            onPointerDown: handleScrollbarPointerDown,
+            onScroll: handleScrollbarScroll,
+            children: /* @__PURE__ */ jsx("div", { style: { height: contentHeight, width: 1 } })
+          }
+        )
+      ]
+    }
+  );
+};
+export {
+  FrozenListOuter,
+  SETTINGS_FROZEN_LIST_MAX_HEIGHT,
+  SETTINGS_ROW_HEIGHT,
+  SETTINGS_SCROLL_LIST_MAX_HEIGHT,
+  SETTINGS_VIRTUALIZE_THRESHOLD,
+  ScrollableListOuter,
+  VirtualColumnList,
+  buildCheckStateMap,
+  computeSettingsListHeights,
+  flattenColumnRows,
+  scrollListTowardPointer
+};

package/dist/components/TableV36/filterUtils.d.ts

@@ -0,0 +1,133 @@
+export declare const getOperatorListForColumn: (columnDef: any) => any;
+export declare const getDefaultOperationForColumn: (columnDef: any, filter?: null) => any;
+/**
+ * Removes special characters from numeric strings
+ * Supports: currency symbols ($, €, £, ¥, ₹), commas, spaces, percentages
+ * @param {string} value - The value to clean
+ * @returns {string} - Cleaned value
+ */
+export declare const cleanNumericValue: (value: any) => any;
+/**
+ * Parses a filter value based on the column type and definition
+ * @param {*} value - The raw filter value
+ * @param {object} columnDef - The column definition from AG Grid
+ * @returns {object} - { parsedValue, filterType }
+ */
+export declare const parseFilterValue: (value: any, columnDef: any) => {
+    parsedValue: any;
+    filterType: string;
+};
+/**
+ * Determines if a column value is a string or number by checking first row data
+ * Used to decide between "equals" (numbers) vs "contains" (strings) filter type
+ * @param {object} api - AG Grid API
+ * @param {string} columnId - Column ID to check
+ * @returns {boolean} - true if column contains string values
+ */
+export declare const isColumnDataString: (api: any, columnId: any) => boolean;
+/**
+ * Builds a filter model entry for AG Grid
+ * Supports all AG Grid filter operators including:
+ * - Text: contains, notContains, equals, notEqual, startsWith, endsWith, blank, notBlank
+ * - Number: equals, notEqual, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, blank, notBlank
+ * - Date: equals, notEqual, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, inRange, blank, notBlank
+ *
+ * @param {*} parsedValue - The parsed filter value
+ * @param {string} filterType - The filter type (equals, contains, etc.)
+ * @param {object} columnDef - The column definition
+ * @param {string} operationType - Optional operation type from advance search
+ * @returns {object|undefined} - Filter model entry or undefined if invalid
+ */
+export declare const buildFilterModelEntry: (parsedValue: any, filterType: any, columnDef: any, operationType?: null) => any;
+/**
+ * Recursively finds a column definition by field or colId
+ * @param {array} colDefs - Array of column definitions
+ * @param {string} field - Field or colId to find
+ * @returns {object|null} - Column definition or null
+ */
+export declare const findColumnDef: (colDefs: any, field: any) => any;
+/**
+ * Applies inline search filter for a single column
+ * Handles special logic for number columns with formatted vs raw data
+ * @param {*} value - Search value
+ * @param {object} columnDef - Column definition
+ * @param {object} api - AG Grid API
+ * @param {string} columnId - Column ID
+ * @returns {object} - { parsedValue, filterType }
+ */
+export declare const parseInlineSearchValue: (value: any, columnDef: any, api: any, columnId: any) => {
+    parsedValue: any;
+    filterType: string;
+};
+/**
+ * Validates if a parsed value is valid for filtering
+ * @param {*} parsedValue - The parsed value to validate
+ * @returns {boolean} - true if valid
+ */
+export declare const isValidFilterValue: (parsedValue: any) => boolean;
+/**
+ * Gets the display label for a column (handles nested/hierarchical columns)
+ * @param {string} columnId - The column ID
+ * @param {object} columnDef - The column definition
+ * @param {array} colDefs - All column definitions
+ * @returns {string} - Display label for the column
+ */
+export declare const getColumnLabel: (columnId: any, columnDef: any, colDefs: any) => any;
+/**
+ * Validates if a filter in the filter model has a valid value
+ * @param {object} filter - Filter object from filter model
+ * @returns {boolean} - true if filter has valid value
+ */
+export declare const hasValidFilterValue: (filter: any) => boolean;
+/**
+ * Converts AG Grid filter model entry to advance search modal format
+ * @param {string} columnId - Column ID
+ * @param {object} filter - Filter from filter model
+ * @param {object} columnDef - Column definition
+ * @param {array} colDefs - All column definitions
+ * @returns {object} - Filter in modal format
+ */
+export declare const convertFilterToModalFormat: (columnId: any, filter: any, columnDef: any, colDefs: any) => {
+    column: {
+        label: any;
+        value: any;
+        type: any;
+    };
+    operation: {
+        label: any;
+        value: any;
+    };
+    value: any;
+};
+/**
+ * Updates existing filters or adds new filter
+ * @param {array} existingFilters - Current filters in modal format
+ * @param {string} columnId - Column ID being updated
+ * @param {*} value - New filter value
+ * @param {object} columnDef - Column definition
+ * @param {array} colDefs - All column definitions
+ * @returns {array} - Updated filters array
+ */
+export declare const updateOrAddFilter: (existingFilters: any, columnId: any, value: any, columnDef: any, colDefs: any) => any;
+/**
+ * Syncs AG Grid filter model with advance search modal state
+ * Clean, step-by-step approach for better maintainability
+ *
+ * @param {object} api - AG Grid API
+ * @param {string} currentColumnId - Current column being filtered
+ * @param {*} inputValue - The filter value
+ * @param {object} columnDef - Column definition
+ * @param {array} colDefs - All column definitions
+ * @param {function} setValue - Form setValue function
+ * @param {function} setInitialFilters - Set initial filters function
+ * @param {function} getOptionFromDropdownValue - Function to convert dropdown values
+ */
+export declare const syncFiltersWithModal: (api: any, currentColumnId: any, inputValue: any, columnDef: any, colDefs: any, setValue: any, setInitialFilters: any, getOptionFromDropdownValue: any) => void;
+/**
+ * Processes advance search filters and builds AG Grid filter model
+ * @param {array} formValues - Array of filter objects from form
+ * @param {array} colDefs - Column definitions
+ * @returns {object} - AG Grid filter model
+ */
+export declare const buildAdvanceSearchFilterModel: (formValues: any, colDefs: any) => {};
+//# sourceMappingURL=filterUtils.d.ts.map

package/dist/components/TableV36/filterUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterUtils.d.ts","sourceRoot":"","sources":["../../../src/components/TableV36/filterUtils.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,wBAAwB,GAAI,cAAS,QAoDjD,CAAC;AAGF,eAAO,MAAM,4BAA4B,GAAI,cAAS,EAAE,aAAa,QAyBpE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAK,QAMtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAK,EAAE,cAAS;;;CA4EhD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAG,EAAE,aAAQ,YAQ/C,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,GAAI,gBAAW,EAAE,eAAU,EAAE,cAAS,EAAE,oBAAoB,QAsI7F,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GAAI,YAAO,EAAE,UAAK,QAoB3C,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAK,EAAE,cAAS,EAAE,QAAG,EAAE,aAAQ;;;CA0ErE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,gBAAW,YAwB7C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,aAAQ,EAAE,cAAS,EAAE,YAAO,QAc1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,WAAM,YAUzC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,aAAQ,EAAE,WAAM,EAAE,cAAS,EAAE,YAAO;;;;;;;;;;;CA4C9E,CAAC;AAqGF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAAI,oBAAe,EAAE,aAAQ,EAAE,UAAK,EAAE,cAAS,EAAE,YAAO,QAUrF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAG,EACH,oBAAe,EACf,eAAU,EACV,cAAS,EACT,YAAO,EACP,aAAQ,EACR,sBAAiB,EACjB,+BAA0B,SA2B3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,GAAI,eAAU,EAAE,YAAO,OAqChE,CAAC"}