@sheetxl/sdk 0.7.28-beta.2 → 0.7.28-beta.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/sdk",
   "description": "SDK - A high-performance, embeddable spreadsheet engine.",
-  "version": "0.7.28-beta.2",
+  "version": "0.7.28-beta.3",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {
@@ -43,11 +43,11 @@
     "automation"
   ],
   "dependencies": {
-    "@sheetxl/formulas": "^0.7.28-beta.2",
-    "@sheetxl/formulas-extended": "^0.7.28-beta.2",
-    "@sheetxl/primitives": "^0.7.28-beta.2",
-    "@sheetxl/scripting": "^0.7.28-beta.2",
-    "@sheetxl/utils": "^0.7.28-beta.2",
+    "@sheetxl/formulas": "^0.7.28-beta.3",
+    "@sheetxl/formulas-extended": "^0.7.28-beta.3",
+    "@sheetxl/primitives": "^0.7.28-beta.3",
+    "@sheetxl/scripting": "^0.7.28-beta.3",
+    "@sheetxl/utils": "^0.7.28-beta.3",
     "bahttext": "^2.4.0",
     "bessel": "^1.0.2",
     "chalk": "^6.0.0",

package/resources/locales/de/model.msg.json

@@ -95,6 +95,17 @@
   "error.address.textToColumnsOverwrite": "Der Zielbereich enthält Daten.",
   "error.anchor.protected": "{description} nicht möglich. Das Element ist geschützt.",
   "error.hyperlink.invalidHyperlink": "Ungültiger Link.",
+  "error.io.encryptionUnavailable": "Kennwortschutz ist nicht verfügbar, daher kann diese Arbeitsmappe nicht mit einem Kennwort gespeichert werden.",
+  "error.io.passwordIncorrect": "Das Kennwort ist falsch.",
+  "error.io.passwordRequired": "''{name}'' ist kennwortgeschützt. Zum Öffnen ist ein Kennwort erforderlich.",
+  "error.io.passwordRequiredSave": "''{name}'' ist kennwortgeschützt. Geben Sie das Kennwort an, um die Datei zu speichern, oder speichern Sie sie ohne Schutz.",
+  "error.io.passwordRequiredSaveUnnamed": "Diese Datei ist kennwortgeschützt. Geben Sie das Kennwort an, um die Datei zu speichern, oder speichern Sie sie ohne Schutz.",
+  "error.io.passwordRequiredUnnamed": "Diese Datei ist kennwortgeschützt. Zum Öffnen ist ein Kennwort erforderlich.",
+  "error.io.readFailed": "{format} kann nicht gelesen werden — {reason}",
+  "error.io.readFormatUnavailable": "''{format}'' kann nicht geöffnet werden — dieser Dateityp wird nicht unterstützt.",
+  "error.io.writeFailed": "Die Arbeitsmappe kann nicht gespeichert werden — {reason}",
+  "error.io.writeFormatUnavailable": "Speichern als ''{format}'' ist nicht möglich — dieser Dateityp wird nicht unterstützt.",
+  "error.io.writeFormatUnresolved": "Der Dateityp zum Speichern konnte nicht ermittelt werden. Wählen Sie einen Dateityp oder verwenden Sie einen Dateinamen mit bekannter Erweiterung.",
   "error.model.modelClosed": "Das Modell wurde geschlossen. Weitere Vorgänge sind nicht zulässig.",
   "error.model.nameRequired": "Name ist erforderlich",
   "error.named.containsSpaces": "Der Name darf keine Leerzeichen enthalten.",
@@ -506,5 +517,6 @@
   "table.defaultName": "Tabelle{n}",
   "table.emptyColumnName": "Spalte",
   "table.totalsRowLabel": "Ergebnis",
+  "workbook.defaultName": "Arbeitsmappe",
   "workbook.defaultSheetName": "Tabelle{n}"
 }

package/resources/locales/en/model.msg.json

@@ -96,6 +96,17 @@
   "error.anchor.protected": "Unable to {description}. The item is protected.",
   "error.function.builtInName": "''{name}'' is a built-in function. Choose a different name.",
   "error.hyperlink.invalidHyperlink": "Invalid hyperlink",
