@ricsam/formula-engine 0.2.8 → 0.2.9

package/dist/cjs/core/commands/content-commands.cjs

@@ -1,857 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// src/core/commands/content-commands.ts
-var exports_content_commands = {};
-__export(exports_content_commands, {
-  SetSheetContentCommand: () => SetSheetContentCommand,
-  SetCellContentCommand: () => SetCellContentCommand,
-  PasteCellsCommand: () => PasteCellsCommand,
-  MoveRangeCommand: () => MoveRangeCommand,
-  MoveCellCommand: () => MoveCellCommand,
-  FillAreasCommand: () => FillAreasCommand,
-  ClearRangeCommand: () => ClearRangeCommand,
-  AutoFillCommand: () => AutoFillCommand
-});
-module.exports = __toCommonJS(exports_content_commands);
-var import_types = require("./types.cjs");
-var import_utils = require("../utils.cjs");
-function buildTouchedCells(cells) {
-  const deduped = new Map;
-  for (const cell of cells) {
-    deduped.set(`${cell.address.workbookName}:${cell.address.sheetName}:${import_utils.getCellReference(cell.address)}`, {
-      address: cell.address,
-      beforeKind: import_types.getSerializedCellValueKind(cell.before),
-      afterKind: import_types.getSerializedCellValueKind(cell.after)
-    });
-  }
-  return Array.from(deduped.values());
-}
-function getAddressKey(address) {
-  return `${address.workbookName}:${address.sheetName}:${import_utils.getCellReference(address)}`;
-}
-function captureCellContents(workbookManager, addresses) {
-  const contents = new Map;
-  for (const address of addresses) {
-    contents.set(getAddressKey(address), workbookManager.getCellContent(address));
-  }
-  return contents;
-}
-
-class SetCellContentCommand {
-  workbookManager;
-  address;
-  newContent;
-  requiresReevaluation = true;
-  previousValue;
-  hadPreviousValue = false;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(workbookManager, address, newContent) {
-    this.workbookManager = workbookManager;
-    this.address = address;
-    this.newContent = newContent;
-  }
-  execute() {
-    const sheet = this.workbookManager.getSheet({
-      workbookName: this.address.workbookName,
-      sheetName: this.address.sheetName
-    });
-    if (sheet) {
-      const key = import_utils.getCellReference(this.address);
-      this.hadPreviousValue = sheet.content.has(key);
-      this.previousValue = sheet.content.get(key);
-    }
-    this.workbookManager.setCellContent(this.address, this.newContent);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells([
-        {
-          address: this.address,
-          before: this.previousValue,
-          after: this.newContent
-        }
-      ]),
-      resourceKeys: []
-    };
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells([
-        {
-          address: this.address,
-          before: this.newContent,
-          after: this.hadPreviousValue ? this.previousValue : undefined
-        }
-      ]),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    if (this.hadPreviousValue) {
-      this.workbookManager.setCellContent(this.address, this.previousValue);
-    } else {
-      this.workbookManager.setCellContent(this.address, undefined);
-    }
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.SET_CELL_CONTENT,
-      payload: {
-        address: this.address,
-        content: this.newContent
-      }
-    };
-  }
-}
-
-class SetSheetContentCommand {
-  workbookManager;
-  opts;
-  newContent;
-  requiresReevaluation = true;
-  previousContent;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(workbookManager, opts, newContent) {
-    this.workbookManager = workbookManager;
-    this.opts = opts;
-    this.newContent = newContent;
-  }
-  execute() {
-    const sheet = this.workbookManager.getSheet(this.opts);
-    if (sheet) {
-      this.previousContent = new Map(sheet.content);
-    }
-    this.workbookManager.setSheetContent(this.opts, this.newContent);
-    const touchedKeys = new Set([
-      ...Array.from(this.previousContent?.keys() ?? []),
-      ...Array.from(this.newContent.keys())
-    ]);
-    const touchedCells = buildTouchedCells(Array.from(touchedKeys, (key) => ({
-      address: {
-        workbookName: this.opts.workbookName,
-        sheetName: this.opts.sheetName,
-        ...import_utils.parseCellReference(key)
-      },
-      before: this.previousContent?.get(key),
-      after: this.newContent.get(key)
-    })));
-    this.executeFootprint = {
-      touchedCells,
-      resourceKeys: []
-    };
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(Array.from(touchedKeys, (key) => ({
-        address: {
-          workbookName: this.opts.workbookName,
-          sheetName: this.opts.sheetName,
-          ...import_utils.parseCellReference(key)
-        },
-        before: this.newContent.get(key),
-        after: this.previousContent?.get(key)
-      }))),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    if (this.previousContent) {
-      this.workbookManager.setSheetContent(this.opts, this.previousContent);
-    }
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.SET_SHEET_CONTENT,
-      payload: {
-        opts: this.opts,
-        content: Array.from(this.newContent.entries())
-      }
-    };
-  }
-}
-
-class ClearRangeCommand {
-  workbookManager;
-  address;
-  requiresReevaluation = true;
-  clearedCells = new Map;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  constructor(workbookManager, address) {
-    this.workbookManager = workbookManager;
-    this.address = address;
-  }
-  execute() {
-    this.clearedCells.clear();
-    try {
-      for (const cellAddress of this.workbookManager.iterateCellsInRange(this.address)) {
-        const key = import_utils.getCellReference(cellAddress);
-        const value = this.workbookManager.getCellContent(cellAddress);
-        if (value !== undefined) {
-          this.clearedCells.set(key, value);
-        }
-      }
-    } catch {}
-    this.workbookManager.clearSpreadsheetRange(this.address);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells(Array.from(this.clearedCells.entries(), ([key, before]) => ({
-        address: {
-          workbookName: this.address.workbookName,
-          sheetName: this.address.sheetName,
-          ...import_utils.parseCellReference(key)
-        },
-        before,
-        after: undefined
-      }))),
-      resourceKeys: []
-    };
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(Array.from(this.clearedCells.entries(), ([key, after]) => ({
-        address: {
-          workbookName: this.address.workbookName,
-          sheetName: this.address.sheetName,
-          ...import_utils.parseCellReference(key)
-        },
-        before: undefined,
-        after
-      }))),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    for (const [key, value] of this.clearedCells) {
-      const { colIndex, rowIndex } = import_utils.parseCellReference(key);
-      this.workbookManager.setCellContent({
-        workbookName: this.address.workbookName,
-        sheetName: this.address.sheetName,
-        colIndex,
-        rowIndex
-      }, value);
-    }
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.CLEAR_RANGE,
-      payload: {
-        address: this.address
-      }
-    };
-  }
-}
-
-class PasteCellsCommand {
-  workbookManager;
-  copyManager;
-  source;
-  target;
-  options;
-  requiresReevaluation = true;
-  targetSnapshots = [];
-  sourceSnapshots = [];
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  executedContents = new Map;
-  constructor(workbookManager, copyManager, source, target, options) {
-    this.workbookManager = workbookManager;
-    this.copyManager = copyManager;
-    this.source = source;
-    this.target = target;
-    this.options = options;
-  }
-  execute() {
-    this.targetSnapshots = [];
-    this.sourceSnapshots = [];
-    this.executedContents.clear();
-    if (this.source.length > 0) {
-      const firstSource = this.source[0];
-      const colOffset = this.target.colIndex - firstSource.colIndex;
-      const rowOffset = this.target.rowIndex - firstSource.rowIndex;
-      for (const sourceCell of this.source) {
-        const targetCell = {
-          workbookName: this.target.workbookName,
-          sheetName: this.target.sheetName,
-          colIndex: sourceCell.colIndex + colOffset,
-          rowIndex: sourceCell.rowIndex + rowOffset
-        };
-        const sheet = this.workbookManager.getSheet({
-          workbookName: targetCell.workbookName,
-          sheetName: targetCell.sheetName
-        });
-        if (sheet) {
-          const key = import_utils.getCellReference(targetCell);
-          this.targetSnapshots.push({
-            address: targetCell,
-            content: sheet.content.get(key),
-            metadata: sheet.metadata.get(key)
-          });
-        }
-      }
-      if (this.options.cut) {
-        for (const sourceCell of this.source) {
-          const sheet = this.workbookManager.getSheet({
-            workbookName: sourceCell.workbookName,
-            sheetName: sourceCell.sheetName
-          });
-          if (sheet) {
-            const key = import_utils.getCellReference(sourceCell);
-            this.sourceSnapshots.push({
-              address: sourceCell,
-              content: sheet.content.get(key),
-              metadata: sheet.metadata.get(key)
-            });
-          }
-        }
-      }
-    }
-    this.copyManager.pasteCells(this.source, this.target, this.options);
-    const touchedAddresses = [
-      ...this.targetSnapshots.map((snapshot) => snapshot.address),
-      ...this.sourceSnapshots.map((snapshot) => snapshot.address)
-    ];
-    this.executedContents = captureCellContents(this.workbookManager, touchedAddresses);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => {
-        const beforeSnapshot = this.targetSnapshots.find((snapshot) => snapshot.address.workbookName === address.workbookName && snapshot.address.sheetName === address.sheetName && snapshot.address.colIndex === address.colIndex && snapshot.address.rowIndex === address.rowIndex) ?? this.sourceSnapshots.find((snapshot) => snapshot.address.workbookName === address.workbookName && snapshot.address.sheetName === address.sheetName && snapshot.address.colIndex === address.colIndex && snapshot.address.rowIndex === address.rowIndex);
-        return {
-          address,
-          before: beforeSnapshot?.content,
-          after: this.executedContents.get(getAddressKey(address))
-        };
-      })),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    for (const snapshot of this.targetSnapshots) {
-      this.workbookManager.setCellContent(snapshot.address, snapshot.content);
-      if (snapshot.metadata !== undefined) {
-        this.workbookManager.setCellMetadata(snapshot.address, snapshot.metadata);
-      }
-    }
-    if (this.options.cut) {
-      for (const snapshot of this.sourceSnapshots) {
-        this.workbookManager.setCellContent(snapshot.address, snapshot.content);
-        if (snapshot.metadata !== undefined) {
-          this.workbookManager.setCellMetadata(snapshot.address, snapshot.metadata);
-        }
-      }
-    }
-    const touchedAddresses = [
-      ...this.targetSnapshots.map((snapshot) => snapshot.address),
-      ...this.sourceSnapshots.map((snapshot) => snapshot.address)
-    ];
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => {
-        return {
-          address,
-          before: this.executedContents.get(getAddressKey(address)),
-          after: this.workbookManager.getCellContent(address)
-        };
-      })),
-      resourceKeys: []
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.PASTE_CELLS,
-      payload: {
-        source: this.source,
-        target: this.target,
-        options: this.options
-      }
-    };
-  }
-}
-
-class FillAreasCommand {
-  workbookManager;
-  copyManager;
-  seedRange;
-  targetRanges;
-  options;
-  requiresReevaluation = true;
-  targetSnapshots = new Map;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  executedContents = new Map;
-  constructor(workbookManager, copyManager, seedRange, targetRanges, options) {
-    this.workbookManager = workbookManager;
-    this.copyManager = copyManager;
-    this.seedRange = seedRange;
-    this.targetRanges = targetRanges;
-    this.options = options;
-  }
-  execute() {
-    this.targetSnapshots.clear();
-    this.executedContents.clear();
-    for (const targetRange of this.targetRanges) {
-      const sheet = this.workbookManager.getSheet({
-        workbookName: targetRange.workbookName,
-        sheetName: targetRange.sheetName
-      });
-      if (sheet) {
-        const { start, end } = targetRange.range;
-        const endCol = end.col.type === "number" ? end.col.value : start.col + 100;
-        const endRow = end.row.type === "number" ? end.row.value : start.row + 100;
-        for (let col = start.col;col <= endCol; col++) {
-          for (let row = start.row;row <= endRow; row++) {
-            const address = {
-              workbookName: targetRange.workbookName,
-              sheetName: targetRange.sheetName,
-              colIndex: col,
-              rowIndex: row
-            };
-            const key = import_utils.getCellReference(address);
-            const fullKey = `${targetRange.workbookName}:${targetRange.sheetName}:${key}`;
-            if (!this.targetSnapshots.has(fullKey)) {
-              this.targetSnapshots.set(fullKey, {
-                address,
-                content: sheet.content.get(key),
-                metadata: sheet.metadata.get(key)
-              });
-            }
-          }
-        }
-      }
-    }
-    this.copyManager.fillAreas(this.seedRange, this.targetRanges, this.options);
-    const touchedAddresses = Array.from(this.targetSnapshots.values()).map((snapshot) => snapshot.address);
-    this.executedContents = captureCellContents(this.workbookManager, touchedAddresses);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: this.targetSnapshots.get(getAddressKey(address))?.content,
-        after: this.executedContents.get(getAddressKey(address))
-      }))),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    for (const snapshot of this.targetSnapshots.values()) {
-      this.workbookManager.setCellContent(snapshot.address, snapshot.content);
-      if (snapshot.metadata !== undefined) {
-        this.workbookManager.setCellMetadata(snapshot.address, snapshot.metadata);
-      }
-    }
-    const touchedAddresses = Array.from(this.targetSnapshots.values()).map((snapshot) => snapshot.address);
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: this.executedContents.get(getAddressKey(address)),
-        after: this.workbookManager.getCellContent(address)
-      }))),
-      resourceKeys: []
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.FILL_AREAS,
-      payload: {
-        seedRange: this.seedRange,
-        targetRanges: this.targetRanges,
-        options: this.options
-      }
-    };
-  }
-}
-
-class MoveCellCommand {
-  workbookManager;
-  copyManager;
-  source;
-  target;
-  requiresReevaluation = true;
-  sourceSnapshot;
-  targetSnapshot;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  executedContents = new Map;
-  constructor(workbookManager, copyManager, source, target) {
-    this.workbookManager = workbookManager;
-    this.copyManager = copyManager;
-    this.source = source;
-    this.target = target;
-  }
-  execute() {
-    this.sourceSnapshot = undefined;
-    this.targetSnapshot = undefined;
-    this.executedContents.clear();
-    const sourceSheet = this.workbookManager.getSheet({
-      workbookName: this.source.workbookName,
-      sheetName: this.source.sheetName
-    });
-    if (sourceSheet) {
-      const key = import_utils.getCellReference(this.source);
-      this.sourceSnapshot = {
-        address: this.source,
-        content: sourceSheet.content.get(key),
-        metadata: sourceSheet.metadata.get(key)
-      };
-    }
-    const targetSheet = this.workbookManager.getSheet({
-      workbookName: this.target.workbookName,
-      sheetName: this.target.sheetName
-    });
-    if (targetSheet) {
-      const key = import_utils.getCellReference(this.target);
-      this.targetSnapshot = {
-        address: this.target,
-        content: targetSheet.content.get(key),
-        metadata: targetSheet.metadata.get(key)
-      };
-    }
-    this.copyManager.pasteCells([this.source], this.target, {
-      cut: true,
-      type: "formula",
-      include: "all"
-    });
-    const touchedAddresses = [this.source, this.target];
-    this.executedContents = captureCellContents(this.workbookManager, touchedAddresses);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: this.sourceSnapshot?.address === address ? this.sourceSnapshot.content : this.targetSnapshot?.content,
-        after: this.executedContents.get(getAddressKey(address))
-      }))),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    if (this.sourceSnapshot) {
-      this.workbookManager.setCellContent(this.sourceSnapshot.address, this.sourceSnapshot.content);
-      if (this.sourceSnapshot.metadata !== undefined) {
-        this.workbookManager.setCellMetadata(this.sourceSnapshot.address, this.sourceSnapshot.metadata);
-      }
-    }
-    if (this.targetSnapshot) {
-      this.workbookManager.setCellContent(this.targetSnapshot.address, this.targetSnapshot.content);
-      if (this.targetSnapshot.metadata !== undefined) {
-        this.workbookManager.setCellMetadata(this.targetSnapshot.address, this.targetSnapshot.metadata);
-      }
-    }
-    const touchedAddresses = [this.source, this.target];
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: this.executedContents.get(getAddressKey(address)),
-        after: this.workbookManager.getCellContent(address)
-      }))),
-      resourceKeys: []
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.MOVE_CELL,
-      payload: {
-        source: this.source,
-        target: this.target
-      }
-    };
-  }
-}
-
-class MoveRangeCommand {
-  workbookManager;
-  copyManager;
-  sourceRange;
-  target;
-  requiresReevaluation = true;
-  sourceSnapshots = [];
-  targetSnapshots = [];
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  executedContents = new Map;
-  constructor(workbookManager, copyManager, sourceRange, target) {
-    this.workbookManager = workbookManager;
-    this.copyManager = copyManager;
-    this.sourceRange = sourceRange;
-    this.target = target;
-  }
-  execute() {
-    this.sourceSnapshots = [];
-    this.targetSnapshots = [];
-    this.executedContents.clear();
-    const sourceCells = this.copyManager.expandRangeToCells(this.sourceRange);
-    for (const cell of sourceCells) {
-      const sheet = this.workbookManager.getSheet({
-        workbookName: cell.workbookName,
-        sheetName: cell.sheetName
-      });
-      if (sheet) {
-        const key = import_utils.getCellReference(cell);
-        this.sourceSnapshots.push({
-          address: cell,
-          content: sheet.content.get(key),
-          metadata: sheet.metadata.get(key)
-        });
-      }
-    }
-    if (sourceCells.length > 0) {
-      const firstSource = sourceCells[0];
-      const colOffset = this.target.colIndex - firstSource.colIndex;
-      const rowOffset = this.target.rowIndex - firstSource.rowIndex;
-      for (const sourceCell of sourceCells) {
-        const targetCell = {
-          workbookName: this.target.workbookName,
-          sheetName: this.target.sheetName,
-          colIndex: sourceCell.colIndex + colOffset,
-          rowIndex: sourceCell.rowIndex + rowOffset
-        };
-        const sheet = this.workbookManager.getSheet({
-          workbookName: targetCell.workbookName,
-          sheetName: targetCell.sheetName
-        });
-        if (sheet) {
-          const key = import_utils.getCellReference(targetCell);
-          this.targetSnapshots.push({
-            address: targetCell,
-            content: sheet.content.get(key),
-            metadata: sheet.metadata.get(key)
-          });
-        }
-      }
-    }
-    this.copyManager.pasteCells(sourceCells, this.target, {
-      cut: true,
-      type: "formula",
-      include: "all"
-    });
-    const touchedAddresses = [
-      ...this.sourceSnapshots.map((snapshot) => snapshot.address),
-      ...this.targetSnapshots.map((snapshot) => snapshot.address)
-    ];
-    this.executedContents = captureCellContents(this.workbookManager, touchedAddresses);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => {
-        const snapshot = this.sourceSnapshots.find((candidate) => getAddressKey(candidate.address) === getAddressKey(address)) ?? this.targetSnapshots.find((candidate) => getAddressKey(candidate.address) === getAddressKey(address));
-        return {
-          address,
-          before: snapshot?.content,
-          after: this.executedContents.get(getAddressKey(address))
-        };
-      })),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    for (const snapshot of this.sourceSnapshots) {
-      this.workbookManager.setCellContent(snapshot.address, snapshot.content);
-      if (snapshot.metadata !== undefined) {
-        this.workbookManager.setCellMetadata(snapshot.address, snapshot.metadata);
-      }
-    }
-    for (const snapshot of this.targetSnapshots) {
-      this.workbookManager.setCellContent(snapshot.address, snapshot.content);
-      if (snapshot.metadata !== undefined) {
-        this.workbookManager.setCellMetadata(snapshot.address, snapshot.metadata);
-      }
-    }
-    const touchedAddresses = [
-      ...this.sourceSnapshots.map((snapshot) => snapshot.address),
-      ...this.targetSnapshots.map((snapshot) => snapshot.address)
-    ];
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(touchedAddresses.map((address) => ({
-        address,
-        before: this.executedContents.get(getAddressKey(address)),
-        after: this.workbookManager.getCellContent(address)
-      }))),
-      resourceKeys: []
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.MOVE_RANGE,
-      payload: {
-        sourceRange: this.sourceRange,
-        target: this.target
-      }
-    };
-  }
-}
-
-class AutoFillCommand {
-  workbookManager;
-  styleManager;
-  autoFillManager;
-  opts;
-  seedRange;
-  fillRanges;
-  direction;
-  requiresReevaluation = true;
-  previousContent = new Map;
-  previousMetadata = new Map;
-  executeFootprint = import_types.emptyMutationInvalidation();
-  undoFootprint = import_types.emptyMutationInvalidation();
-  touchedAddresses = [];
-  executedContents = new Map;
-  constructor(workbookManager, styleManager, autoFillManager, opts, seedRange, fillRanges, direction) {
-    this.workbookManager = workbookManager;
-    this.styleManager = styleManager;
-    this.autoFillManager = autoFillManager;
-    this.opts = opts;
-    this.seedRange = seedRange;
-    this.fillRanges = fillRanges;
-    this.direction = direction;
-  }
-  execute() {
-    this.previousContent.clear();
-    this.previousMetadata.clear();
-    this.touchedAddresses = [];
-    this.executedContents.clear();
-    for (const fillRange of this.fillRanges) {
-      if (fillRange.end.col.type === "infinity" || fillRange.end.row.type === "infinity") {
-        continue;
-      }
-      const startCol = fillRange.start.col;
-      const startRow = fillRange.start.row;
-      const endCol = fillRange.end.col.value;
-      const endRow = fillRange.end.row.value;
-      for (let row = startRow;row <= endRow; row++) {
-        for (let col = startCol;col <= endCol; col++) {
-          const key = import_utils.getCellReference({ colIndex: col, rowIndex: row });
-          const address = {
-            workbookName: this.opts.workbookName,
-            sheetName: this.opts.sheetName,
-            colIndex: col,
-            rowIndex: row
-          };
-          this.touchedAddresses.push(address);
-          const content = this.workbookManager.getCellContent(address);
-          if (content !== undefined) {
-            this.previousContent.set(key, content);
-          }
-          const metadata = this.workbookManager.getCellMetadata(address);
-          if (metadata !== undefined) {
-            this.previousMetadata.set(key, metadata);
-          }
-        }
-      }
-    }
-    this.autoFillManager.fill(this.opts, this.seedRange, this.fillRanges, this.direction);
-    this.executedContents = captureCellContents(this.workbookManager, this.touchedAddresses);
-    this.executeFootprint = {
-      touchedCells: buildTouchedCells(this.touchedAddresses.map((address) => {
-        const key = import_utils.getCellReference(address);
-        return {
-          address,
-          before: this.previousContent.get(key),
-          after: this.executedContents.get(getAddressKey(address))
-        };
-      })),
-      resourceKeys: []
-    };
-  }
-  undo() {
-    const currentContent = this.workbookManager.getSheetSerialized(this.opts);
-    const newContent = new Map(currentContent);
-    for (const fillRange of this.fillRanges) {
-      if (fillRange.end.col.type === "infinity" || fillRange.end.row.type === "infinity") {
-        continue;
-      }
-      const startCol = fillRange.start.col;
-      const startRow = fillRange.start.row;
-      const endCol = fillRange.end.col.value;
-      const endRow = fillRange.end.row.value;
-      for (let row = startRow;row <= endRow; row++) {
-        for (let col = startCol;col <= endCol; col++) {
-          const key = import_utils.getCellReference({ colIndex: col, rowIndex: row });
-          const address = {
-            workbookName: this.opts.workbookName,
-            sheetName: this.opts.sheetName,
-            colIndex: col,
-            rowIndex: row
-          };
-          if (this.previousContent.has(key)) {
-            newContent.set(key, this.previousContent.get(key));
-          } else {
-            newContent.delete(key);
-          }
-          if (this.previousMetadata.has(key)) {
-            this.workbookManager.setCellMetadata(address, this.previousMetadata.get(key));
-          } else {
-            this.workbookManager.setCellMetadata(address, undefined);
-          }
-        }
-      }
-    }
-    this.workbookManager.setSheetContent(this.opts, newContent);
-    this.undoFootprint = {
-      touchedCells: buildTouchedCells(this.touchedAddresses.map((address) => ({
-        address,
-        before: this.executedContents.get(getAddressKey(address)),
-        after: this.workbookManager.getCellContent(address)
-      }))),
-      resourceKeys: []
-    };
-  }
-  getInvalidationFootprint(phase) {
-    return phase === "execute" ? this.executeFootprint : this.undoFootprint;
-  }
-  toAction() {
-    return {
-      type: import_types.ActionTypes.AUTO_FILL,
-      payload: {
-        opts: this.opts,
-        seedRange: this.seedRange,
-        fillRanges: this.fillRanges,
-        direction: this.direction
-      }
-    };
-  }
-}
-
-//# debugId=7AAB2F977AF7BA6364756E2164756E21