@univerjs/sheets 0.4.2 → 0.5.0-beta.0

package/lib/es/facade.js

@@ -0,0 +1,1806 @@
+var ue = Object.defineProperty;
+var me = (n, e, t) => e in n ? ue(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var E = (n, e, t) => me(n, typeof e != "symbol" ? e + "" : e, t);
+import { Inject as u, Injector as f, IAuthzIoService as le, FBase as U, generateRandomId as ge, Rectangle as j, ICommandService as R, IPermissionService as ie, HorizontalAlign as C, VerticalAlign as I, isFormulaString as _e, isCellV as we, isICellData as ke, ObjectMatrix as y, Tools as Se, RANGE_TYPE as l, BooleanNumber as m, WrapStrategy as H, Dimension as N, Direction as b, IResourceLoaderService as Ce, mergeWorksheetSnapshotWithDefault as Ie, UndoCommand as Re, RedoCommand as ve, toDisposable as fe, UniverInstanceType as O, IUniverInstanceService as ae, ILogService as be, FUniver as he } from "@univerjs/core";
+import { WorksheetProtectionRuleModel as pe, RangeProtectionRuleModel as ye, WorksheetProtectionPointModel as Pe, WorkbookEditablePermission as ce, UnitObject as v, AddWorksheetProtectionMutation as Ue, DeleteWorksheetProtectionMutation as xe, getAllWorksheetPermissionPoint as Ee, getAllWorksheetPermissionPointByPointPanel as $, SetWorksheetPermissionPointsMutation as Me, AddRangeProtectionMutation as Fe, DeleteRangeProtectionMutation as We, SetRangeProtectionMutation as Ae, WorksheetEditPermission as De, WorksheetViewPermission as Te, SetStyleCommand as _, SetRangeValuesCommand as G, SetTextWrapCommand as q, SetVerticalTextAlignCommand as je, SetHorizontalTextAlignCommand as Oe, addMergeCellsUtil as M, getAddMergeMutationRangeByType as Y, RemoveWorksheetMergeCommand as Ve, SheetsSelectionsService as de, SetWorksheetDefaultStyleMutation as ze, SetColDataCommand as J, SetRowDataCommand as K, copyRangeStyles as p, InsertRowCommand as Q, RemoveRowCommand as Le, MoveRowsCommand as Be, SetRowHiddenCommand as X, SetSpecificRowsVisibleCommand as Z, SetRowHeightCommand as ee, SetWorksheetRowIsAutoHeightCommand as He, InsertColCommand as te, RemoveColCommand as Ne, MoveColsCommand as $e, SetColHiddenCommand as ne, SetSpecificColsVisibleCommand as oe, SetColWidthCommand as Ge, SetFrozenCommand as qe, CancelFrozenCommand as Ye, ToggleGridlinesCommand as Je, SetRangeValuesMutation as se, InsertSheetCommand as re, SetWorksheetActiveOperation as F, RemoveSheetCommand as Ke, getPrimaryForRange as Qe, SetSelectionsOperation as Xe } from "@univerjs/sheets";
+import { FormulaDataModel as Ze, deserializeRangeWithSheet as et } from "@univerjs/engine-formula";
+var tt = Object.defineProperty, nt = Object.getOwnPropertyDescriptor, ot = (n, e, t, o) => {
+  for (var s = o > 1 ? void 0 : o ? nt(e, t) : e, r = n.length - 1, i; r >= 0; r--)
+    (i = n[r]) && (s = (o ? i(e, t, s) : i(s)) || s);
+  return o && s && tt(e, t, s), s;
+}, w = (n, e) => (t, o) => e(t, o, n);
+let V = class extends U {
+  constructor(n, e, t, o, s, r, i) {
+    super(), this._injector = n, this._commandService = e, this._permissionService = t, this._worksheetProtectionRuleModel = o, this._rangeProtectionRuleModel = s, this._worksheetProtectionPointRuleModel = r, this._authzIoService = i;
+  }
+  /**
+   * Configures a specific permission point for a workbook.
+   *
+   * This function sets or updates a permission point for a workbook identified by `unitId`.
+   * It creates a new permission point if it does not already exist, and updates the point with the provided value.
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {WorkbookPermissionPointConstructor} FPointClass - The constructor function for creating a permission point instance. Other point constructors can See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+   * @param {boolean} value - The boolean value to determine whether the permission point is enabled or disabled.
+   *
+   */
+  setWorkbookPermissionPoint(n, e, t) {
+    const o = new e(n);
+    this._permissionService.getPermissionPoint(o.id) || this._permissionService.addPermissionPoint(o), this._permissionService.updatePermissionPoint(o.id, t);
+  }
+  /**
+   * This function is used to set whether the workbook can be edited
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {boolean} value - A value that controls whether the workbook can be edited
+   *
+   */
+  setWorkbookEditPermission(n, e) {
+    this.setWorkbookPermissionPoint(n, ce, e);
+  }
+  /**
+   * This function is used to add a base permission for a worksheet.
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {string} subUnitId - The unique identifier of the worksheet for which the permission is being set.
+   *
+   * @returns {Promise<string | undefined>} - Returns the `permissionId` if the permission is successfully added. If the operation fails or no result is returned, it resolves to `undefined`.
+   */
+  async addWorksheetBasePermission(n, e) {
+    if (this._rangeProtectionRuleModel.getSubunitRuleList(n, e).length > 0)
+      throw new Error("sheet protection cannot intersect with range protection");
+    const o = await this._authzIoService.create({ objectType: v.Worksheet });
+    if (this._commandService.syncExecuteCommand(Ue.id, {
+      unitId: n,
+      subUnitId: e,
+      rule: {
+        permissionId: o,
+        unitType: v.Worksheet,
+        unitId: n,
+        subUnitId: e
+      }
+    }))
+      return o;
+  }
+  /**
+   * Delete the entire table protection set for the worksheet and reset the point permissions of the worksheet to true
+   *
+   * @param {string} unitId - The unique identifier of the workbook for which the permission is being set.
+   * @param {string} subUnitId - The unique identifier of the worksheet for which the permission is being set.
+   */
+  removeWorksheetPermission(n, e) {
+    this._commandService.syncExecuteCommand(xe.id, {
+      unitId: n,
+      subUnitId: e
+    }), [...Ee(), ...$()].forEach((t) => {
+      const o = new t(n, e);
+      this._permissionService.updatePermissionPoint(o.id, !0);
+    }), this._worksheetProtectionPointRuleModel.deleteRule(n, e);
+  }
+  /**
+   * Sets the worksheet permission point by updating or adding the permission point for the worksheet.
+   * If the worksheet doesn't have a base permission, it creates one to used render
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet.
+   * @param {WorkSheetPermissionPointConstructor} FPointClass - The constructor for the permission point class.
+   *    See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+   * @param {boolean} value - The new permission value to be set for the worksheet.
+   *
+   * @returns {Promise<string | undefined>} - Returns the `permissionId` if the permission point is successfully set or created. If no permission is set, it resolves to `undefined`.
+   */
+  async setWorksheetPermissionPoint(n, e, t, o) {
+    const s = this._worksheetProtectionRuleModel.getRule(n, e);
+    let r;
+    if (t === De || t === Te)
+      if (s)
+        r = s.permissionId;
+      else {
+        if (this._rangeProtectionRuleModel.getSubunitRuleList(n, e).length > 0)
+          throw new Error("sheet protection cannot intersect with range protection");
+        r = await this.addWorksheetBasePermission(n, e);
+      }
+    else {
+      const c = this._worksheetProtectionPointRuleModel.getRule(n, e);
+      c ? r = c.permissionId : (r = await this._authzIoService.create({ objectType: v.Worksheet }), this._commandService.executeCommand(Me.id, { unitId: n, subUnitId: e, permissionId: r }));
+    }
+    const a = new t(n, e);
+    return this._permissionService.getPermissionPoint(a.id) || this._permissionService.addPermissionPoint(a), this._permissionService.updatePermissionPoint(a.id, o), r;
+  }
+  /**
+   * Adds a range protection to the worksheet.
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet.
+   * @param {IRange[]} ranges - The ranges to be protected.
+   *
+   * @returns {Promise<{ permissionId: string, ruleId: string } | undefined>} - Returns an object containing the `permissionId` and `ruleId` if the range protection is successfully added. If the operation fails or no result is returned, it resolves to `undefined`. permissionId is used to stitch permission point ID，ruleId is used to store permission rules
+   */
+  async addRangeBaseProtection(n, e, t) {
+    const o = await this._authzIoService.create({ objectType: v.SelectRange }), s = `ruleId_${ge(6)}`;
+    if (this._worksheetProtectionRuleModel.getRule(n, e))
+      throw new Error("sheet protection cannot intersect with range protection");
+    if (this._rangeProtectionRuleModel.getSubunitRuleList(n, e).some((c) => c.ranges.some((d) => t.some((x) => j.intersects(x, d)))))
+      throw new Error("range protection cannot intersect");
+    if (this._commandService.syncExecuteCommand(Fe.id, {
+      unitId: n,
+      subUnitId: e,
+      rules: [{
+        permissionId: o,
+        unitType: v.SelectRange,
+        unitId: n,
+        subUnitId: e,
+        ranges: t,
+        id: s
+      }]
+    }))
+      return {
+        permissionId: o,
+        ruleId: s
+      };
+  }
+  /**
+   * Removes the range protection from the worksheet.
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet.
+   * @param {string[]} ruleIds - The rule IDs of the range protection to be removed.
+   */
+  removeRangeProtection(n, e, t) {
+    this._commandService.syncExecuteCommand(We.id, {
+      unitId: n,
+      subUnitId: e,
+      ruleIds: t
+    }) && this._rangeProtectionRuleModel.getSubunitRuleList(n, e).length === 0 && (this._worksheetProtectionPointRuleModel.deleteRule(n, e), [...$()].forEach((r) => {
+      const i = new r(n, e);
+      this._permissionService.updatePermissionPoint(i.id, i.value);
+    }));
+  }
+  /**
+   * Modify the permission points of a custom area
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet within the workbook.
+   * @param {string} permissionId - The unique identifier of the permission that controls access to the range.
+   * @param {RangePermissionPointConstructor} FPointClass - The constructor for the range permission point class.
+   *    See the [permission-point documentation](https://github.com/dream-num/univer/tree/dev/packages/sheets/src/services/permission/permission-point) for more details.
+   * @param {boolean} value - The new permission value to be set for the range (e.g., true for allowing access, false for restricting access).
+   */
+  setRangeProtectionPermissionPoint(n, e, t, o, s) {
+    const r = new o(n, e, t);
+    this._permissionService.getPermissionPoint(r.id) || this._permissionService.addPermissionPoint(r), this._permissionService.updatePermissionPoint(r.id, s);
+  }
+  /**
+   * Sets the ranges for range protection in a worksheet.
+   *
+   * This method finds the rule by unitId, subUnitId, and ruleId, and updates the rule with the provided ranges.
+   * It checks for overlaps with existing ranges in the same subunit and shows an error message if any overlap is detected.
+   * If no overlap is found, it executes the command to update the range protection with the new ranges.
+   *
+   * @param {string} unitId - The unique identifier of the workbook.
+   * @param {string} subUnitId - The unique identifier of the worksheet within the workbook.
+   * @param {string} ruleId - The ruleId of the range protection rule that is being updated.
+   * @param {IRange[]} ranges - The array of new ranges to be set for the range protection rule.
+   */
+  setRangeProtectionRanges(n, e, t, o) {
+    const s = this._rangeProtectionRuleModel.getRule(n, e, t);
+    if (s) {
+      if (this._rangeProtectionRuleModel.getSubunitRuleList(n, e).filter((a) => a.id !== t).some((a) => a.ranges.some((h) => o.some((c) => j.intersects(c, h)))))
+        throw new Error("range protection cannot intersect");
+      this._commandService.syncExecuteCommand(Ae.id, {
+        unitId: n,
+        subUnitId: e,
+        ruleId: t,
+        rule: {
+          ...s,
+          ranges: o
+        }
+      });
+    }
+  }
+};
+V = ot([
+  w(0, u(f)),
+  w(1, R),
+  w(2, ie),
+  w(3, u(pe)),
+  w(4, u(ye)),
+  w(5, u(Pe)),
+  w(6, u(le))
+], V);
+function st(n) {
+  switch (n) {
+    case "left":
+      return C.LEFT;
+    case "center":
+      return C.CENTER;
+    case "normal":
+      return C.RIGHT;
+    default:
+      throw new Error(`Invalid horizontal alignment: ${n}`);
+  }
+}
+function rt(n) {
+  switch (n) {
+    case C.LEFT:
+      return "left";
+    case C.CENTER:
+      return "center";
+    case C.RIGHT:
+      return "normal";
+    default:
+      throw new Error(`Invalid horizontal alignment: ${n}`);
+  }
+}
+function it(n) {
+  switch (n) {
+    case "top":
+      return I.TOP;
+    case "middle":
+      return I.MIDDLE;
+    case "bottom":
+      return I.BOTTOM;
+    default:
+      throw new Error(`Invalid vertical alignment: ${n}`);
+  }
+}
+function at(n) {
+  switch (n) {
+    case I.TOP:
+      return "top";
+    case I.MIDDLE:
+      return "middle";
+    case I.BOTTOM:
+      return "bottom";
+    default:
+      throw new Error(`Invalid vertical alignment: ${n}`);
+  }
+}
+function z(n) {
+  return _e(n) ? {
+    f: n
+  } : we(n) ? {
+    v: n
+  } : (ke(n), n);
+}
+function ht(n, e) {
+  const t = new y(), { startRow: o, startColumn: s, endRow: r, endColumn: i } = e;
+  if (Se.isArray(n))
+    for (let a = 0; a <= r - o; a++)
+      for (let h = 0; h <= i - s; h++)
+        t.setValue(a + o, h + s, z(n[a][h]));
+  else
+    new y(n).forValue((h, c, d) => {
+      t.setValue(h, c, z(d));
+    });
+  return t.getMatrix();
+}
+function W(n, e) {
+  return {
+    startRow: n.startRow,
+    endRow: n.endRow,
+    startColumn: 0,
+    endColumn: e.getColumnCount() - 1,
+    rangeType: l.ROW
+  };
+}
+function A(n, e) {
+  return {
+    startRow: 0,
+    endRow: e.getRowCount() - 1,
+    startColumn: n.startColumn,
+    endColumn: n.endColumn,
+    rangeType: l.COLUMN
+  };
+}
+var ct = Object.defineProperty, dt = Object.getOwnPropertyDescriptor, ut = (n, e, t, o) => {
+  for (var s = o > 1 ? void 0 : o ? dt(e, t) : e, r = n.length - 1, i; r >= 0; r--)
+    (i = n[r]) && (s = (o ? i(e, t, s) : i(s)) || s);
+  return o && s && ct(e, t, s), s;
+}, D = (n, e) => (t, o) => e(t, o, n);
+let S = class extends U {
+  constructor(n, e, t, o, s, r) {
+    super(), this._workbook = n, this._worksheet = e, this._range = t, this._injector = o, this._commandService = s, this._formulaDataModel = r;
+  }
+  /**
+   * Get the unit ID of the current workbook
+   *
+   * @return The unit ID of the workbook
+   */
+  getUnitId() {
+    return this._workbook.getUnitId();
+  }
+  /**
+   * Gets the name of the worksheet
+   *
+   * @return The name of the worksheet
+   */
+  getSheetName() {
+    return this._worksheet.getName();
+  }
+  /**
+   * Gets the area where the statement is applied
+   *
+   * @return The area where the statement is applied
+   */
+  getRange() {
+    return this._range;
+  }
+  /**
+   * Gets the starting row number of the applied area
+   *
+   * @return The starting row number of the area
+   */
+  getRow() {
+    return this._range.startRow;
+  }
+  /**
+   * Gets the starting column number of the applied area
+   *
+   * @return The starting column number of the area
+   */
+  getColumn() {
+    return this._range.startColumn;
+  }
+  /**
+   * Gets the width of the applied area
+   *
+   * @return The width of the area
+   */
+  getWidth() {
+    return this._range.endColumn - this._range.startColumn + 1;
+  }
+  /**
+   * Gets the height of the applied area
+   *
+   * @return The height of the area
+   */
+  getHeight() {
+    return this._range.endRow - this._range.startRow + 1;
+  }
+  /**
+   * Return first cell model data in this range
+   * @returns The cell model data
+   */
+  getCellData() {
+    var n;
+    return (n = this._worksheet.getCell(this._range.startRow, this._range.startColumn)) != null ? n : null;
+  }
+  /**
+   * Return range whether this range is merged
+   * @returns if true is merged
+   */
+  isMerged() {
+    const { startColumn: n, startRow: e, endColumn: t, endRow: o } = this._range;
+    return this._worksheet.getMergedCellRange(e, n, o, t).some((r) => j.equals(r, this._range));
+  }
+  /**
+   * Return first cell style data in this range
+   * @returns The cell style data
+   */
+  getCellStyleData() {
+    var t;
+    const n = this.getCellData(), e = this._workbook.getStyles();
+    return n && e && (t = e.getStyleByCell(n)) != null ? t : null;
+  }
+  /**
+   * Returns the value of the cell at the start of this range.
+   * @returns The value of the cell.
+   */
+  getValue() {
+    var n, e;
+    return (e = (n = this._worksheet.getCell(this._range.startRow, this._range.startColumn)) == null ? void 0 : n.v) != null ? e : null;
+  }
+  /**
+   * Returns the rectangular grid of values for this range.
+   * Returns a two-dimensional array of values, indexed by row, then by column.
+   * @returns A two-dimensional array of values.
+   */
+  getValues() {
+    var r, i;
+    const { startRow: n, endRow: e, startColumn: t, endColumn: o } = this._range, s = [];
+    for (let a = n; a <= e; a++) {
+      const h = [];
+      for (let c = t; c <= o; c++)
+        h.push((i = (r = this._worksheet.getCell(a, c)) == null ? void 0 : r.v) != null ? i : null);
+      s.push(h);
+    }
+    return s;
+  }
+  /**
+   * Returns the cell data for the cells in the range.
+   * @returns A two-dimensional array of cell data.
+   */
+  getCellDataGrid() {
+    const { startRow: n, endRow: e, startColumn: t, endColumn: o } = this._range, s = [];
+    for (let r = n; r <= e; r++) {
+      const i = [];
+      for (let a = t; a <= o; a++)
+        i.push(this._worksheet.getCellRaw(r, a));
+      s.push(i);
+    }
+    return s;
+  }
+  /**
+   * Returns the formulas (A1 notation) for the cells in the range. Entries in the 2D array are empty strings for cells with no formula.
+   * @returns A two-dimensional array of formulas in string format.
+   */
+  getFormulas() {
+    const n = [], { startRow: e, endRow: t, startColumn: o, endColumn: s } = this._range, r = this._worksheet.getSheetId(), i = this._workbook.getUnitId();
+    for (let a = e; a <= t; a++) {
+      const h = [];
+      for (let c = o; c <= s; c++) {
+        const d = this._formulaDataModel.getFormulaStringByCell(a, c, r, i);
+        h.push(d || "");
+      }
+      n.push(h);
+    }
+    return n;
+  }
+  getWrap() {
+    return this._worksheet.getRange(this._range).getWrap() === m.TRUE;
+  }
+  getWrapStrategy() {
+    return this._worksheet.getRange(this._range).getWrapStrategy();
+  }
+  getHorizontalAlignment() {
+    return rt(this._worksheet.getRange(this._range).getHorizontalAlignment());
+  }
+  getVerticalAlignment() {
+    return at(this._worksheet.getRange(this._range).getVerticalAlignment());
+  }
+  // #region editing
+  setBackgroundColor(n) {
+    return this._commandService.executeCommand(_.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: {
+        type: "bg",
+        value: {
+          rgb: n
+        }
+      }
+    });
+  }
+  /**
+   * The value can be a number, string, boolean, or standard cell format. If it begins with `=`, it is interpreted as a formula. The value is tiled to all cells in the range.
+   * @param value
+   */
+  setValue(n) {
+    const e = z(n);
+    if (!e)
+      throw new Error("Invalid value");
+    return this._commandService.executeCommand(G.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: e
+    });
+  }
+  /**
+   * Set the cell wrap of the given range.
+   * Cells with wrap enabled (the default) resize to display their full content. Cells with wrap disabled display as much as possible in the cell without resizing or running to multiple lines.
+   */
+  setWrap(n) {
+    return this._commandService.executeCommand(q.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: n ? H.WRAP : H.UNSPECIFIED
+    });
+  }
+  /**
+   * Sets the text wrapping strategy for the cells in the range.
+   */
+  setWrapStrategy(n) {
+    return this._commandService.executeCommand(q.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: n
+    });
+  }
+  /**
+   * Set the vertical (top to bottom) alignment for the given range (top/middle/bottom).
+   */
+  setVerticalAlignment(n) {
+    return this._commandService.executeCommand(je.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: it(n)
+    });
+  }
+  /**
+   * Set the horizontal (left to right) alignment for the given range (left/center/right).
+   */
+  setHorizontalAlignment(n) {
+    return this._commandService.executeCommand(Oe.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: st(n)
+    });
+  }
+  /**
+   * Sets a different value for each cell in the range. The value can be a two-dimensional array or a standard range matrix (must match the dimensions of this range), consisting of numbers, strings, Boolean values or Composed of standard cell formats. If a value begins with `=`, it is interpreted as a formula.
+   * @param value
+   */
+  setValues(n) {
+    const e = ht(n, this._range);
+    return this._commandService.executeCommand(G.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      value: e
+    });
+  }
+  /**
+   * Sets the font weight for the given range (normal/bold),
+   * @param fontWeight The font weight, either 'normal' or 'bold'; a null value resets the font weight.
+   */
+  setFontWeight(n) {
+    let e;
+    if (n === "bold")
+      e = m.TRUE;
+    else if (n === "normal")
+      e = m.FALSE;
+    else if (n === null)
+      e = null;
+    else
+      throw new Error("Invalid fontWeight");
+    const t = {
+      type: "bl",
+      value: e
+    }, o = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: t
+    };
+    return this._commandService.executeCommand(_.id, o), this;
+  }
+  /**
+   * Sets the font style for the given range ('italic' or 'normal').
+   * @param fontStyle The font style, either 'italic' or 'normal'; a null value resets the font style.
+   */
+  setFontStyle(n) {
+    let e;
+    if (n === "italic")
+      e = m.TRUE;
+    else if (n === "normal")
+      e = m.FALSE;
+    else if (n === null)
+      e = null;
+    else
+      throw new Error("Invalid fontStyle");
+    const t = {
+      type: "it",
+      value: e
+    }, o = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: t
+    };
+    return this._commandService.executeCommand(_.id, o), this;
+  }
+  /**
+   * Sets the font line style of the given range ('underline', 'line-through', or 'none').
+   * @param fontLine The font line style, either 'underline', 'line-through', or 'none'; a null value resets the font line style.
+   */
+  setFontLine(n) {
+    if (n === "underline")
+      this._setFontUnderline({
+        s: m.TRUE
+      });
+    else if (n === "line-through")
+      this._setFontStrikethrough({
+        s: m.TRUE
+      });
+    else if (n === "none")
+      this._setFontUnderline({
+        s: m.FALSE
+      }), this._setFontStrikethrough({
+        s: m.FALSE
+      });
+    else if (n === null)
+      this._setFontUnderline(null), this._setFontStrikethrough(null);
+    else
+      throw new Error("Invalid fontLine");
+    return this;
+  }
+  /**
+   * Sets the font underline style of the given ITextDecoration
+   */
+  _setFontUnderline(n) {
+    const e = {
+      type: "ul",
+      value: n
+    }, t = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: e
+    };
+    this._commandService.executeCommand(_.id, t);
+  }
+  /**
+   * Sets the font strikethrough style of the given ITextDecoration
+   */
+  _setFontStrikethrough(n) {
+    const e = {
+      type: "st",
+      value: n
+    }, t = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: e
+    };
+    this._commandService.executeCommand(_.id, t);
+  }
+  /**
+   * Sets the font family, such as "Arial" or "Helvetica".
+   * @param fontFamily The font family to set; a null value resets the font family.
+   */
+  setFontFamily(n) {
+    const e = {
+      type: "ff",
+      value: n
+    }, t = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: e
+    };
+    return this._commandService.executeCommand(_.id, t), this;
+  }
+  /**
+   * Sets the font size, with the size being the point size to use.
+   * @param size A font size in point size. A null value resets the font size.
+   */
+  setFontSize(n) {
+    const e = {
+      type: "fs",
+      value: n
+    }, t = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: e
+    };
+    return this._commandService.executeCommand(_.id, t), this;
+  }
+  /**
+   * Sets the font color in CSS notation (such as '#ffffff' or 'white').
+   * @param color The font color in CSS notation (such as '#ffffff' or 'white'); a null value resets the color.
+   */
+  setFontColor(n) {
+    const t = {
+      type: "cl",
+      value: n === null ? null : { rgb: n }
+    }, o = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      range: this._range,
+      style: t
+    };
+    return this._commandService.executeCommand(_.id, o), this;
+  }
+  // #endregion editing
+  //#region Merge cell
+  /**
+   * Merge cells in a range into one merged cell
+   * @returns This range, for chaining
+   */
+  async merge() {
+    const n = this._workbook.getUnitId(), e = this._worksheet.getSheetId();
+    return await M(this._injector, n, e, [this._range]), this;
+  }
+  /**
+   * Merges cells in a range horizontally.
+   * @returns This range, for chaining
+   */
+  async mergeAcross() {
+    const n = Y([this._range], N.ROWS), e = this._workbook.getUnitId(), t = this._worksheet.getSheetId();
+    return await M(this._injector, e, t, n), this;
+  }
+  /**
+   * Merges cells in a range vertically.
+   * @returns This range, for chaining
+   */
+  async mergeVertically() {
+    const n = Y([this._range], N.COLUMNS), e = this._workbook.getUnitId(), t = this._worksheet.getSheetId();
+    return await M(this._injector, e, t, n), this;
+  }
+  /**
+   * Returns true if cells in the current range overlap a merged cell.
+   * @returns {boolean} is overlap with a merged cell
+   */
+  isPartOfMerge() {
+    const { startRow: n, startColumn: e, endRow: t, endColumn: o } = this._range;
+    return this._worksheet.getMergedCellRange(n, e, t, o).length > 0;
+  }
+  /**
+   * Unmerge cells in the range
+   * @returns This range, for chaining
+   */
+  breakApart() {
+    return this._commandService.executeCommand(Ve.id, { ranges: [this._range] }), this;
+  }
+  //#endregion
+  /**
+   * Iterate cells in this range. Merged cells will be respected.
+   * @param callback
+   */
+  forEach(n) {
+    const { startColumn: e, startRow: t, endColumn: o, endRow: s } = this._range;
+    this._worksheet.getMatrixWithMergedCells(t, e, s, o).forValue((r, i, a) => {
+      n(r, i, a);
+    });
+  }
+};
+S = ut([
+  D(3, u(f)),
+  D(4, R),
+  D(5, u(Ze))
+], S);
+var mt = Object.defineProperty, lt = Object.getOwnPropertyDescriptor, gt = (n, e, t, o) => {
+  for (var s = o > 1 ? void 0 : o ? lt(e, t) : e, r = n.length - 1, i; r >= 0; r--)
+    (i = n[r]) && (s = (o ? i(e, t, s) : i(s)) || s);
+  return o && s && mt(e, t, s), s;
+}, _t = (n, e) => (t, o) => e(t, o, n);
+let L = class {
+  constructor(n, e, t, o) {
+    this._workbook = n, this._worksheet = e, this._selections = t, this._injector = o;
+  }
+  getActiveRange() {
+    const n = this._selections.find((e) => !!e.primary);
+    return n ? this._injector.createInstance(S, this._workbook, this._worksheet, n.range) : null;
+  }
+};
+L = gt([
+  _t(3, u(f))
+], L);
+var wt = Object.defineProperty, kt = Object.getOwnPropertyDescriptor, St = (n, e, t, o) => {
+  for (var s = o > 1 ? void 0 : o ? kt(e, t) : e, r = n.length - 1, i; r >= 0; r--)
+    (i = n[r]) && (s = (o ? i(e, t, s) : i(s)) || s);
+  return o && s && wt(e, t, s), s;
+}, T = (n, e) => (t, o) => e(t, o, n);
+let g = class extends U {
+  constructor(e, t, o, s, r, i) {
+    super();
+    /**
+     * Sets the active selection region for this sheet.
+     * @param range The range to set as the active selection.
+     */
+    E(this, "setActiveSelection", this.setActiveRange);
+    this._fWorkbook = e, this._workbook = t, this._worksheet = o, this._injector = s, this._selectionManagerService = r, this._commandService = i;
+  }
+  /**
+   * Returns the injector
+   * @returns The injector
+   */
+  getInject() {
+    return this._injector;
+  }
+  /**
+   * Returns the workbook
+   * @returns The workbook
+   */
+  getWorkbook() {
+    return this._workbook;
+  }
+  /**
+   * Returns the worksheet id
+   * @returns The id of the worksheet
+   */
+  getSheetId() {
+    return this._worksheet.getSheetId();
+  }
+  /**
+   * Returns the worksheet name
+   * @returns The name of the worksheet
+   */
+  getSheetName() {
+    return this._worksheet.getName();
+  }
+  getSelection() {
+    const e = this._selectionManagerService.getCurrentSelections();
+    return e ? this._injector.createInstance(L, this._workbook, this._worksheet, e) : null;
+  }
+  // #region rows
+  // #region default style
+  /**
+   * Get the default style of the worksheet
+   * @returns Default style
+   */
+  getDefaultStyle() {
+    return this._worksheet.getDefaultCellStyle();
+  }
+  /**
+   * Get the default style of the worksheet row
+   * @param {number} index The row index
+   * @param {boolean} [keepRaw] If true, return the raw style data maybe the style name or style data, otherwise return the data from row manager
+   * @returns {Nullable<IStyleData> | string} The default style of the worksheet row name or style data
+   */
+  getRowDefaultStyle(e, t = !1) {
+    return this._worksheet.getRowStyle(e, t);
+  }
+  /**
+   * Get the default style of the worksheet column
+   * @param {number} index The column index
+   * @param  {boolean} [keepRaw] If true, return the raw style data maybe the style name or style data, otherwise return the data from col manager
+   * @returns {Nullable<IStyleData> | string} The default style of the worksheet column name or style data
+   */
+  getColumnDefaultStyle(e, t = !1) {
+    return this._worksheet.getColumnStyle(e, t);
+  }
+  /**
+   * Set the default style of the worksheet
+   * @param style default style
+   * @returns this worksheet
+   */
+  async setDefaultStyle(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId();
+    return await this._commandService.executeCommand(ze.id, {
+      unitId: t,
+      subUnitId: o,
+      defaultStyle: e
+    }), this._worksheet.setDefaultCellStyle(e), this;
+  }
+  /**
+   * Set the default style of the worksheet row
+   * @param {number} index The row index
+   * @param {string | Nullable<IStyleData>} style The style name or style data
+   */
+  async setColumnDefaultStyle(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = {
+      unitId: o,
+      subUnitId: s,
+      columnData: {
+        [e]: {
+          s: t
+        }
+      }
+    };
+    return await this._commandService.executeCommand(J.id, r), this;
+  }
+  /**
+   * Set the default style of the worksheet column
+   * @param {number} index The column index
+   * @param {string | Nullable<IStyleData>} style The style name or style data
+   */
+  async setRowDefaultStyle(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = {
+      unitId: o,
+      subUnitId: s,
+      rowData: {
+        [e]: {
+          s: t
+        }
+      }
+    };
+    return await this._commandService.executeCommand(K.id, r), this;
+  }
+  getRange(e, t, o, s) {
+    let r, i;
+    if (typeof e == "string") {
+      const { range: a, sheetName: h } = et(e), c = h ? this._workbook.getSheetBySheetName(h) : this._worksheet;
+      if (!c)
+        throw new Error("Range not found");
+      i = c, r = {
+        ...a,
+        unitId: this._workbook.getUnitId(),
+        sheetId: i.getSheetId(),
+        // Use the current range instead of the future actual range to match Apps Script behavior.
+        // Users can create the latest range in real time when needed.
+        rangeType: l.NORMAL,
+        startRow: a.rangeType === l.COLUMN ? 0 : a.startRow,
+        endRow: a.rangeType === l.COLUMN ? i.getMaxRows() - 1 : a.endRow,
+        startColumn: a.rangeType === l.ROW ? 0 : a.startColumn,
+        endColumn: a.rangeType === l.ROW ? i.getMaxColumns() - 1 : a.endColumn
+      };
+    } else if (typeof e == "number" && t !== void 0)
+      i = this._worksheet, r = {
+        startRow: e,
+        endRow: e + (o != null ? o : 1) - 1,
+        startColumn: t,
+        endColumn: t + (s != null ? s : 1) - 1,
+        unitId: this._workbook.getUnitId(),
+        sheetId: this._worksheet.getSheetId()
+      };
+    else
+      throw new Error("Invalid range specification");
+    return this._injector.createInstance(S, this._workbook, i, r);
+  }
+  /**
+   * Returns the current number of columns in the sheet, regardless of content.
+   * @return The maximum columns count of the sheet
+   */
+  getMaxColumns() {
+    return this._worksheet.getMaxColumns();
+  }
+  /**
+   * Returns the current number of rows in the sheet, regardless of content.
+   * @return The maximum rows count of the sheet
+   */
+  getMaxRows() {
+    return this._worksheet.getMaxRows();
+  }
+  /**
+   * Inserts a row after the given row position.
+   * @param afterPosition The row after which the new row should be added, starting at 0 for the first row.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowAfter(e) {
+    return this.insertRowsAfter(e, 1);
+  }
+  /**
+   * Inserts a row before the given row position.
+   * @param beforePosition The row before which the new row should be added, starting at 0 for the first row.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowBefore(e) {
+    return this.insertRowsBefore(e, 1);
+  }
+  /**
+   * Inserts one or more consecutive blank rows in a sheet starting at the specified location.
+   * @param rowIndex The index indicating where to insert a row, starting at 0 for the first row.
+   * @param numRows The number of rows to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertRows(e, t = 1) {
+    return this.insertRowsBefore(e, t);
+  }
+  /**
+   * Inserts a number of rows after the given row position.
+   * @param afterPosition The row after which the new rows should be added, starting at 0 for the first row.
+   * @param howMany The number of rows to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowsAfter(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = b.DOWN, i = e + 1, a = e + t, h = 0, c = this._worksheet.getColumnCount() - 1, d = p(this._worksheet, i, a, h, c, !0, e);
+    return await this._commandService.executeCommand(Q.id, {
+      unitId: o,
+      subUnitId: s,
+      direction: r,
+      range: {
+        startRow: i,
+        endRow: a,
+        startColumn: h,
+        endColumn: c
+      },
+      cellValue: d
+    }), this;
+  }
+  /**
+   * Inserts a number of rows before the given row position.
+   * @param beforePosition The row before which the new rows should be added, starting at 0 for the first row.
+   * @param howMany The number of rows to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertRowsBefore(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = b.UP, i = e, a = e + t - 1, h = 0, c = this._worksheet.getColumnCount() - 1, d = p(this._worksheet, i, a, h, c, !0, e - 1);
+    return await this._commandService.executeCommand(Q.id, {
+      unitId: o,
+      subUnitId: s,
+      direction: r,
+      range: {
+        startRow: i,
+        endRow: a,
+        startColumn: h,
+        endColumn: c
+      },
+      cellValue: d
+    }), this;
+  }
+  /**
+   * Deletes the row at the given row position.
+   * @param rowPosition The position of the row, starting at 0 for the first row.
+   * @returns This sheet, for chaining.
+   */
+  async deleteRow(e) {
+    return this.deleteRows(e, 1);
+  }
+  /**
+   * Deletes a number of rows starting at the given row position.
+   * @param rowPosition The position of the first row to delete, starting at 0 for the first row.
+   * @param howMany The number of rows to delete.
+   * @returns This sheet, for chaining.
+   */
+  async deleteRows(e, t) {
+    const o = {
+      startRow: e,
+      endRow: e + t - 1,
+      startColumn: 0,
+      endColumn: this._worksheet.getColumnCount() - 1
+    };
+    return await this._commandService.executeCommand(Le.id, {
+      range: o
+    }), this;
+  }
+  /**
+   * Moves the rows selected by the given range to the position indicated by the destinationIndex. The rowSpec itself does not have to exactly represent an entire row or group of rows to move—it selects all rows that the range spans.
+   * @param rowSpec A range spanning the rows that should be moved.
+   * @param destinationIndex The index that the rows should be moved to. Note that this index is based on the coordinates before the rows are moved. Existing data is shifted down to make room for the moved rows while the source rows are removed from the grid. Therefore, the data may end up at a different index than originally specified. Use 0-index for this method.
+   * @returns This sheet, for chaining.
+   */
+  async moveRows(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = W(e.getRange(), this._worksheet), i = r, a = {
+      startRow: t,
+      endRow: t,
+      startColumn: r.startColumn,
+      endColumn: r.endColumn
+    };
+    return await this._commandService.executeCommand(Be.id, {
+      unitId: o,
+      subUnitId: s,
+      range: r,
+      fromRange: i,
+      toRange: a
+    }), this;
+  }
+  /**
+   * Hides the rows in the given range.
+   * @param row The row range to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideRow(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), s = W(e.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(X.id, {
+      unitId: t,
+      subUnitId: o,
+      ranges: [s]
+    }), this;
+  }
+  /**
+   * Hides one or more consecutive rows starting at the given index. Use 0-index for this method.
+   * @param rowIndex The starting index of the rows to hide.
+   * @param numRows The number of rows to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideRows(e, t = 1) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = {
+      startRow: e,
+      endRow: e + t - 1,
+      startColumn: 0,
+      endColumn: this._worksheet.getColumnCount() - 1,
+      rangeType: l.ROW
+    };
+    return await this._commandService.executeCommand(X.id, {
+      unitId: o,
+      subUnitId: s,
+      ranges: [r]
+    }), this;
+  }
+  /**
+   * Unhides the row in the given range.
+   * @param row The range to unhide, if hidden.
+   * @returns This sheet, for chaining.
+   */
+  async unhideRow(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), s = W(e.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(Z.id, {
+      unitId: t,
+      subUnitId: o,
+      ranges: [s]
+    }), this;
+  }
+  /**
+   * Unhides one or more consecutive rows starting at the given index. Use 0-index for this method.
+   * @param rowIndex The starting index of the rows to unhide.
+   * @param numRows The number of rows to unhide.
+   * @returns This sheet, for chaining.
+   */
+  async showRows(e, t = 1) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = {
+      startRow: e,
+      endRow: e + t - 1,
+      startColumn: 0,
+      endColumn: this._worksheet.getColumnCount() - 1,
+      rangeType: l.ROW
+    };
+    return await this._commandService.executeCommand(Z.id, {
+      unitId: o,
+      subUnitId: s,
+      ranges: [r]
+    }), this;
+  }
+  /**
+   * Sets the row height of the given row in pixels. By default, rows grow to fit cell contents. If you want to force rows to a specified height, use setRowHeightsForced(startRow, numRows, height).
+   * @param rowPosition The row position to change.
+   * @param height The height in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setRowHeight(e, t) {
+    return this.setRowHeights(e, 1, t);
+  }
+  /**
+   * Sets the height of the given rows in pixels. By default, rows grow to fit cell contents. If you want to force rows to a specified height, use setRowHeightsForced(startRow, numRows, height).
+   * @param startRow The starting row position to change.
+   * @param numRows The number of rows to change.
+   * @param height The height in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setRowHeights(e, t, o) {
+    var c;
+    const s = this._workbook.getUnitId(), r = this._worksheet.getSheetId(), i = this._worksheet.getRowManager(), a = [], h = [];
+    for (let d = e; d < e + t; d++) {
+      const x = ((c = i.getRow(d)) == null ? void 0 : c.ah) || this._worksheet.getConfig().defaultRowHeight, B = {
+        startRow: d,
+        endRow: d,
+        startColumn: 0,
+        endColumn: this._worksheet.getColumnCount() - 1
+      };
+      o <= x ? a.push(B) : h.push(B);
+    }
+    return h.length > 0 && await this._commandService.executeCommand(ee.id, {
+      unitId: s,
+      subUnitId: r,
+      ranges: h,
+      value: o
+    }), a.length > 0 && await this._commandService.executeCommand(He.id, {
+      unitId: s,
+      subUnitId: r,
+      ranges: a
+    }), this;
+  }
+  /**
+   * Sets the height of the given rows in pixels. By default, rows grow to fit cell contents. When you use setRowHeightsForced, rows are forced to the specified height even if the cell contents are taller than the row height.
+   * @param startRow The starting row position to change.
+   * @param numRows The number of rows to change.
+   * @param height The height in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setRowHeightsForced(e, t, o) {
+    const s = this._workbook.getUnitId(), r = this._worksheet.getSheetId(), i = [
+      {
+        startRow: e,
+        endRow: e + t - 1,
+        startColumn: 0,
+        endColumn: this._worksheet.getColumnCount() - 1
+      }
+    ];
+    return await this._commandService.executeCommand(ee.id, {
+      unitId: s,
+      subUnitId: r,
+      ranges: i,
+      value: o
+    }), this;
+  }
+  // #endregion
+  /**
+   * Set custom properties for given rows.
+   * @param custom The custom properties to set.
+   * @returns This sheet, for chaining.
+   */
+  async setRowCustom(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), s = {};
+    for (const [i, a] of Object.entries(e))
+      s[Number(i)] = {
+        custom: a
+      };
+    const r = {
+      unitId: t,
+      subUnitId: o,
+      rowData: s
+    };
+    return await this._commandService.executeCommand(K.id, r), this;
+  }
+  // #region Column
+  /**
+   * Inserts a column after the given column position.
+   * @param afterPosition The column after which the new column should be added, starting at 0 for the first column.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnAfter(e) {
+    return this.insertColumnsAfter(e, 1);
+  }
+  /**
+   * Inserts a column before the given column position.
+   * @param beforePosition The column before which the new column should be added, starting at 0 for the first column.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnBefore(e) {
+    return this.insertColumnsBefore(e, 1);
+  }
+  /**
+   * Inserts one or more consecutive blank columns in a sheet starting at the specified location.
+   * @param columnIndex The index indicating where to insert a column, starting at 0 for the first column.
+   * @param numColumns The number of columns to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumns(e, t = 1) {
+    return this.insertColumnsBefore(e, t);
+  }
+  /**
+   * Inserts a given number of columns after the given column position.
+   * @param afterPosition The column after which the new column should be added, starting at 0 for the first column.
+   * @param howMany The number of columns to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnsAfter(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = b.RIGHT, i = 0, a = this._worksheet.getRowCount() - 1, h = e + 1, c = e + t, d = p(this._worksheet, i, a, h, c, !1, e);
+    return await this._commandService.executeCommand(te.id, {
+      unitId: o,
+      subUnitId: s,
+      direction: r,
+      range: {
+        startRow: i,
+        endRow: a,
+        startColumn: h,
+        endColumn: c
+      },
+      cellValue: d
+    }), this;
+  }
+  /**
+   * Inserts a number of columns before the given column position.
+   * @param beforePosition The column before which the new column should be added, starting at 0 for the first column.
+   * @param howMany The number of columns to insert.
+   * @returns This sheet, for chaining.
+   */
+  async insertColumnsBefore(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = b.LEFT, i = 0, a = this._worksheet.getRowCount() - 1, h = e, c = e + t - 1, d = p(this._worksheet, i, a, h, c, !1, e - 1);
+    return await this._commandService.executeCommand(te.id, {
+      unitId: o,
+      subUnitId: s,
+      direction: r,
+      range: {
+        startRow: i,
+        endRow: a,
+        startColumn: h,
+        endColumn: c
+      },
+      cellValue: d
+    }), this;
+  }
+  /**
+   * Deletes the column at the given column position.
+   * @param columnPosition The position of the column, starting at 0 for the first column.
+   * @returns This sheet, for chaining.
+   */
+  async deleteColumn(e) {
+    return this.deleteColumns(e, 1);
+  }
+  /**
+   * Deletes a number of columns starting at the given column position.
+   * @param columnPosition The position of the first column to delete, starting at 0 for the first column.
+   * @param howMany The number of columns to delete.
+   * @returns This sheet, for chaining.
+   */
+  async deleteColumns(e, t) {
+    const o = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: e,
+      endColumn: e + t - 1
+    };
+    return await this._commandService.executeCommand(Ne.id, {
+      range: o
+    }), this;
+  }
+  /**
+   * Moves the columns selected by the given range to the position indicated by the destinationIndex. The columnSpec itself does not have to exactly represent an entire column or group of columns to move—it selects all columns that the range spans.
+   * @param columnSpec A range spanning the columns that should be moved.
+   * @param destinationIndex The index that the columns should be moved to. Note that this index is based on the coordinates before the columns are moved. Existing data is shifted right to make room for the moved columns while the source columns are removed from the grid. Therefore, the data may end up at a different index than originally specified. Use 0-index for this method.
+   * @returns This sheet, for chaining.
+   */
+  async moveColumns(e, t) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = A(e.getRange(), this._worksheet), i = r, a = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: t,
+      endColumn: t
+    };
+    return await this._commandService.executeCommand($e.id, {
+      unitId: o,
+      subUnitId: s,
+      range: r,
+      fromRange: i,
+      toRange: a
+    }), this;
+  }
+  /**
+   * Hides the column or columns in the given range.
+   * @param column The column range to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideColumn(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), s = A(e.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(ne.id, {
+      unitId: t,
+      subUnitId: o,
+      ranges: [s]
+    }), this;
+  }
+  /**
+   * Hides one or more consecutive columns starting at the given index. Use 0-index for this method.
+   * @param columnIndex The starting index of the columns to hide.
+   * @param numColumns The number of columns to hide.
+   * @returns This sheet, for chaining.
+   */
+  async hideColumns(e, t = 1) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: e,
+      endColumn: e + t - 1,
+      rangeType: l.COLUMN
+    };
+    return await this._commandService.executeCommand(ne.id, {
+      unitId: o,
+      subUnitId: s,
+      ranges: [r]
+    }), this;
+  }
+  /**
+   * Unhides the column in the given range.
+   * @param column The range to unhide, if hidden.
+   * @returns This sheet, for chaining.
+   */
+  async unhideColumn(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), s = A(e.getRange(), this._worksheet);
+    return await this._commandService.executeCommand(oe.id, {
+      unitId: t,
+      subUnitId: o,
+      ranges: [s]
+    }), this;
+  }
+  /**
+   * Unhides one or more consecutive columns starting at the given index. Use 0-index for this method.
+   * @param columnIndex The starting index of the columns to unhide.
+   * @param numColumns The number of columns to unhide.
+   * @returns This sheet, for chaining.
+   */
+  async showColumns(e, t = 1) {
+    const o = this._workbook.getUnitId(), s = this._worksheet.getSheetId(), r = {
+      startRow: 0,
+      endRow: this._worksheet.getRowCount() - 1,
+      startColumn: e,
+      endColumn: e + t - 1,
+      rangeType: l.COLUMN
+    };
+    return await this._commandService.executeCommand(oe.id, {
+      unitId: o,
+      subUnitId: s,
+      ranges: [r]
+    }), this;
+  }
+  /**
+   * Sets the width of the given column in pixels.
+   * @param columnPosition The position of the given column to set.
+   * @param width The width in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setColumnWidth(e, t) {
+    return this.setColumnWidths(e, 1, t);
+  }
+  /**
+   * Sets the width of the given columns in pixels.
+   * @param startColumn The starting column position to change.
+   * @param numColumns The number of columns to change.
+   * @param width The width in pixels to set it to.
+   * @returns This sheet, for chaining.
+   */
+  async setColumnWidths(e, t, o) {
+    const s = this._workbook.getUnitId(), r = this._worksheet.getSheetId(), i = [
+      {
+        startColumn: e,
+        endColumn: e + t - 1,
+        startRow: 0,
+        endRow: this._worksheet.getRowCount() - 1
+      }
+    ];
+    return await this._commandService.executeCommand(Ge.id, {
+      unitId: s,
+      subUnitId: r,
+      ranges: i,
+      value: o
+    }), this;
+  }
+  // #endregion
+  /**
+   * Set custom properties for given columns.
+   * @param custom The custom properties to set.
+   * @returns This sheet, for chaining.
+   */
+  async setColumnCustom(e) {
+    const t = this._workbook.getUnitId(), o = this._worksheet.getSheetId(), s = {};
+    for (const [i, a] of Object.entries(e))
+      s[Number(i)] = {
+        custom: a
+      };
+    const r = {
+      unitId: t,
+      subUnitId: o,
+      columnData: s
+    };
+    return await this._commandService.executeCommand(J.id, r), this;
+  }
+  // #region merge cells
+  /**
+   * Get all merged cells in the current sheet
+   * @returns all merged cells
+   */
+  getMergedRanges() {
+    return this._worksheet.getSnapshot().mergeData.map((t) => this._injector.createInstance(S, this._workbook, this._worksheet, t));
+  }
+  /**
+   * Get the merged cell data of the specified row and column.
+   * @param {number} row The row index.
+   * @param {number} column The column index.
+   * @returns {FRange|undefined} The merged cell data, or undefined if the cell is not merged.
+   */
+  getCellMergeData(e, t) {
+    const s = this._worksheet.getMergedCell(e, t);
+    if (s)
+      return this._injector.createInstance(S, this._workbook, this._worksheet, s);
+  }
+  // #endregion
+  /**
+   * Returns the selected range in the active sheet, or null if there is no active range.
+   * @returns the active range
+   */
+  getActiveRange() {
+    return this._fWorkbook.getActiveRange();
+  }
+  /**
+   * Sets the active selection region for this sheet.
+   * @param range The range to set as the active selection.
+   */
+  setActiveRange(e) {
+    const { unitId: t, sheetId: o } = e.getRange();
+    if (t !== this._workbook.getUnitId() || o !== this._worksheet.getSheetId())
+      throw new Error("Specified range must be part of the sheet.");
+    this._fWorkbook.setActiveRange(e);
+  }
+  /**
+   * Sets the frozen state of the current sheet.
+   * @param freeze - The freeze object containing the parameters for freezing the sheet.
+   * @returns True if the command was successful, false otherwise.
+   */
+  setFreeze(e) {
+    return this._commandService.syncExecuteCommand(qe.id, {
+      ...e,
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this.getSheetId()
+    });
+  }
+  /**
+   * Cancels the frozen state of the current sheet.
+   * @returns True if the command was successful, false otherwise.
+   */
+  cancelFreeze() {
+    return this._commandService.syncExecuteCommand(Ye.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this.getSheetId()
+    });
+  }
+  /**
+   * Get the freeze state of the current sheet.
+   * @returns The freeze state of the current sheet.
+   */
+  getFreeze() {
+    return this._worksheet.getFreeze();
+  }
+  /**
+   * Set the number of frozen columns.
+   * @param columns The number of columns to freeze.
+   * To unfreeze all columns, set this value to 0.
+   */
+  setFrozenColumns(e) {
+    const t = this.getFreeze();
+    this.setFreeze({
+      ...t,
+      startColumn: e > 0 ? e : -1,
+      xSplit: e
+    });
+  }
+  /**
+   * Set the number of frozen rows.
+   * @param rows The number of rows to freeze.
+   * To unfreeze all rows, set this value to 0.
+   */
+  setFrozenRows(e) {
+    const t = this.getFreeze();
+    this.setFreeze({
+      ...t,
+      startRow: e > 0 ? e : -1,
+      ySplit: e
+    });
+  }
+  /**
+   * Get the number of frozen columns.
+   * @returns The number of frozen columns.
+   * Returns 0 if no columns are frozen.
+   */
+  getFrozenColumns() {
+    const e = this.getFreeze();
+    return e.startColumn === -1 ? 0 : e.startColumn;
+  }
+  /**
+   * Get the number of frozen rows.
+   * @returns The number of frozen rows.
+   * Returns 0 if no rows are frozen.
+   */
+  getFrozenRows() {
+    const e = this.getFreeze();
+    return e.startRow === -1 ? 0 : e.startRow;
+  }
+  /**
+   * Returns true if the sheet's gridlines are hidden; otherwise returns false. Gridlines are visible by default.
+   */
+  hasHiddenGridLines() {
+    return this._worksheet.getConfig().showGridlines === m.FALSE;
+  }
+  /**
+   * Hides or reveals the sheet gridlines.
+   * @param {boolean} hidden If `true`, hide gridlines in this sheet; otherwise show the gridlines.
+   */
+  setHiddenGridlines(e) {
+    return this._commandService.executeCommand(Je.id, {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      showGridlines: e ? m.FALSE : m.TRUE
+    });
+  }
+  /**
+   * Subscribe to the cell data change event.
+   * @param callback - The callback function to be executed when the cell data changes.
+   * @returns - A disposable object to unsubscribe from the event.
+   */
+  onCellDataChange(e) {
+    return this._injector.get(R).onCommandExecuted((o) => {
+      if (o.id === se.id) {
+        const s = o.params;
+        s.unitId === this._workbook.getUnitId() && s.subUnitId === this._worksheet.getSheetId() && s.cellValue && e(new y(s.cellValue));
+      }
+    });
+  }
+  /**
+   * Subscribe to the cell data change event.
+   * @param callback - The callback function to be executed before the cell data changes.
+   * @returns - A disposable object to unsubscribe from the event.
+   */
+  onBeforeCellDataChange(e) {
+    return this._injector.get(R).beforeCommandExecuted((o) => {
+      if (o.id === se.id) {
+        const s = o.params;
+        s.unitId === this._workbook.getUnitId() && s.subUnitId === this._worksheet.getSheetId() && s.cellValue && e(new y(s.cellValue));
+      }
+    });
+  }
+};
+g = St([
+  T(3, u(f)),
+  T(4, u(de)),
+  T(5, R)
+], g);
+var Ct = Object.defineProperty, It = Object.getOwnPropertyDescriptor, Rt = (n, e, t, o) => {
+  for (var s = o > 1 ? void 0 : o ? It(e, t) : e, r = n.length - 1, i; r >= 0; r--)
+    (i = n[r]) && (s = (o ? i(e, t, s) : i(s)) || s);
+  return o && s && Ct(e, t, s), s;
+}, k = (n, e) => (t, o) => e(t, o, n);
+let P = class extends U {
+  constructor(e, t, o, s, r, i, a, h) {
+    super();
+    E(this, "id");
+    this._workbook = e, this._injector = t, this._resourceLoaderService = o, this._selectionManagerService = s, this._univerInstanceService = r, this._commandService = i, this._permissionService = a, this._logService = h, this.id = this._workbook.getUnitId();
+  }
+  getId() {
+    return this.id;
+  }
+  getName() {
+    return this._workbook.getName();
+  }
+  /**
+   * save workbook snapshot data, including conditional formatting, data validation, and other plugin data.
+   */
+  save() {
+    return this._resourceLoaderService.saveUnit(this._workbook.getUnitId());
+  }
+  /**
+   * @deprecated use 'save' instead.
+   * @return {*}  {IWorkbookData}
+   * @memberof FWorkbook
+   */
+  getSnapshot() {
+    return this._logService.warn("use 'save' instead of 'getSnapshot'"), this.save();
+  }
+  /**
+   * Get the active sheet of the workbook.
+   * @returns The active sheet of the workbook
+   */
+  getActiveSheet() {
+    const e = this._workbook.getActiveSheet();
+    return this._injector.createInstance(g, this, this._workbook, e);
+  }
+  /**
+   * Gets all the worksheets in this workbook
+   * @returns An array of all the worksheets in the workbook
+   */
+  getSheets() {
+    return this._workbook.getSheets().map((e) => this._injector.createInstance(g, this, this._workbook, e));
+  }
+  /**
+   * Create a new worksheet and returns a handle to it.
+   * @param name Name of the new sheet
+   * @param rows How may rows would the new sheet have
+   * @param column How many columns would the new sheet have
+   * @returns The new created sheet
+   */
+  create(e, t, o) {
+    const s = Ie({});
+    s.rowCount = t, s.columnCount = o, s.name = e, s.id = e.toLowerCase().replace(/ /g, "-"), this._commandService.syncExecuteCommand(re.id, {
+      unitId: this.id,
+      index: this._workbook.getSheets().length,
+      sheet: s
+    }), this._commandService.syncExecuteCommand(F.id, {
+      unitId: this.id,
+      subUnitId: this._workbook.getSheets()[this._workbook.getSheets().length - 1].getSheetId()
+    });
+    const r = this._workbook.getActiveSheet();
+    if (!r)
+      throw new Error("No active sheet found");
+    return this._injector.createInstance(g, this, this._workbook, r);
+  }
+  /**
+   * Get a worksheet by sheet id.
+   * @param sheetId The id of the sheet to get.
+   * @return The worksheet with given sheet id
+   */
+  getSheetBySheetId(e) {
+    const t = this._workbook.getSheetBySheetId(e);
+    return t ? this._injector.createInstance(g, this, this._workbook, t) : null;
+  }
+  /**
+   * Get a worksheet by sheet name.
+   * @param name The name of the sheet to get.
+   * @returns The worksheet with given sheet name
+   */
+  getSheetByName(e) {
+    const t = this._workbook.getSheetBySheetName(e);
+    return t ? this._injector.createInstance(g, this, this._workbook, t) : null;
+  }
+  /**
+   * Sets the given worksheet to be the active worksheet in the workbook.
+   * @param sheet The worksheet to set as the active worksheet.
+   * @returns The active worksheet
+   */
+  setActiveSheet(e) {
+    return this._commandService.syncExecuteCommand(F.id, {
+      unitId: this.id,
+      subUnitId: e.getSheetId()
+    }), e;
+  }
+  /**
+   * Inserts a new worksheet into the workbook.
+   * Using a default sheet name. The new sheet becomes the active sheet
+   * @returns The new sheet
+   */
+  insertSheet() {
+    this._commandService.syncExecuteCommand(re.id);
+    const e = this.id, t = this._workbook.getSheets()[this._workbook.getSheets().length - 1].getSheetId();
+    this._commandService.syncExecuteCommand(F.id, {
+      unitId: e,
+      subUnitId: t
+    });
+    const o = this._workbook.getActiveSheet();
+    if (!o)
+      throw new Error("No active sheet found");
+    return this._injector.createInstance(g, this, this._workbook, o);
+  }
+  /**
+   * Deletes the specified worksheet.
+   * @param sheet The worksheet to delete.
+   */
+  deleteSheet(e) {
+    const t = this.id, o = e.getSheetId();
+    this._commandService.executeCommand(Ke.id, {
+      unitId: t,
+      subUnitId: o
+    });
+  }
+  // #region editing
+  undo() {
+    return this._univerInstanceService.focusUnit(this.id), this._commandService.executeCommand(Re.id);
+  }
+  redo() {
+    return this._univerInstanceService.focusUnit(this.id), this._commandService.executeCommand(ve.id);
+  }
+  /**
+   * Register a callback that will be triggered before invoking a command targeting the Univer sheet.
+   * @param callback the callback.
+   * @returns A function to dispose the listening.
+   */
+  onBeforeCommandExecute(e) {
+    return this._commandService.beforeCommandExecuted((t) => {
+      var o;
+      ((o = t.params) == null ? void 0 : o.unitId) === this.id && e(t);
+    });
+  }
+  /**
+   * Register a callback that will be triggered when a command is invoked targeting the Univer sheet.
+   * @param callback the callback.
+   * @returns A function to dispose the listening.
+   */
+  onCommandExecuted(e) {
+    return this._commandService.onCommandExecuted((t) => {
+      var o;
+      ((o = t.params) == null ? void 0 : o.unitId) === this.id && e(t);
+    });
+  }
+  onSelectionChange(e) {
+    return fe(
+      this._selectionManagerService.selectionMoveEnd$.subscribe((t) => {
+        this._univerInstanceService.getCurrentUnitForType(O.UNIVER_SHEET).getUnitId() === this.id && (t != null && t.length ? e(t.map((o) => o.range)) : e([]));
+      })
+    );
+  }
+  /**
+   * Used to modify the editing permissions of the workbook. When the value is false, editing is not allowed.
+   * @param {boolean} value  editable value want to set
+   */
+  setEditable(e) {
+    const t = new ce(this._workbook.getUnitId());
+    this._permissionService.getPermissionPoint(t.id) || this._permissionService.addPermissionPoint(t), this._permissionService.updatePermissionPoint(t.id, e);
+  }
+  /**
+   * Sets the active selection region for this sheet.
+   * @param range The range to set as the active selection.
+   */
+  setActiveRange(e) {
+    const t = this.getActiveSheet(), o = e.getRange().sheetId || t.getSheetId(), s = o ? this._workbook.getSheetBySheetId(o) : this._workbook.getActiveSheet(!0);
+    if (!s)
+      throw new Error("No active sheet found");
+    s.getSheetId() !== t.getSheetId() && this.setActiveSheet(this._injector.createInstance(g, this, this._workbook, s));
+    const r = {
+      unitId: this.getId(),
+      subUnitId: o,
+      selections: [e].map((i) => ({ range: i.getRange(), primary: Qe(i.getRange(), s), style: null }))
+    };
+    this._commandService.syncExecuteCommand(Xe.id, r);
+  }
+  /**
+   * Returns the selected range in the active sheet, or null if there is no active range.
+   * @returns the active range
+   */
+  getActiveRange() {
+    const e = this._workbook.getActiveSheet(), o = this._selectionManagerService.getCurrentSelections().find((s) => !!s.primary);
+    return o ? this._injector.createInstance(S, this._workbook, e, o.range) : null;
+  }
+};
+P = Rt([
+  k(1, u(f)),
+  k(2, u(Ce)),
+  k(3, u(de)),
+  k(4, ae),
+  k(5, R),
+  k(6, ie),
+  k(7, be)
+], P);
+class vt extends he {
+  createUniverSheet(e) {
+    const o = this._injector.get(ae).createUnit(O.UNIVER_SHEET, e);
+    return this._injector.createInstance(P, o);
+  }
+  getActiveWorkbook() {
+    const e = this._univerInstanceService.getCurrentUnitForType(O.UNIVER_SHEET);
+    return e ? this._injector.createInstance(P, e) : null;
+  }
+  getPermission() {
+    return this._injector.createInstance(V);
+  }
+}
+he.extend(vt);
+export {
+  V as FPermission,
+  S as FRange,
+  L as FSelection,
+  P as FWorkbook,
+  g as FWorksheet
+};