+  "error.io.encryptionUnavailable": "Password protection is not available, so this workbook cannot be saved with a password.",
+  "error.io.passwordIncorrect": "The password is incorrect.",
+  "error.io.passwordRequired": "''{name}'' is password protected. A password is required to open it.",
+  "error.io.passwordRequiredSave": "''{name}'' is password protected. Supply the password to save it, or save it without protection.",
+  "error.io.passwordRequiredSaveUnnamed": "This file is password protected. Supply the password to save it, or save it without protection.",
+  "error.io.passwordRequiredUnnamed": "This file is password protected. A password is required to open it.",
+  "error.io.readFailed": "Unable to read {format} — {reason}",
+  "error.io.readFormatUnavailable": "Unable to open ''{format}'' — that file type is not supported.",
+  "error.io.writeFailed": "Unable to save the workbook — {reason}",
+  "error.io.writeFormatUnavailable": "Unable to save as ''{format}'' — that file type is not supported.",
+  "error.io.writeFormatUnresolved": "Unable to determine the file type to save as. Choose a file type, or use a file name with a known extension.",
   "error.model.modelClosed": "Model has been closed. No further operations are allowed.",
   "error.model.nameRequired": "Name is required",
   "error.named.containsSpaces": "Name must not contain any spaces.",
@@ -521,5 +532,6 @@
   "table.defaultName": "Table{n}",
   "table.emptyColumnName": "Column",
   "table.totalsRowLabel": "Total",
+  "workbook.defaultName": "Workbook",
   "workbook.defaultSheetName": "Sheet{n}"
 }

package/types/scripting.d.ts

@@ -2688,6 +2688,11 @@ declare global {
              * two diverge exactly where normalization is lossy — a number (`3.0` → `3`, `1**2` → `100`) or a
              * cell (raw `b2` vs the resolved coords). `undefined` only for a token with no captured source
              * image (e.g. a reference the engine rewrote programmatically rather than one the user typed).
+             *
+             * A reference literal is ONE span: a typed sheet qualifier and a trailing spill anchor ride inside
+             * the `cell`/`named` token's `text` (`Sheet2!A1#`), so the caret rules an editor applies per token
+             * treat the whole reference as one. The anchor keeps its own `postfix` token (carrying the same
+             * {@link referenceIndex}) imaging the empty string, so the concatenation above still holds.
              */
             text?: string;
             /**
@@ -4689,11 +4694,24 @@ declare global {
          * Returns a range that includes the current range up to a content edge boundary.
          *
          * @param direction The direction.
-         * @param cell The cell to use as a starting point.
-         *               If not provide the cell closest to the edge will be used.
+         * @param cell Either the cell to walk from — as {@link ICellRange.GetExtendedOptions.cell}, and
+         *               the positional form Office Scripts' `getExtendedRange` takes — or the full
+         *               {@link ICellRange.GetExtendedOptions}. If neither is given the cell closest to
+         *               the edge is used.
          * @returns `ICellRange` extended in the given direction.
+         *
+         * @remarks
+         * The result **includes** the current range, and a boundary with nowhere to go returns the range
+         * unchanged — so comparing the two is how you tell there was nothing to extend onto.
+         *
+         * {@link ICellRange.GetExtendedOptions.basis} picks what the boundary is read from: the range's
+         * own content (Ctrl+Arrow, the default) or the lines flanking it (a double-clicked fill handle).
+         *
+         * Both bases read the content, merge and table indexes rather than walking cells, so the cost is
+         * the blocks involved and not the distance traveled — extending across a million rows costs what
+         * extending across ten does.
          */
-        getExtended(direction: IRange.Direction, cell?: ICell.Address): this;
+        getExtended(direction: IRange.Direction, cell?: ICell.Address | ICellRange.GetExtendedOptions): this;
         /**
          * Returns a range with coordinates adjusted to be fixed (absolute) or flexible (relative).
          *
@@ -5809,6 +5827,50 @@ declare global {
              */
             colEnd?: boolean;
         }
