@revolist/revogrid 3.2.12 → 3.2.13

package/custom-element/columnService.js

@@ -1,743 +0,0 @@
-/*!
- * Built by Revolist
- */
-import { h } from '@stencil/core/internal/client';
-import { c as createStore, d as setStore, b as getVisibleSourceItem, g as getSourceItem, s as setSourceByVirtualIndex } from './data.store.js';
-import { G as GRID_INTERNALS, h as CELL_CLASS, i as DISABLED_CLASS } from './consts.js';
-
-const GROUP_DEPTH = `${GRID_INTERNALS}-depth`;
-const PSEUDO_GROUP_ITEM = `${GRID_INTERNALS}-name`;
-const PSEUDO_GROUP_ITEM_ID = `${GRID_INTERNALS}-id`;
-const PSEUDO_GROUP_ITEM_VALUE = `${GRID_INTERNALS}-value`;
-const PSEUDO_GROUP_COLUMN = `${GRID_INTERNALS}-column`;
-const GROUP_EXPANDED = `${GRID_INTERNALS}-expanded`;
-const GROUP_EXPAND_BTN = `group-expand`;
-const GROUP_EXPAND_EVENT = `groupExpandClick`;
-const GROUPING_ROW_TYPE = 'rgRow';
-
-/**
- * Do actual grouping
- * @param array - items to group
- * @param f - function responsible for grouping, returns property to group by
- */
-function groupBy(array, f) {
-  const groupsOrder = [];
-  const itemsByGroup = {};
-  array.forEach((item, i) => {
-    // get grouping values
-    const groupKeys = JSON.stringify(f(item));
-    // new group identification
-    if (!itemsByGroup[groupKeys]) {
-      itemsByGroup[groupKeys] = new Map();
-      // create group parents
-      groupsOrder.push({
-        children: itemsByGroup[groupKeys],
-        id: groupKeys,
-      });
-    }
-    // save to group with previous index
-    itemsByGroup[groupKeys].set(i, item);
-  });
-  return groupsOrder;
-}
-/**
- * Gather data for grouping
- * @param array - flat data array
- * @param mapFunc - mapping function for stringify
- * @param expanded - potentially expanded items if present
- */
-function gatherGrouping(array, mapFunc, { prevExpanded, expandedAll }) {
-  // build groups
-  const groupsOrder = groupBy(array, mapFunc);
-  const itemsMirror = []; // grouped source
-  const pseudoGroupTest = {}; // check if group header exists
-  // item index in source
-  let itemIndex = 0;
-  // to save max group depth
-  let groupingDepth = 0;
-  // collapse all groups in the beginning
-  const trimmed = {};
-  // index mapping
-  const oldNewIndexMap = {};
-  // go through groups
-  groupsOrder.forEach(group => {
-    const parseGroup = getParsedGroup(group.id);
-    // extra precaution and type safe guard
-    if (!parseGroup) {
-      return;
-    }
-    let depth = 0;
-    let skipTrim = !!expandedAll;
-    let isExpanded = skipTrim;
-    const children = [];
-    // add group headers
-    parseGroup.reduce((prevVal, groupValue) => {
-      prevVal.push(groupValue);
-      const newVal = prevVal.join(',');
-      // if header not added, add new header
-      if (!pseudoGroupTest[newVal]) {
-        isExpanded = expandedAll || (prevExpanded && prevExpanded[newVal]);
-        itemsMirror.push(getPseudoGroup(groupValue, newVal, depth, group.id, isExpanded));
-        // if not first level auto collapse
-        if (depth && !isExpanded && !skipTrim) {
-          // check if parent expanded, expand this layer too
-          const parent = prevVal.slice(0, prevVal.length - 1);
-          if (!(prevExpanded && parent.length && prevExpanded[parent.join(',')])) {
-            trimmed[itemIndex] = true;
-          }
-        }
-        itemIndex++;
-        pseudoGroupTest[newVal] = children;
-      }
-      // calculate depth
-      depth++;
-      groupingDepth = depth;
-      return prevVal;
-    }, []);
-    // add regular items
-    group.children.forEach((item, oldIndex) => {
-      // hide items if group colapsed
-      if (!isExpanded && !skipTrim) {
-        // collapse rgRow
-        trimmed[itemIndex] = true;
-      }
-      // add items to new source
-      itemsMirror.push(item);
-      oldNewIndexMap[oldIndex] = itemIndex;
-      children.push(itemIndex);
-      itemIndex++;
-    });
-  });
-  return {
-    // updates source mirror
-    sourceWithGroups: itemsMirror,
-    // largest depth for grouping
-    depth: groupingDepth,
-    // used for expand/collapse grouping values
-    trimmed,
-    // used for mapping old values to new
-    oldNewIndexMap,
-    // used to get child items in group
-    childrenByGroup: pseudoGroupTest,
-  };
-}
-function getPseudoGroup(groupValue, value, depth, id, isExpanded = false) {
-  return {
-    [PSEUDO_GROUP_ITEM]: groupValue,
-    [GROUP_DEPTH]: depth,
-    [PSEUDO_GROUP_ITEM_ID]: id,
-    [PSEUDO_GROUP_ITEM_VALUE]: value,
-    [GROUP_EXPANDED]: isExpanded,
-  };
-}
-function getGroupingName(rgRow) {
-  return rgRow && rgRow[PSEUDO_GROUP_ITEM];
-}
-function isGrouping(rgRow) {
-  return rgRow && typeof rgRow[PSEUDO_GROUP_ITEM] !== 'undefined';
-}
-function isGroupingColumn(column) {
-  return column && typeof column[PSEUDO_GROUP_COLUMN] !== 'undefined';
-}
-function isArray(data) {
-  return typeof data.push !== 'undefined';
-}
-function measureEqualDepth(groupA, groupB) {
-  const ln = groupA.length;
-  let i = 0;
-  for (; i < ln; i++) {
-    if (groupA[i] !== groupB[i]) {
-      return i;
-    }
-  }
-  return i;
-}
-function getParsedGroup(id) {
-  const parseGroup = JSON.parse(id);
-  // extra precaution and type safe guard
-  if (!isArray(parseGroup)) {
-    return null;
-  }
-  return parseGroup;
-}
-// check if items is child of current clicked group
-function isSameGroup(currentGroup, currentModel, nextModel) {
-  const nextGroup = getParsedGroup(nextModel[PSEUDO_GROUP_ITEM_ID]);
-  if (!nextGroup) {
-    return false;
-  }
-  const depth = measureEqualDepth(currentGroup, nextGroup);
-  return currentModel[GROUP_DEPTH] < depth;
-}
-
-function isHiddenStore(pos) {
-  return pos === EMPTY_INDEX;
-}
-function nextCell(cell, lastCell) {
-  const nextItem = {};
-  let types = ['x', 'y'];
-  // previous item check
-  for (let t of types) {
-    if (cell[t] < 0) {
-      nextItem[t] = cell[t];
-      return nextItem;
-    }
-  }
-  // next item check
-  for (let t of types) {
-    if (cell[t] >= lastCell[t]) {
-      nextItem[t] = cell[t] - lastCell[t];
-      return nextItem;
-    }
-  }
-  return null;
-}
-function cropCellToMax(cell, lastCell) {
-  const newCell = Object.assign({}, cell);
-  let types = ['x', 'y'];
-  // previous item check
-  for (let t of types) {
-    if (cell[t] < 0) {
-      newCell[t] = 0;
-    }
-  }
-  // next item check
-  for (let t of types) {
-    if (cell[t] >= lastCell[t]) {
-      newCell[t] = lastCell[t] - 1;
-    }
-  }
-  return newCell;
-}
-function getRange(start, end) {
-  return start && end
-    ? {
-      x: Math.min(start.x, end.x),
-      y: Math.min(start.y, end.y),
-      x1: Math.max(start.x, end.x),
-      y1: Math.max(start.y, end.y),
-    }
-    : null;
-}
-function isRangeSingleCell(a) {
-  return a.x === a.x1 && a.y === a.y1;
-}
-
-function defaultState() {
-  return {
-    range: null,
-    tempRange: null,
-    tempRangeType: null,
-    focus: null,
-    edit: null,
-    lastCell: null,
-  };
-}
-class SelectionStore {
-  constructor() {
-    this.unsubscribe = [];
-    this.store = createStore(defaultState());
-    this.store.on('set', (key, newVal) => {
-      if (key === 'tempRange' && !newVal) {
-        this.store.set('tempRangeType', null);
-      }
-    });
-  }
-  onChange(propName, cb) {
-    this.unsubscribe.push(this.store.onChange(propName, cb));
-  }
-  clearFocus() {
-    setStore(this.store, { focus: null, range: null, edit: null, tempRange: null });
-  }
-  setFocus(focus, end) {
-    setStore(this.store, {
-      focus,
-      range: getRange(focus, end),
-      edit: null,
-      tempRange: null,
-    });
-  }
-  setTempArea(range) {
-    setStore(this.store, { tempRange: range === null || range === void 0 ? void 0 : range.area, tempRangeType: range === null || range === void 0 ? void 0 : range.type, edit: null });
-  }
-  clearTemp() {
-    setStore(this.store, { tempRange: null });
-  }
-  /** Can be applied from selection change or from simple keyboard change clicks */
-  setRangeArea(range) {
-    setStore(this.store, { range, edit: null, tempRange: null });
-  }
-  setRange(start, end) {
-    this.setRangeArea(getRange(start, end));
-  }
-  setLastCell(lastCell) {
-    setStore(this.store, { lastCell });
-  }
-  setEdit(val) {
-    const focus = this.store.get('focus');
-    if (focus && typeof val === 'string') {
-      setStore(this.store, {
-        edit: { x: focus.x, y: focus.y, val },
-      });
-      return;
-    }
-    setStore(this.store, { edit: null });
-  }
-  dispose() {
-    this.unsubscribe.forEach(f => f());
-    this.store.dispose();
-  }
-}
-
-const EMPTY_INDEX = -1;
-class SelectionStoreConnector {
-  constructor() {
-    // dirty flag required to cleanup whole store in case visibility of panels changed
-    this.dirty = false;
-    this.stores = {};
-    this.columnStores = {};
-    this.rowStores = {};
-    this.sections = [];
-  }
-  get focusedStore() {
-    var _a;
-    for (let y in this.stores) {
-      for (let x in this.stores[y]) {
-        const focused = (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.store.get('focus');
-        if (focused) {
-          return {
-            entity: this.stores[y][x],
-            cell: focused,
-            position: {
-              x: parseInt(x, 10),
-              y: parseInt(y, 10)
-            }
-          };
-        }
-      }
-    }
-    return null;
-  }
-  get edit() {
-    var _a;
-    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('edit');
-  }
-  get focused() {
-    var _a;
-    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('focus');
-  }
-  get selectedRange() {
-    var _a;
-    return (_a = this.focusedStore) === null || _a === void 0 ? void 0 : _a.entity.store.get('range');
-  }
-  registerSection(e) {
-    if (!e) {
-      this.sections.length = 0;
-      // some elements removed, rebuild stores
-      this.dirty = true;
-      return;
-    }
-    if (this.sections.indexOf(e) === -1) {
-      this.sections.push(e);
-    }
-  }
-  // check if require to cleanup all stores
-  beforeUpdate() {
-    if (this.dirty) {
-      for (let y in this.stores) {
-        for (let x in this.stores[y]) {
-          this.stores[y][x].dispose();
-        }
-      }
-      this.dirty = false;
-    }
-  }
-  registerColumn(x) {
-    // if hidden just create store
-    if (isHiddenStore(x)) {
-      return new SelectionStore();
-    }
-    if (this.columnStores[x]) {
-      return this.columnStores[x];
-    }
-    this.columnStores[x] = new SelectionStore();
-    return this.columnStores[x];
-  }
-  registerRow(y) {
-    // if hidden just create store
-    if (isHiddenStore(y)) {
-      return new SelectionStore();
-    }
-    if (this.rowStores[y]) {
-      return this.rowStores[y];
-    }
-    this.rowStores[y] = new SelectionStore();
-    return this.rowStores[y];
-  }
-  /**
-   * Cross store proxy, based on multiple dimensions
-   */
-  register({ x, y }) {
-    var _a, _b;
-    // if hidden just create store
-    if (isHiddenStore(x) || isHiddenStore(y)) {
-      return new SelectionStore();
-    }
-    if (!this.stores[y]) {
-      this.stores[y] = {};
-    }
-    if (this.stores[y][x]) {
-      // Store already registered. Do not register twice
-      return this.stores[y][x];
-    }
-    this.stores[y][x] = new SelectionStore();
-    // proxy update
-    (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.onChange('range', c => {
-      this.columnStores[x].setRangeArea(c);
-      this.rowStores[y].setRangeArea(c);
-    });
-    // clean up on remove
-    (_b = this.stores[y][x]) === null || _b === void 0 ? void 0 : _b.store.on('dispose', () => {
-      var _a, _b;
-      (_a = this.columnStores[x]) === null || _a === void 0 ? void 0 : _a.dispose();
-      (_b = this.rowStores[y]) === null || _b === void 0 ? void 0 : _b.dispose();
-      delete this.rowStores[y];
-      delete this.columnStores[x];
-      if (this.stores[y]) {
-        delete this.stores[y][x];
-      }
-      // clear empty rows
-      if (!Object.keys(this.stores[y] || {}).length) {
-        delete this.stores[y];
-      }
-    });
-    return this.stores[y][x];
-  }
-  setEditByCell({ x, y }, editCell) {
-    const store = this.stores[y][x];
-    this.focus(store, { focus: editCell, end: editCell });
-    this.setEdit('');
-  }
-  focus(store, { focus, end }) {
-    let currentStorePointer;
-    // clear all stores focus leave only active one
-    for (let y in this.stores) {
-      for (let x in this.stores[y]) {
-        const s = this.stores[y][x];
-        // clear other stores, only one area can be selected
-        if (s !== store) {
-          s.clearFocus();
-        }
-        else {
-          currentStorePointer = { x: parseInt(x, 10), y: parseInt(y, 10) };
-        }
-      }
-    }
-    if (!currentStorePointer) {
-      return;
-    }
-    // check is focus in next store
-    const lastCell = store.store.get('lastCell');
-    // item in new store
-    const nextItem = nextCell(focus, lastCell);
-    let nextStore;
-    if (nextItem) {
-      for (let i in nextItem) {
-        let type = i;
-        let stores;
-        switch (type) {
-          case 'x':
-            stores = this.getXStores(currentStorePointer.y);
-            break;
-          case 'y':
-            stores = this.getYStores(currentStorePointer.x);
-            break;
-        }
-        if (nextItem[type] >= 0) {
-          nextStore = stores[++currentStorePointer[type]];
-        }
-        else {
-          nextStore = stores[--currentStorePointer[type]];
-          const nextLastCell = nextStore === null || nextStore === void 0 ? void 0 : nextStore.store.get('lastCell');
-          if (nextLastCell) {
-            nextItem[type] = nextLastCell[type] + nextItem[type];
-          }
-        }
-      }
-    }
-    // if next store present - update
-    if (nextStore) {
-      let item = Object.assign(Object.assign({}, focus), nextItem);
-      this.focus(nextStore, { focus: item, end: item });
-      return;
-    }
-    focus = cropCellToMax(focus, lastCell);
-    end = cropCellToMax(focus, lastCell);
-    store.setFocus(focus, end);
-  }
-  clearAll() {
-    var _a;
-    for (let y in this.stores) {
-      for (let x in this.stores[y]) {
-        (_a = this.stores[y][x]) === null || _a === void 0 ? void 0 : _a.clearFocus();
-      }
-    }
-  }
-  setEdit(val) {
-    if (!this.focusedStore) {
-      return;
-    }
-    this.focusedStore.entity.setEdit(val);
-  }
-  getXStores(y) {
-    return this.stores[y];
-  }
-  getYStores(x) {
-    const stores = {};
-    for (let i in this.stores) {
-      stores[i] = this.stores[i][x];
-    }
-    return stores;
-  }
-}
-
-class ColumnService {
-  constructor(dataStore, source) {
-    this.dataStore = dataStore;
-    this.source = source;
-    this.unsubscribe = [];
-    this.hasGrouping = false;
-    this.unsubscribe.push(source.onChange('source', s => this.checkGrouping(s)));
-    this.checkGrouping(source.get('source'));
-  }
-  get columns() {
-    return getVisibleSourceItem(this.source);
-  }
-  checkGrouping(cols) {
-    for (let rgCol of cols) {
-      if (isGroupingColumn(rgCol)) {
-        this.hasGrouping = true;
-        return;
-      }
-      this.hasGrouping = false;
-    }
-  }
-  isReadOnly(r, c) {
-    var _a;
-    const readOnly = (_a = this.columns[c]) === null || _a === void 0 ? void 0 : _a.readonly;
-    if (typeof readOnly === 'function') {
-      const data = this.rowDataModel(r, c);
-      return readOnly(data);
-    }
-    return readOnly;
-  }
-  static doMerge(existing, extra) {
-    let props = Object.assign(Object.assign({}, extra), existing);
-    // extend existing props
-    if (extra.class) {
-      if (typeof extra.class === 'object' && typeof props.class === 'object') {
-        props.class = Object.assign(Object.assign({}, extra.class), props.class);
-      }
-      else if (typeof extra.class === 'string' && typeof props.class === 'object') {
-        props.class[extra.class] = true;
-      }
-      else if (typeof props.class === 'string') {
-        props.class += ' ' + extra.class;
-      }
-    }
-    if (extra.style) {
-      props.style = Object.assign(Object.assign({}, extra.style), props.style);
-    }
-    return props;
-  }
-  mergeProperties(r, c, defaultProps) {
-    var _a;
-    const cellClass = {
-      [CELL_CLASS]: true,
-      [DISABLED_CLASS]: this.isReadOnly(r, c),
-    };
-    let props = Object.assign(Object.assign({}, defaultProps), { class: cellClass });
-    const extraPropsFunc = (_a = this.columns[c]) === null || _a === void 0 ? void 0 : _a.cellProperties;
-    if (extraPropsFunc) {
-      const data = this.rowDataModel(r, c);
-      const extra = extraPropsFunc(data);
-      if (!extra) {
-        return props;
-      }
-      return ColumnService.doMerge(props, extra);
-    }
-    return props;
-  }
-  customRenderer(_r, c, model) {
-    var _a;
-    const tpl = (_a = this.columns[c]) === null || _a === void 0 ? void 0 : _a.cellTemplate;
-    if (tpl) {
-      return tpl(h, model);
-    }
-    return;
-  }
-  getRowClass(r, prop) {
-    const model = getSourceItem(this.dataStore, r) || {};
-    return model[prop] || '';
-  }
-  getCellData(r, c) {
-    const data = this.rowDataModel(r, c);
-    return ColumnService.getData(data.model[data.prop]);
-  }
-  getSaveData(rowIndex, c, val) {
-    if (typeof val === 'undefined') {
-      val = this.getCellData(rowIndex, c);
-    }
-    const data = this.rowDataModel(rowIndex, c);
-    return {
-      prop: data.prop,
-      rowIndex,
-      val,
-      model: data.model,
-      type: this.dataStore.get('type'),
-    };
-  }
-  getCellEditor(_r, c, editors) {
-    var _a;
-    const editor = (_a = this.columns[c]) === null || _a === void 0 ? void 0 : _a.editor;
-    if (!editor) {
-      return undefined;
-    }
-    // reference
-    if (typeof editor === 'string') {
-      return editors[editor];
-    }
-    return editor;
-  }
-  rowDataModel(rowIndex, c) {
-    const column = this.columns[c];
-    const prop = column === null || column === void 0 ? void 0 : column.prop;
-    const model = getSourceItem(this.dataStore, rowIndex) || {};
-    return {
-      prop,
-      model,
-      data: this.dataStore.get('source'),
-      column,
-      rowIndex,
-    };
-  }
-  getRangeData(d) {
-    const changed = {};
-    // get original length sizes
-    const copyColLength = d.oldProps.length;
-    const copyFrom = this.copyRangeArray(d.oldRange, d.oldProps, this.dataStore);
-    const copyRowLength = copyFrom.length;
-    // rows
-    for (let rowIndex = d.newRange.y, i = 0; rowIndex < d.newRange.y1 + 1; rowIndex++, i++) {
-      // copy original data link
-      const copyRow = copyFrom[i % copyRowLength];
-      // columns
-      for (let colIndex = d.newRange.x, j = 0; colIndex < d.newRange.x1 + 1; colIndex++, j++) {
-        // check if old range area
-        if (rowIndex >= d.oldRange.y && rowIndex <= d.oldRange.y1 && colIndex >= d.oldRange.x && colIndex <= d.oldRange.x1) {
-          continue;
-        }
-        const p = this.columns[colIndex].prop;
-        const currentCol = j % copyColLength;
-        /** if can write */
-        if (!this.isReadOnly(rowIndex, colIndex)) {
-          /** to show before save */
-          if (!changed[rowIndex]) {
-            changed[rowIndex] = {};
-          }
-          changed[rowIndex][p] = copyRow[currentCol];
-        }
-      }
-    }
-    return changed;
-  }
-  getTransformedDataToApply(start, data) {
-    const changed = {};
-    const copyRowLength = data.length;
-    const colLength = this.columns.length;
-    const rowLength = this.dataStore.get('items').length;
-    // rows
-    let rowIndex = start.y;
-    let maxCol = 0;
-    for (let i = 0; rowIndex < rowLength && i < copyRowLength; rowIndex++, i++) {
-      // copy original data link
-      const copyRow = data[i % copyRowLength];
-      const copyColLength = (copyRow === null || copyRow === void 0 ? void 0 : copyRow.length) || 0;
-      // columns
-      let colIndex = start.x;
-      for (let j = 0; colIndex < colLength && j < copyColLength; colIndex++, j++) {
-        const p = this.columns[colIndex].prop;
-        const currentCol = j % colLength;
-        /** if can write */
-        if (!this.isReadOnly(rowIndex, colIndex)) {
-          /** to show before save */
-          if (!changed[rowIndex]) {
-            changed[rowIndex] = {};
-          }
-          changed[rowIndex][p] = copyRow[currentCol];
-        }
-      }
-      maxCol = Math.max(maxCol, colIndex - 1);
-    }
-    const range = getRange(start, {
-      y: rowIndex - 1,
-      x: maxCol,
-    });
-    return {
-      changed,
-      range,
-    };
-  }
-  applyRangeData(data) {
-    const items = {};
-    for (let rowIndex in data) {
-      const oldModel = (items[rowIndex] = getSourceItem(this.dataStore, parseInt(rowIndex, 10)));
-      for (let prop in data[rowIndex]) {
-        oldModel[prop] = data[rowIndex][prop];
-      }
-    }
-    setSourceByVirtualIndex(this.dataStore, items);
-  }
-  getRangeStaticData(d, value) {
-    const changed = {};
-    // rows
-    for (let rowIndex = d.y, i = 0; rowIndex < d.y1 + 1; rowIndex++, i++) {
-      // columns
-      for (let colIndex = d.x, j = 0; colIndex < d.x1 + 1; colIndex++, j++) {
-        const p = this.columns[colIndex].prop;
-        /** if can write */
-        if (!this.isReadOnly(rowIndex, colIndex)) {
-          /** to show before save */
-          if (!changed[rowIndex]) {
-            changed[rowIndex] = {};
-          }
-          changed[rowIndex][p] = value;
-        }
-      }
-    }
-    return changed;
-  }
-  copyRangeArray(range, rangeProps, store) {
-    const toCopy = [];
-    for (let i = range.y; i < range.y1 + 1; i++) {
-      const rgRow = [];
-      for (let prop of rangeProps) {
-        const item = getSourceItem(store, i);
-        rgRow.push(item[prop]);
-      }
-      toCopy.push(rgRow);
-    }
-    return toCopy;
-  }
-  static getData(val) {
-    if (typeof val === 'undefined' || val === null) {
-      return '';
-    }
-    return val.toString();
-  }
-  destroy() {
-    this.unsubscribe.forEach(f => f());
-  }
-}
-
-export { ColumnService as C, EMPTY_INDEX as E, GROUP_EXPANDED as G, PSEUDO_GROUP_ITEM_ID as P, SelectionStoreConnector as S, getParsedGroup as a, isSameGroup as b, GROUP_DEPTH as c, GROUPING_ROW_TYPE as d, PSEUDO_GROUP_ITEM_VALUE as e, PSEUDO_GROUP_COLUMN as f, getGroupingName as g, GROUP_EXPAND_EVENT as h, isGrouping as i, gatherGrouping as j, isGroupingColumn as k, GROUP_EXPAND_BTN as l, PSEUDO_GROUP_ITEM as m, getRange as n, isRangeSingleCell as o };