+        /**
+         * Options for {@link ICellRange.getExtended}.
+         */
+        interface GetExtendedOptions {
+            /**
+             * The cell to walk from. Only `'content'` extends from a cell — the flanking lines a
+             * `'adjacent'` extension reads are fixed by the range's own edges — so this is ignored there.
+             *
+             * @defaultValue the cell of the range closest to the edge being extended toward.
+             */
+            cell?: ICell.Address;
+            /**
+             * What the content edge is read from.
+             *
+             * - `'content'` — the range's own content, walked from {@link cell}. This is Ctrl+Arrow: it
+             *   runs to the end of the block it is in, or from a blank onto the next block.
+             * - `'adjacent'` — the two lines flanking the range on the cross axis (for a downward
+             *   extension, the column left of the left edge and the column right of the right edge). Each
+             *   contributes its contiguous run measured from the line the extension would start on, and
+             *   the **further** of the two wins; a flank that starts blank contributes nothing, which is
+             *   why a spacer column stops the extension dead. The reach is then cut short **before** the
+             *   nearest populated line inside the range's own columns, so an existing block is not run
+             *   over. This is the destination Excel picks when the fill handle is double-clicked, and it
+             *   feeds {@link ICellRange.autoFill} directly.
+             *
+             * @defaultValue 'content'
+             */
+            basis?: 'content' | 'adjacent';
+            /**
+             * Where a walk that begins on a **blank** cell comes to rest.
+             *
+             * - `'enter'` — on the first cell of the block it runs into. This is Ctrl+Arrow.
+             * - `'before'` — on the last blank, one short of that block. This is what a double-clicked
+             *   selection border does.
+             *
+             * Blanks are the *only* thing this changes: from a populated cell both run to the end of that
+             * cell's own block and stop in the same place. It is also independent of {@link basis} — that
+             * says where the boundary is read from, this says what happens on the way — though `'adjacent'`
+             * has nothing to apply it to, since a blank flank contributes no reach in the first place.
+             *
+             * @defaultValue 'enter'
+             */
+            fromBlank?: 'enter' | 'before';
+        }
         /**
          * Options for {@link ICellRange.getSurrounding}.
          */
@@ -12313,12 +12375,19 @@ declare global {
          */
         getFormulaAt(row: number, column: number, sheetName?: string): string | null;
         /**
-         * Returns the spill range anchored at a cell.
+         * Returns the range the formula anchored at a cell OCCUPIES — what the spill anchor operator
+         * (`A1#`) resolves to.
          *
-         * @param row The row where the spill starts.
-         * @param column The column where the spill starts.
+         * @param row The row the formula is anchored at.
+         * @param column The column the formula is anchored at.
          * @param sheetName The name of the sheet. If not provided the current sheet is used.
-         * @returns The spilled range, or `null` if nothing spills from that cell.
+         * @returns The range, or `null` if no formula is anchored there.
+         *
+         * @remarks
+         * The range is the formula's spill when it produced an array, the whole block for a legacy
+         * array formula, and the cell ITSELF for an ordinary formula — every formula occupies at least
+         * the cell it sits in. `null` means no formula is anchored at that cell: it holds a constant, it
+         * is empty, or it merely lies INSIDE another cell's spill or array block.
          */
         getSpillAt(row: number, column: number, sheetName?: string): IReferenceRange | null;
         /**

package/types/src/calculation/ICalculation.d.ts

@@ -572,6 +572,11 @@ export declare namespace ICalculation {
          * two diverge exactly where normalization is lossy — a number (`3.0` → `3`, `1**2` → `100`) or a
          * cell (raw `b2` vs the resolved coords). `undefined` only for a token with no captured source
          * image (e.g. a reference the engine rewrote programmatically rather than one the user typed).
+         *
+         * A reference literal is ONE span: a typed sheet qualifier and a trailing spill anchor ride inside
+         * the `cell`/`named` token's `text` (`Sheet2!A1#`), so the caret rules an editor applies per token
+         * treat the whole reference as one. The anchor keeps its own `postfix` token (carrying the same
+         * {@link referenceIndex}) imaging the empty string, so the concatenation above still holds.
          */
         text?: string;
         /**

package/types/src/calculation/compiler/CompilerUtils.d.ts

@@ -129,6 +129,26 @@ export declare const isRangedNode: (node: ASTNode) => boolean;
  * parse path has no access to — and "SUM is not a defined name" is an honest answer.
  */
 export declare const findNonReferenceIntersectionOperand: (root: ASTNode, getFunction: ((name: string) => IFunction | null) | null) => ASTNode | null;
+/**
+ * Finds a spill-anchor (`#`) operand that cannot possibly be a reference, or `null` if the formula
+ * has none.
+ *
+ * @param root The root of the formula's AST.
+ * @param getFunction Resolves a function's stableId to its declaration, or `null`.
+ *
+ * @remarks
+ * The anchor answers "where did the formula anchored HERE put its result", so its operand is a
+ * location, never a value — Excel's own declaration is `ANCHORARRAY(Range) -> Range|Array`. An
+ * operand that provably computes a value is refused at ENTRY, the same verdict (and the same
+ * predicate — {@link isDefinitelyNotReferenceNode}) as the intersection operand beside it.
+ *
+ * Measured against Excel 16.0 desktop (`spreadsheetbench/formula-tests/probe-anchor.ps1`): `=5#`,
+ * `={1,2}#` and `=SUM(X1:X3)#` cannot be typed at all, while a reference-returning call
+ * (`=INDEX(X1:X3,1)#`, `=OFFSET(B3,0,0)#`) is accepted. A NAME is accepted too — what it resolves
+ * to is not knowable here — and answers `#VALUE!` when it turns out to hold a constant, which is
+ * the runtime half of this same rule.
+ */
+export declare const findNonReferenceAnchorOperand: (root: ASTNode, getFunction: ((name: string) => IFunction | null) | null) => ASTNode | null;
 /**
  * Finds an array constant whose rows are not all the same length — a JAGGED literal such as
  * `{1,2;3}`.

package/types/src/calculation/compiler/FormulaParser.d.ts

@@ -92,8 +92,11 @@ export declare class FormulaParser extends EmbeddedActionsParser {
     /** Matches a single `+` or `-` token. Used as a helper by `_rulePrefixOp` and `_ruleLiteralForArray`. */
     protected _rulePlusMinusOp: import('chevrotain').ParserMethod<[], IToken>;
     /**
-     * Applies zero or more postfix operators (`%` percent, `#` spill anchor) to the node
-     * produced by `_rulePrefixOp`, building a right-growing postfix AST chain.
+     * Applies zero or more `%` percent postfixes to the node produced by `_rulePrefixOp`, building a
+     * right-growing postfix AST chain.
+     *
+     * The other postfix, the spill anchor `#`, is NOT here: it binds tighter than the unary prefixes
+     * and looser than `:`, so it lives inside `_ruleRangeOp`.
      */
     protected _rulePostfixOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
     /**
@@ -106,10 +109,33 @@ export declare class FormulaParser extends EmbeddedActionsParser {
      */
     protected _rulePrefixOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
     /**
-     * Folds the range operators (`:` range, `.:.` / `.:` / `:.` range-trim) — Excel's highest-precedence
-     * operators, binding tighter than the unary prefixes (`_rulePrefixOp`). Left-associative, single level
-     * (`A1:B2:C3` = `(A1:B2):C3`); every operator produces a reference infix node (`isRange = true`) so the
-     * whole span resolves to one reference. This rule sits just above the `_ruleCallOp` leaf.
+     * Folds the range operators (`:` range, `.:.` / `.:` / `:.` range-trim) and the spill anchor `#` —
+     * Excel's highest-precedence operators, binding tighter than the unary prefixes (`_rulePrefixOp`).
+     * Left-associative, single level (`A1:B2:C3` = `(A1:B2):C3`); every operator produces a reference
+     * node (`isRange = true`) so the whole span resolves to one reference. This rule sits just above the
+     * `_ruleCallOp` leaf.
+     *
+     * ── Why `#` is folded HERE, with the range operators ─────────────────────────────────────────
+     *
+     * The anchor is a postfix over the reference accumulated SO FAR, not over the primary in front of
+     * it: `A1:B2#` is `(A1:B2)#`, whose operand is a multi-cell reference — `#REF!` in Excel. What a
+     * `#` before the operator anchors is only its own operand, because that is all that has
+     * accumulated yet — `B3#:B1` is `(B3#):B1`, the rectangle spanning B1 and the whole of B3's spill.
+     *
+     * Measured against Excel 16.0 desktop (`spreadsheetbench/formula-tests/probe-anchor.ps1`); the
+     * xlsx round-trip is the unambiguous witness, since the anchor lowers to an explicit call there:
+     *
+     * | typed | value | stored |
+     * | --- | --- | --- |
+     * | `B1:B3#` | `#REF!` | `_xlfn.ANCHORARRAY(B1:B3)` |
+     * | `B11:B3#` | `#REF!` | `_xlfn.ANCHORARRAY(B3:B11)` — re-imaged as `=B3:B11#` |
+     * | `B3#:B1` | B1:B5 | `_xlfn.ANCHORARRAY(B3):B1` |
+     *
+     * Excel ONLINE parses the same text differently — its grammar attaches `#` to the PRIMARY
+     * (`re = q(primary, any(Pound, StructRef), ...)` in the shipped engine), so it reads `A1:(B2#)`.
+     * Desktop wins. (The one desktop form this fold does not reproduce is `B3#:B5#`, which Excel
+     * stores as `ANCHORARRAY(B3):ANCHORARRAY(B5)` while we anchor the accumulation. Both are `#REF!`
+     * — an anchor over a multi-cell reference either way — so only the re-imaged text differs.)
      */
     protected _ruleRangeOp: import('chevrotain').ParserMethod<[], ASTNode<TokenType, any>>;
     /**

package/types/src/calculation/functions/Operators.d.ts

@@ -25,6 +25,6 @@ export declare const Prefix: {
 };
 export declare const Postfix: {
     '%': (context: IFormulaContext, value: any) => any;
-    '#': (context: IFormulaContext, value: any) => IReferenceRange;
+    '#': (context: IFormulaContext, value: any) => IReferenceRange | FormulaError.Known;
 };
 //# sourceMappingURL=Operators.d.ts.map

package/types/src/calculation/grid/CalcGrid.d.ts

@@ -75,6 +75,8 @@ export declare class CalcGrid implements ICalcGrid {
     getDirtyRegions(): ISpatialQuery;
     /** {@inheritDoc ICalcGrid.getFormulas} */
     getFormulas(): ISpatialQuery<IFormulaBlock>;
+    /** {@inheritDoc ICalcGrid.getSpills} */
+    getSpills(): ISpatialQuery<SpillEntry>;
     /** {@inheritDoc ICalcGrid.getSnapshot} */
     getSnapshot(options?: ICalcGrid.GetSnapshotOptions): ICalcGrid.ISnapshot;
     /** {@inheritDoc ICalcGrid.getDirectDependentsAt} */

package/types/src/calculation/grid/ICalcGrid.d.ts

@@ -66,6 +66,17 @@ export interface ICalcGrid {
      * Used by sheet
      */
     getFormulas(): ISpatialQuery<IFormulaBlock>;
+    /**
+     * Returns a queryable spatial index of the ARRAY EXTENTS on this grid — one entry per array
+     * formula, keyed by the cells it occupies: a dynamic array's spill, a legacy CSE block, or the
+     * single cell a blocked spill collapses to.
+     *
+     * @remark
+     * The same index a calculation pass writes through {@link ICalcGrid.IncrementalUpdates.spillSpatial}
+     * (`beginUpdates` hands out this very map), so a read answers identically inside and outside a
+     * pass — which is what lets a formula evaluated OUTSIDE one resolve a spill anchor.
+     */
+    getSpills(): ISpatialQuery<SpillEntry>;
     /**
      * Returns the current values on the grid.
      */

package/types/src/cellRange/ICellRange.d.ts

@@ -246,11 +246,24 @@ export interface ICellRange {
      * Returns a range that includes the current range up to a content edge boundary.
      *
      * @param direction The direction.
-     * @param cell The cell to use as a starting point.
-     *               If not provide the cell closest to the edge will be used.
+     * @param cell Either the cell to walk from — as {@link ICellRange.GetExtendedOptions.cell}, and
+     *               the positional form Office Scripts' `getExtendedRange` takes — or the full
+     *               {@link ICellRange.GetExtendedOptions}. If neither is given the cell closest to
+     *               the edge is used.
      * @returns `ICellRange` extended in the given direction.
+     *
+     * @remarks
+     * The result **includes** the current range, and a boundary with nowhere to go returns the range
+     * unchanged — so comparing the two is how you tell there was nothing to extend onto.
+     *
+     * {@link ICellRange.GetExtendedOptions.basis} picks what the boundary is read from: the range's
+     * own content (Ctrl+Arrow, the default) or the lines flanking it (a double-clicked fill handle).
+     *
+     * Both bases read the content, merge and table indexes rather than walking cells, so the cost is
+     * the blocks involved and not the distance traveled — extending across a million rows costs what
+     * extending across ten does.
      */
-    getExtended(direction: IRange.Direction, cell?: ICell.Address): this;
+    getExtended(direction: IRange.Direction, cell?: ICell.Address | ICellRange.GetExtendedOptions): this;
     /**
      * Returns a range with coordinates adjusted to be fixed (absolute) or flexible (relative).
      *
@@ -1391,6 +1404,50 @@ export declare namespace ICellRange {
          */
         colEnd?: boolean;
     }
+    /**
+     * Options for {@link ICellRange.getExtended}.
+     */
+    interface GetExtendedOptions {
+        /**
+         * The cell to walk from. Only `'content'` extends from a cell — the flanking lines a
+         * `'adjacent'` extension reads are fixed by the range's own edges — so this is ignored there.
+         *
+         * @defaultValue the cell of the range closest to the edge being extended toward.
+         */
+        cell?: ICell.Address;
+        /**
+         * What the content edge is read from.
+         *
+         * - `'content'` — the range's own content, walked from {@link cell}. This is Ctrl+Arrow: it
+         *   runs to the end of the block it is in, or from a blank onto the next block.
+         * - `'adjacent'` — the two lines flanking the range on the cross axis (for a downward
+         *   extension, the column left of the left edge and the column right of the right edge). Each
+         *   contributes its contiguous run measured from the line the extension would start on, and
+         *   the **further** of the two wins; a flank that starts blank contributes nothing, which is
+         *   why a spacer column stops the extension dead. The reach is then cut short **before** the
+         *   nearest populated line inside the range's own columns, so an existing block is not run
+         *   over. This is the destination Excel picks when the fill handle is double-clicked, and it
+         *   feeds {@link ICellRange.autoFill} directly.
+         *
+         * @defaultValue 'content'
+         */
+        basis?: 'content' | 'adjacent';
+        /**
+         * Where a walk that begins on a **blank** cell comes to rest.
+         *
+         * - `'enter'` — on the first cell of the block it runs into. This is Ctrl+Arrow.
+         * - `'before'` — on the last blank, one short of that block. This is what a double-clicked
+         *   selection border does.
+         *
+         * Blanks are the *only* thing this changes: from a populated cell both run to the end of that
+         * cell's own block and stop in the same place. It is also independent of {@link basis} — that
+         * says where the boundary is read from, this says what happens on the way — though `'adjacent'`
+         * has nothing to apply it to, since a blank flank contributes no reach in the first place.
+         *
+         * @defaultValue 'enter'
+         */
+        fromBlank?: 'enter' | 'before';
+    }
     /**
      * Options for {@link ICellRange.getSurrounding}.
      */

package/types/src/sheet/SheetRange.d.ts

@@ -162,7 +162,18 @@ export declare class SheetRange implements ICellRange {
     /** {@inheritDoc ICellRange.getSurrounding} */
     getSurrounding(options?: ICellRange.GetSurroundingOptions): this;
     /** {@inheritDoc ICellRange.getExtended} */
-    getExtended(direction: IRange.Direction, cell?: ICell.Address): this;
+    getExtended(direction: IRange.Direction, cell?: ICell.Address | ICellRange.GetExtendedOptions): this;
+    /**
+     * `fromBlank: 'before'` — a walk that set off from a blank comes to rest on the last blank rather
+     * than on the first cell of the block it ran into. See
+     * {@link ICellRange.GetExtendedOptions.fromBlank}.
+     */
+    private _restBeforeBlock;
+    /**
+     * `basis: 'adjacent'` — the boundary comes from the lines flanking the range rather than from its
+     * own content. See {@link ICellRange.GetExtendedOptions.basis} for the rule.
+     */
+    private _extendedAdjacent;
     /** {@inheritDoc ICellRange.getEntireRows} */
     getEntireRows(shift?: boolean, options?: ICellRange.GetRangeOptions): this;
     /** {@inheritDoc ICellRange.getEntireColumns} */