@ex-grid/core 0.2.0-beta.3 → 0.2.0-rc.1

package/dist/index.js

@@ -857,7 +857,23 @@ var findPanelLabelIds = Object.freeze({
   /** The refused cells past those named, their count at `{count}`. */
   replaceRefusedMore: "find-replace-refused-more",
   /** Why a match in a column that is not Editable cannot be written. */
-  notEditable: "find-not-editable"
+  notEditable: "find-not-editable",
+  /** The Find All button (ADR-0470 §1). */
+  findAll: "find-all",
+  /** The list of a Find All's matches: its accessible name. */
+  findAllList: "find-all-list",
+  /** What a Find All that matched several cells says, their count at `{count}`. */
+  findAllFound: "find-all-found",
+  /** What a Find All that matched one cell says. */
+  findAllFoundOne: "find-all-found-one",
+  /** What a Find All that matched nothing says. */
+  findAllNone: "find-all-none",
+  /** Where a match in a row is, its row's number from 1 at `{row}` and its column's header at `{column}`. */
+  findAllInRow: "find-all-in-row",
+  /** Where a match in a row is, by the Consumer's label for the row at `{row}` and its column's header at `{column}`. */
+  findAllInLabelledRow: "find-all-in-labelled-row",
+  /** Where a match in a header is, the header's text at `{column}`. */
+  findAllInHeader: "find-all-in-header"
 });
 var findPanelWords = Object.freeze([
   [findPanelLabelIds.title, "Find"],
@@ -879,7 +895,15 @@ var findPanelWords = Object.freeze([
   [findPanelLabelIds.replaceRefused, "Nothing was replaced."],
   [findPanelLabelIds.replaceRefusedCell, "Row {row}, {column}: {reason}."],
   [findPanelLabelIds.replaceRefusedMore, "And {count} more."],
-  [findPanelLabelIds.notEditable, "this column cannot be edited"]
+  [findPanelLabelIds.notEditable, "this column cannot be edited"],
+  [findPanelLabelIds.findAll, "Find All"],
+  [findPanelLabelIds.findAllList, "Matches"],
+  [findPanelLabelIds.findAllFound, "{count} cells found"],
+  [findPanelLabelIds.findAllFoundOne, "1 cell found"],
+  [findPanelLabelIds.findAllNone, "No cells found"],
+  [findPanelLabelIds.findAllInRow, "Row {row}, {column}"],
+  [findPanelLabelIds.findAllInLabelledRow, "{row}, {column}"],
+  [findPanelLabelIds.findAllInHeader, "Header {column}"]
 ]);
 var refusedCellsNamed = 5;
 function findOutcomeText(outcome, words2) {
@@ -5169,6 +5193,16 @@ var GridMetrics = class _GridMetrics {
   get fillHandleSizePx() {
     return Math.max(5, roundHalfToEven(this.rowHeightPx * 0.3));
   }
+  /** The side of a Reference Outline's corner square (ADR-0480): 5px, as Excel draws it, in the Reference's colour
+   * with a 1px margin of the ground, centred on the outline's corner. */
+  get referenceHandleSizePx() {
+    return 5;
+  }
+  /** How wide the strip along a Reference Outline's line is that a press grabs it by (ADR-0480): 5px, centred on
+   * the line, wider than the line so that it can be pressed. */
+  get referenceGripPx() {
+    return 5;
+  }
   /** A cell's horizontal padding on one side; a cell pays it twice. */
   get cellPaddingXPx() {
     return this.cellMetrics.cellHorizontalPaddingPx;
@@ -6974,6 +7008,187 @@ function beyond(position, first, last) {
   return position < first ? position - first : 0;
 }
 
+// src/paint/selection-styles.ts
+var outlineSideStyles = Object.freeze(Array.from({ length: 16 }, (_, flags) => ((flags & 1) === 0 ? "" : "; --ex-outline-in-t: 1") + ((flags & 2) === 0 ? "" : "; --ex-outline-in-l: 1") + ((flags & 4) === 0 ? "" : "; --ex-outline-heading-t: 1") + ((flags & 8) === 0 ? "" : "; --ex-outline-heading-l: 1")));
+var flushPx = 0.01;
+function cellRange(cell2) {
+  return selectionRange(cell2.row, cell2.column, 1, 1);
+}
+function box(range, focus, columns, rowHeightPx, painted, pinnedLayer, cover) {
+  if (rangeCellCount(range) === 1 && rangeContains(range, focus)) return void 0;
+  const style = whole3(range, columns, rowHeightPx, painted, pinnedLayer, rowHeightPx);
+  const side = sideOf(range, columns, pinnedLayer);
+  if (style === void 0 || side === void 0) return void 0;
+  return style + outlineSides(range.topRow, side.first, columns, pinnedLayer, cover, true);
+}
+function tint(range, focus, columns, rowHeightPx, painted, pinnedLayer) {
+  const side = sideOf(range, columns, pinnedLayer);
+  if (side === void 0 || focusAlone(range, side, focus)) return void 0;
+  const rows = clip(range, painted);
+  if (rows === void 0) return void 0;
+  const leftPx = columns.offsetPxOf(side.first);
+  let style = rect(leftPx, columns.offsetPxOf(side.last + 1) - leftPx, rows, rowHeightPx, painted.start);
+  if (rangeContains(range, focus) && sideOf(cellRange(focus), columns, pinnedLayer) !== void 0 && focus.row >= rows.top && focus.row < rows.top + rows.count) {
+    const holeLeftPx = columns.offsetPxOf(focus.column) - leftPx;
+    const holeRightPx = columns.offsetPxOf(focus.column + 1) - leftPx;
+    const holeTopPx = (focus.row - rows.top) * rowHeightPx;
+    const holeBottomPx = holeTopPx + rowHeightPx;
+    style += `; --ex-range-hole: polygon(evenodd, 0 0, 100% 0, 100% 100%, 0 100%, 0 0, ${holeLeftPx}px ${holeTopPx}px, ${holeRightPx}px ${holeTopPx}px, ${holeRightPx}px ${holeBottomPx}px, ${holeLeftPx}px ${holeBottomPx}px, ${holeLeftPx}px ${holeTopPx}px)`;
+  }
+  return style;
+}
+function tinted(range, focus, columns, painted, pinnedLayer) {
+  const side = sideOf(range, columns, pinnedLayer);
+  return side !== void 0 && !focusAlone(range, side, focus) && clip(range, painted) !== void 0;
+}
+function reaches(range, columns, painted, pinnedLayer) {
+  return sideOf(range, columns, pinnedLayer) !== void 0 && clip(range, painted) !== void 0;
+}
+function whole3(range, columns, rowHeightPx, painted, pinnedLayer, outsidePx = 0) {
+  const rows = clip(range, painted);
+  if (sideOf(range, columns, pinnedLayer) === void 0 || rows === void 0) return void 0;
+  const leftPx = columns.offsetPxOf(range.leftColumn);
+  const rightPx = columns.offsetPxOf(rightColumn(range) + 1);
+  let style = rect(leftPx, rightPx - leftPx, rows, rowHeightPx, painted.start);
+  if (sideOf(range, columns, !pinnedLayer) !== void 0) {
+    const boundaryPx = columns.offsetPxOf(columns.pinnedCount);
+    const o = outsidePx > 0 ? `${-outsidePx}px` : "0";
+    style += pinnedLayer ? `; clip-path: inset(${o} ${rightPx - boundaryPx}px ${o} ${o})` : `; clip-path: inset(${o} ${o} ${o} ${boundaryPx - leftPx}px)`;
+  }
+  return style;
+}
+function copied(range, columns, rowHeightPx, painted, pinnedLayer, cover) {
+  const style = whole3(range, columns, rowHeightPx, painted, pinnedLayer, rowHeightPx);
+  const side = sideOf(range, columns, pinnedLayer);
+  if (style === void 0 || side === void 0) return void 0;
+  return style + outlineSides(range.topRow, side.first, columns, pinnedLayer, cover, false);
+}
+function focusStyle(focus, columns, rowHeightPx, painted, pinnedLayer, cover) {
+  const style = part(cellRange(focus), columns, rowHeightPx, painted, pinnedLayer);
+  if (style === void 0) return void 0;
+  return style + outlineSides(focus.row, focus.column, columns, pinnedLayer, cover, true);
+}
+function gripResizes(kind) {
+  return kind === "topLeft" || kind === "topRight" || kind === "bottomLeft" || kind === "bottomRight";
+}
+var referenceSquareMarginPx = 1;
+function gripCursor(kind) {
+  if (kind === "topLeft" || kind === "bottomRight") return "nwse";
+  return kind === "topRight" || kind === "bottomLeft" ? "nesw" : "move";
+}
+function referenceGrips(range, columns, rowHeightPx, painted, pinnedLayer, gripPx, squarePx, readableLeftPx, named3 = range) {
+  const side = sideOf(range, columns, pinnedLayer);
+  const rows = clip(range, painted);
+  if (side === void 0 || rows === void 0) return [];
+  const rowPainted = (row) => row >= painted.start - 1 && row <= painted.start + painted.count;
+  const hasLeft = sideOf(cellRange({ row: range.topRow, column: range.leftColumn }), columns, pinnedLayer) !== void 0 && range.leftColumn === named3.leftColumn;
+  const hasRight = sideOf(cellRange({ row: range.topRow, column: rightColumn(range) }), columns, pinnedLayer) !== void 0 && rightColumn(range) === rightColumn(named3);
+  const hasTop = rowPainted(range.topRow) && range.topRow === named3.topRow;
+  const hasBottom = rowPainted(bottomRow(range)) && bottomRow(range) === bottomRow(named3);
+  const leftX = columns.offsetPxOf(range.leftColumn);
+  const rightX = columns.offsetPxOf(rightColumn(range) + 1);
+  const topY = (range.topRow - painted.start) * rowHeightPx;
+  const bottomY = (bottomRow(range) + 1 - painted.start) * rowHeightPx;
+  const spanLeft = Math.max(columns.offsetPxOf(side.first), readableLeftPx);
+  const spanRight = columns.offsetPxOf(side.last + 1);
+  const spanTop = (rows.top - painted.start) * rowHeightPx;
+  const spanBottom = spanTop + rows.count * rowHeightPx;
+  const half = gripPx / 2;
+  const grips = [];
+  const strip = (kind, leftPx, topPx, widthPx, heightPx) => {
+    const clippedLeft = Math.max(leftPx, readableLeftPx);
+    const clippedWidth = widthPx - (clippedLeft - leftPx);
+    if (clippedWidth > 0 && heightPx > 0) grips.push(Object.freeze({ kind, leftPx: clippedLeft, topPx, widthPx: clippedWidth, heightPx }));
+  };
+  if (hasTop) strip("top", spanLeft, topY - half, spanRight - spanLeft, gripPx);
+  if (hasBottom) strip("bottom", spanLeft, bottomY - half, spanRight - spanLeft, gripPx);
+  if (hasLeft) strip("left", leftX - half, spanTop, gripPx, spanBottom - spanTop);
+  if (hasRight) strip("right", rightX - half, spanTop, gripPx, spanBottom - spanTop);
+  const squareBox = squarePx + 2 * referenceSquareMarginPx;
+  const square = (kind, x, y) => {
+    if (x < readableLeftPx) return;
+    grips.push(Object.freeze({ kind, leftPx: x - squareBox / 2, topPx: y - squareBox / 2, widthPx: squareBox, heightPx: squareBox }));
+  };
+  if (hasTop && hasLeft) square("topLeft", leftX, topY);
+  if (hasTop && hasRight) square("topRight", rightX, topY);
+  if (hasBottom && hasLeft) square("bottomLeft", leftX, bottomY);
+  if (hasBottom && hasRight) square("bottomRight", rightX, bottomY);
+  return grips;
+}
+function scrollable(range, columns, rowHeightPx, painted) {
+  return part(range, columns, rowHeightPx, painted, false);
+}
+function pinned(range, columns, rowHeightPx, painted) {
+  return part(range, columns, rowHeightPx, painted, true);
+}
+function handle(range, corner, columns, rowHeightPx, painted, sizePx, pinnedLayer, readable) {
+  const cell2 = handleCell(range, corner);
+  if (sideOf(cellRange(cell2), columns, pinnedLayer) === void 0) return void 0;
+  const heldAtTheTop = corner === "topRight";
+  if (!heldAtTheTop && cell2.row < painted.start - 1 || cell2.row > painted.start + painted.count) return void 0;
+  const [leftPx, topPx] = handleCentrePx(range, corner, columns, rowHeightPx, painted.start, sizePx, readable);
+  return `left: ${leftPx - sizePx / 2}px; top: ${topPx - sizePx / 2}px; width: ${sizePx}px; height: ${sizePx}px`;
+}
+function handleCell(range, corner) {
+  switch (corner) {
+    case "topRight":
+      return Object.freeze({ row: range.topRow, column: rightColumn(range) });
+    case "bottomLeft":
+      return Object.freeze({ row: bottomRow(range), column: range.leftColumn });
+    case "bottomRight":
+      return Object.freeze({ row: bottomRow(range), column: rightColumn(range) });
+    default:
+      return unreachable(corner);
+  }
+}
+function handleCentrePx(range, corner, columns, rowHeightPx, firstPaintedRow, sizePx, readable) {
+  const half = sizePx / 2;
+  switch (corner) {
+    case "topRight":
+      return [columns.offsetPxOf(rightColumn(range) + 1), Math.max((range.topRow - firstPaintedRow) * rowHeightPx, readable.topPx) + half];
+    case "bottomLeft":
+      return [
+        (range.leftColumn < columns.pinnedCount ? columns.offsetPxOf(range.leftColumn) : Math.max(columns.offsetPxOf(range.leftColumn), readable.leftPx)) + half,
+        (bottomRow(range) + 1 - firstPaintedRow) * rowHeightPx
+      ];
+    case "bottomRight":
+      return [columns.offsetPxOf(rightColumn(range) + 1), (bottomRow(range) + 1 - firstPaintedRow) * rowHeightPx];
+    default:
+      return unreachable(corner);
+  }
+}
+function outlineSides(topRow, firstColumn, columns, pinnedLayer, cover, headingMark) {
+  const top = topRow < cover.firstOpenRow;
+  const left = pinnedLayer ? columns.offsetPxOf(firstColumn) <= columns.leadWidthPx + flushPx : columns.offsetPxOf(firstColumn) - cover.scrollLeftPx <= columns.pinnedWidthPx + flushPx;
+  const headingTop = top && headingMark && cover.hasHeader;
+  const headingLeft = left && headingMark && columns.leadWidthPx > 0 && (pinnedLayer || columns.pinnedCount === 0);
+  const flags = (top && !headingTop ? 1 : 0) | (left && !headingLeft ? 2 : 0) | (headingTop ? 4 : 0) | (headingLeft ? 8 : 0);
+  return itemAt(outlineSideStyles, flags);
+}
+function focusAlone(range, side, focus) {
+  return range.rowCount === 1 && side.first === side.last && focus.row === range.topRow && focus.column === side.first;
+}
+function part(range, columns, rowHeightPx, painted, pinnedLayer) {
+  const side = sideOf(range, columns, pinnedLayer);
+  const rows = clip(range, painted);
+  if (side === void 0 || rows === void 0) return void 0;
+  return rect(columns.offsetPxOf(side.first), columns.offsetPxOf(side.last + 1) - columns.offsetPxOf(side.first), rows, rowHeightPx, painted.start);
+}
+function sideOf(range, columns, pinnedLayer) {
+  const first = pinnedLayer ? range.leftColumn : Math.max(range.leftColumn, columns.pinnedCount);
+  const last = pinnedLayer ? Math.min(rightColumn(range), columns.pinnedCount - 1) : rightColumn(range);
+  return first > last ? void 0 : { first, last };
+}
+function clip(range, painted) {
+  const top = Math.max(range.topRow, painted.start - 1);
+  const bottom = Math.min(bottomRow(range), painted.start + painted.count);
+  return bottom < top ? void 0 : { top, count: bottom - top + 1 };
+}
+function rect(leftPx, widthPx, rows, rowHeightPx, firstPaintedRow) {
+  const topPx = (rows.top - firstPaintedRow) * rowHeightPx;
+  return `left: ${leftPx}px; top: ${topPx}px; width: ${widthPx}px; height: ${rows.count * rowHeightPx}px`;
+}
+
 // src/query/sort.ts
 function nextSort(current, column) {
   if (column === "") throw new TypeError("A sort names a column.");
@@ -7840,6 +8055,81 @@ var InMemoryRowMarks = class {
   }
 };
 
+// src/finding/find-all.ts
+function findAllPage(total, matches3, rowSequenceVersion) {
+  if (!Number.isInteger(total) || total < 0) throw new RangeError(`A Find All counts 0 matches or more, not ${total}.`);
+  if (matches3.length > total) throw new RangeError(`A Find All page holds ${matches3.length} matches of a list of ${total}.`);
+  return Object.freeze({
+    total,
+    rowSequenceVersion,
+    matches: Object.freeze(matches3.map(({ row, column, text: text3, rowLabel }) => Object.freeze(rowLabel === void 0 ? { row, column, text: text3 } : { row, column, text: text3, rowLabel })))
+  });
+}
+var FindAllMatches = class _FindAllMatches {
+  #rows;
+  #columns;
+  #texts;
+  #ordinals;
+  #rowLabel;
+  constructor(rows, columns, texts, ordinals, rowLabel) {
+    this.#rows = rows;
+    this.#columns = columns;
+    this.#texts = texts;
+    this.#ordinals = ordinals;
+    this.#rowLabel = rowLabel;
+  }
+  /**
+   * Walks `rows` once (ADR-0470 §2), by rows and across a row in the request's column order. `textOf` answers a
+   * column's displayed text by name, or `undefined` for a column with no text to search or one not known, which is
+   * skipped, as a step skips it. An empty pattern matches nothing. `rowLabel`, where given, names each match's row in
+   * the Consumer's words.
+   */
+  static of(rows, request, textOf4, rowLabel) {
+    const columns = Object.freeze([...request.columns]);
+    const texts = columns.map(textOf4);
+    const matches3 = matcherOf(request);
+    const ordinals = [];
+    if (request.text !== "") {
+      const columnCount = columns.length;
+      rows.forEach((item, row) => {
+        texts.forEach((text3, column) => {
+          if (text3 === void 0) return;
+          if (request.scope !== void 0 && !inScope(request.scope, row, column)) return;
+          if (matches3(text3(item))) ordinals.push(row * columnCount + column);
+        });
+      });
+    }
+    return new _FindAllMatches(rows, columns, texts, Object.freeze(ordinals), rowLabel);
+  }
+  /** How many cells match. */
+  get total() {
+    return this.#ordinals.length;
+  }
+  /** The entries from `start`, `count` of them or every one left, under `rowSequenceVersion`. A range past the end
+   * holds none; a range outside the list's positions is refused. */
+  page(start, count, rowSequenceVersion) {
+    if (!Number.isInteger(start) || start < 0) throw new RangeError(`A Find All page starts at an entry at or after 0, not ${start}.`);
+    if (!Number.isInteger(count) || count < 1) throw new RangeError(`A Find All page asks for 1 entry or more, not ${count}.`);
+    const columnCount = this.#columns.length;
+    const matches3 = this.#ordinals.slice(start, start + count).map((ordinal2) => {
+      const row = Math.floor(ordinal2 / columnCount);
+      const column = ordinal2 % columnCount;
+      const text3 = itemAt(this.#texts, column);
+      if (text3 === void 0) throw new Error("Internal: a Find All match in a column with no text.");
+      const item = itemAt(this.#rows, row);
+      const match = { row, column: itemAt(this.#columns, column), text: text3(item) };
+      if (this.#rowLabel === void 0) return match;
+      const label = this.#rowLabel(item);
+      if (typeof label !== "string") throw new TypeError(`findAllRowLabel answers text for every row, not ${typeof label} (ADR-0470 \xA73).`);
+      return { ...match, rowLabel: label };
+    });
+    return findAllPage(this.total, matches3, rowSequenceVersion);
+  }
+};
+function findAll(rows, rowSequenceVersion, request, textOf4) {
+  return FindAllMatches.of(rows, request, textOf4).page(request.start, request.count, rowSequenceVersion);
+}
+
 // src/source/row-key.ts
 function keyOf2(rowKey, row, which2) {
   return checkedKey(rowKey(row), which2);
@@ -8560,8 +8850,13 @@ var InMemoryGridSource = class _InMemoryGridSource {
   #marks;
   #columns;
   #state;
-  constructor(rows, { rowKey, clock = systemClock }) {
+  // The last Find All's matches, kept while the result, the columns and the question stand, so a list scrolled
+  // through is walked once (ADR-0470 §2).
+  #findAllRowLabel;
+  #findAll;
+  constructor(rows, { rowKey, clock = systemClock, findAllRowLabel }) {
     this.#rowKey = rowKey;
+    this.#findAllRowLabel = findAllRowLabel;
     let window2;
     if (rowKey === void 0) {
       this.#rows = Object.freeze([...rows]);
@@ -8806,6 +9101,24 @@ var InMemoryGridSource = class _InMemoryGridSource {
     const columns = this.#queryColumns();
     return findStep(this.#state.window, request, (name) => textsOf(columns, name, textFor));
   }
+  /**
+   * The reference Find All (ADR-0470): `findAll` over the current result, matching each column's displayed text as
+   * `find` does. The matches are found once for a question and read a page at a time while the result stands. A
+   * request read under another version is answered anyway, under this source's: the grid discards it by the
+   * version.
+   */
+  async findAll(request, signal) {
+    signal.throwIfAborted();
+    const columns = this.#queryColumns();
+    const { window: window2, rowSequenceVersion } = this.#state;
+    const key2 = JSON.stringify([request.text, request.matchCase, request.wholeCell, request.scope, request.columns]);
+    let held2 = this.#findAll;
+    if (held2?.key !== key2 || held2.window !== window2 || held2.columns !== columns) {
+      held2 = { key: key2, window: window2, columns, matches: FindAllMatches.of(window2, request, (name) => textsOf(columns, name, textFor), this.#findAllRowLabel) };
+      this.#findAll = held2;
+    }
+    return held2.matches.page(request.start, request.count, rowSequenceVersion);
+  }
   /**
    * The reference Selection Summary (ADR-0130): `summaryOf` over the current result, reading each column's
    * value. A column this source was not told about, or one with no value of its own, is blank. It never
@@ -9425,172 +9738,38 @@ var ClipboardLedger = class _ClipboardLedger {
     const write = this.#pending.shift() ?? null;
     this.#heard.set(change, write);
     return write;
-  }
-};
-
-// src/dom/column-styles.ts
-var ColumnStyles = class {
-  /** The geometry the styles are made from. */
-  geometry;
-  #cells = [];
-  #pinnedCells = [];
-  #gaps = [];
-  constructor(geometry) {
-    this.geometry = geometry;
-  }
-  /** A scrollable cell's width. */
-  cell(column) {
-    return this.#cells[column] ??= `width: ${this.geometry.widthPxOf(column)}px`;
-  }
-  /** A pinned cell's width and its own offset: a sticky cell still occupies its place in the flow, so it
-   * sticks exactly where it would otherwise have been. */
-  pinnedCell(column) {
-    return this.#pinnedCells[column] ??= `width: ${this.geometry.widthPxOf(column)}px; left: ${this.geometry.offsetPxOf(column)}px`;
-  }
-  /** The spacer standing for the scrollable columns virtualised away to the left (ADR-0004). The pinned
-   * block is already in the flow ahead of it, so its width comes off. */
-  gap(firstScrollable) {
-    return this.#gaps[firstScrollable] ??= `width: ${Math.max(0, this.geometry.offsetPxOf(firstScrollable) - this.geometry.pinnedWidthPx)}px`;
-  }
-  /** Whether any scrollable column lies to the left of `firstScrollable`, so a gap stands for it. */
-  hasGap(firstScrollable) {
-    return this.geometry.offsetPxOf(firstScrollable) > this.geometry.pinnedWidthPx;
-  }
-};
-
-// src/paint/selection-styles.ts
-var outlineSideStyles = Object.freeze(Array.from({ length: 16 }, (_, flags) => ((flags & 1) === 0 ? "" : "; --ex-outline-in-t: 1") + ((flags & 2) === 0 ? "" : "; --ex-outline-in-l: 1") + ((flags & 4) === 0 ? "" : "; --ex-outline-heading-t: 1") + ((flags & 8) === 0 ? "" : "; --ex-outline-heading-l: 1")));
-var flushPx = 0.01;
-function cellRange(cell2) {
-  return selectionRange(cell2.row, cell2.column, 1, 1);
-}
-function box(range, focus, columns, rowHeightPx, painted, pinnedLayer, cover) {
-  if (rangeCellCount(range) === 1 && rangeContains(range, focus)) return void 0;
-  const style = whole3(range, columns, rowHeightPx, painted, pinnedLayer, rowHeightPx);
-  const side = sideOf(range, columns, pinnedLayer);
-  if (style === void 0 || side === void 0) return void 0;
-  return style + outlineSides(range.topRow, side.first, columns, pinnedLayer, cover, true);
-}
-function tint(range, focus, columns, rowHeightPx, painted, pinnedLayer) {
-  const side = sideOf(range, columns, pinnedLayer);
-  if (side === void 0 || focusAlone(range, side, focus)) return void 0;
-  const rows = clip(range, painted);
-  if (rows === void 0) return void 0;
-  const leftPx = columns.offsetPxOf(side.first);
-  let style = rect(leftPx, columns.offsetPxOf(side.last + 1) - leftPx, rows, rowHeightPx, painted.start);
-  if (rangeContains(range, focus) && sideOf(cellRange(focus), columns, pinnedLayer) !== void 0 && focus.row >= rows.top && focus.row < rows.top + rows.count) {
-    const holeLeftPx = columns.offsetPxOf(focus.column) - leftPx;
-    const holeRightPx = columns.offsetPxOf(focus.column + 1) - leftPx;
-    const holeTopPx = (focus.row - rows.top) * rowHeightPx;
-    const holeBottomPx = holeTopPx + rowHeightPx;
-    style += `; --ex-range-hole: polygon(evenodd, 0 0, 100% 0, 100% 100%, 0 100%, 0 0, ${holeLeftPx}px ${holeTopPx}px, ${holeRightPx}px ${holeTopPx}px, ${holeRightPx}px ${holeBottomPx}px, ${holeLeftPx}px ${holeBottomPx}px, ${holeLeftPx}px ${holeTopPx}px)`;
-  }
-  return style;
-}
-function tinted(range, focus, columns, painted, pinnedLayer) {
-  const side = sideOf(range, columns, pinnedLayer);
-  return side !== void 0 && !focusAlone(range, side, focus) && clip(range, painted) !== void 0;
-}
-function reaches(range, columns, painted, pinnedLayer) {
-  return sideOf(range, columns, pinnedLayer) !== void 0 && clip(range, painted) !== void 0;
-}
-function whole3(range, columns, rowHeightPx, painted, pinnedLayer, outsidePx = 0) {
-  const rows = clip(range, painted);
-  if (sideOf(range, columns, pinnedLayer) === void 0 || rows === void 0) return void 0;
-  const leftPx = columns.offsetPxOf(range.leftColumn);
-  const rightPx = columns.offsetPxOf(rightColumn(range) + 1);
-  let style = rect(leftPx, rightPx - leftPx, rows, rowHeightPx, painted.start);
-  if (sideOf(range, columns, !pinnedLayer) !== void 0) {
-    const boundaryPx = columns.offsetPxOf(columns.pinnedCount);
-    const o = outsidePx > 0 ? `${-outsidePx}px` : "0";
-    style += pinnedLayer ? `; clip-path: inset(${o} ${rightPx - boundaryPx}px ${o} ${o})` : `; clip-path: inset(${o} ${o} ${o} ${boundaryPx - leftPx}px)`;
-  }
-  return style;
-}
-function copied(range, columns, rowHeightPx, painted, pinnedLayer, cover) {
-  const style = whole3(range, columns, rowHeightPx, painted, pinnedLayer, rowHeightPx);
-  const side = sideOf(range, columns, pinnedLayer);
-  if (style === void 0 || side === void 0) return void 0;
-  return style + outlineSides(range.topRow, side.first, columns, pinnedLayer, cover, false);
-}
-function focusStyle(focus, columns, rowHeightPx, painted, pinnedLayer, cover) {
-  const style = part(cellRange(focus), columns, rowHeightPx, painted, pinnedLayer);
-  if (style === void 0) return void 0;
-  return style + outlineSides(focus.row, focus.column, columns, pinnedLayer, cover, true);
-}
-function scrollable(range, columns, rowHeightPx, painted) {
-  return part(range, columns, rowHeightPx, painted, false);
-}
-function pinned(range, columns, rowHeightPx, painted) {
-  return part(range, columns, rowHeightPx, painted, true);
-}
-function handle(range, corner, columns, rowHeightPx, painted, sizePx, pinnedLayer, readable) {
-  const cell2 = handleCell(range, corner);
-  if (sideOf(cellRange(cell2), columns, pinnedLayer) === void 0) return void 0;
-  const heldAtTheTop = corner === "topRight";
-  if (!heldAtTheTop && cell2.row < painted.start - 1 || cell2.row > painted.start + painted.count) return void 0;
-  const [leftPx, topPx] = handleCentrePx(range, corner, columns, rowHeightPx, painted.start, sizePx, readable);
-  return `left: ${leftPx - sizePx / 2}px; top: ${topPx - sizePx / 2}px; width: ${sizePx}px; height: ${sizePx}px`;
-}
-function handleCell(range, corner) {
-  switch (corner) {
-    case "topRight":
-      return Object.freeze({ row: range.topRow, column: rightColumn(range) });
-    case "bottomLeft":
-      return Object.freeze({ row: bottomRow(range), column: range.leftColumn });
-    case "bottomRight":
-      return Object.freeze({ row: bottomRow(range), column: rightColumn(range) });
-    default:
-      return unreachable(corner);
-  }
-}
-function handleCentrePx(range, corner, columns, rowHeightPx, firstPaintedRow, sizePx, readable) {
-  const half = sizePx / 2;
-  switch (corner) {
-    case "topRight":
-      return [columns.offsetPxOf(rightColumn(range) + 1), Math.max((range.topRow - firstPaintedRow) * rowHeightPx, readable.topPx) + half];
-    case "bottomLeft":
-      return [
-        (range.leftColumn < columns.pinnedCount ? columns.offsetPxOf(range.leftColumn) : Math.max(columns.offsetPxOf(range.leftColumn), readable.leftPx)) + half,
-        (bottomRow(range) + 1 - firstPaintedRow) * rowHeightPx
-      ];
-    case "bottomRight":
-      return [columns.offsetPxOf(rightColumn(range) + 1), (bottomRow(range) + 1 - firstPaintedRow) * rowHeightPx];
-    default:
-      return unreachable(corner);
-  }
-}
-function outlineSides(topRow, firstColumn, columns, pinnedLayer, cover, headingMark) {
-  const top = topRow < cover.firstOpenRow;
-  const left = pinnedLayer ? columns.offsetPxOf(firstColumn) <= columns.leadWidthPx + flushPx : columns.offsetPxOf(firstColumn) - cover.scrollLeftPx <= columns.pinnedWidthPx + flushPx;
-  const headingTop = top && headingMark && cover.hasHeader;
-  const headingLeft = left && headingMark && columns.leadWidthPx > 0 && (pinnedLayer || columns.pinnedCount === 0);
-  const flags = (top && !headingTop ? 1 : 0) | (left && !headingLeft ? 2 : 0) | (headingTop ? 4 : 0) | (headingLeft ? 8 : 0);
-  return itemAt(outlineSideStyles, flags);
-}
-function focusAlone(range, side, focus) {
-  return range.rowCount === 1 && side.first === side.last && focus.row === range.topRow && focus.column === side.first;
-}
-function part(range, columns, rowHeightPx, painted, pinnedLayer) {
-  const side = sideOf(range, columns, pinnedLayer);
-  const rows = clip(range, painted);
-  if (side === void 0 || rows === void 0) return void 0;
-  return rect(columns.offsetPxOf(side.first), columns.offsetPxOf(side.last + 1) - columns.offsetPxOf(side.first), rows, rowHeightPx, painted.start);
-}
-function sideOf(range, columns, pinnedLayer) {
-  const first = pinnedLayer ? range.leftColumn : Math.max(range.leftColumn, columns.pinnedCount);
-  const last = pinnedLayer ? Math.min(rightColumn(range), columns.pinnedCount - 1) : rightColumn(range);
-  return first > last ? void 0 : { first, last };
-}
-function clip(range, painted) {
-  const top = Math.max(range.topRow, painted.start - 1);
-  const bottom = Math.min(bottomRow(range), painted.start + painted.count);
-  return bottom < top ? void 0 : { top, count: bottom - top + 1 };
-}
-function rect(leftPx, widthPx, rows, rowHeightPx, firstPaintedRow) {
-  const topPx = (rows.top - firstPaintedRow) * rowHeightPx;
-  return `left: ${leftPx}px; top: ${topPx}px; width: ${widthPx}px; height: ${rows.count * rowHeightPx}px`;
-}
+  }
+};
+
+// src/dom/column-styles.ts
+var ColumnStyles = class {
+  /** The geometry the styles are made from. */
+  geometry;
+  #cells = [];
+  #pinnedCells = [];
+  #gaps = [];
+  constructor(geometry) {
+    this.geometry = geometry;
+  }
+  /** A scrollable cell's width. */
+  cell(column) {
+    return this.#cells[column] ??= `width: ${this.geometry.widthPxOf(column)}px`;
+  }
+  /** A pinned cell's width and its own offset: a sticky cell still occupies its place in the flow, so it
+   * sticks exactly where it would otherwise have been. */
+  pinnedCell(column) {
+    return this.#pinnedCells[column] ??= `width: ${this.geometry.widthPxOf(column)}px; left: ${this.geometry.offsetPxOf(column)}px`;
+  }
+  /** The spacer standing for the scrollable columns virtualised away to the left (ADR-0004). The pinned
+   * block is already in the flow ahead of it, so its width comes off. */
+  gap(firstScrollable) {
+    return this.#gaps[firstScrollable] ??= `width: ${Math.max(0, this.geometry.offsetPxOf(firstScrollable) - this.geometry.pinnedWidthPx)}px`;
+  }
+  /** Whether any scrollable column lies to the left of `firstScrollable`, so a gap stands for it. */
+  hasGap(firstScrollable) {
+    return this.geometry.offsetPxOf(firstScrollable) > this.geometry.pinnedWidthPx;
+  }
+};
 
 // src/dom/cell-editing.ts
 var waitingStyle = "left: 0px; top: 0px; width: 0px; height: 0px";
@@ -10278,6 +10457,8 @@ var FindPanel = class {
   #replace;
   // Whether a Replace All is out with the Consumer.
   #waiting = false;
+  #findAllButton;
+  #findAllPart;
   constructor(doc, held2, words2, answers) {
     this.#doc = doc;
     this.#held = held2;
@@ -10293,7 +10474,12 @@ var FindPanel = class {
     });
     const actions = doc.createElement("div");
     actions.className = "ex-popover-actions";
+    this.#findAllButton = this.#button("ex-find-all-button", findPanelLabelIds.findAll, () => {
+      answers.findAll();
+    });
+    this.#findAllButton.hidden = true;
     actions.append(
+      this.#findAllButton,
       this.#button("ex-find-previous", findPanelLabelIds.previous, () => {
         answers.step(true);
       }),
@@ -10364,6 +10550,15 @@ var FindPanel = class {
   say(text3) {
     if (this.#outcome.textContent !== text3) this.#outcome.textContent = text3;
   }
+  offerFindAll(offered) {
+    this.#findAllButton.hidden = !offered;
+  }
+  showFindAll(part2) {
+    if (part2 === this.#findAllPart) return;
+    this.#findAllPart?.remove();
+    this.#findAllPart = part2;
+    if (part2 !== void 0) this.#outcome.after(part2);
+  }
   focusField() {
     this.#field.focus({ preventScroll: true });
     this.#field.select();
@@ -10848,6 +11043,9 @@ var SlottedFindPanel = class {
   #replaceShown = false;
   #waiting = false;
   #outcome = "";
+  #findAllShown = false;
+  #findAllPart;
+  #body;
   #view;
   constructor(doc, mount, held2, label, answers, takeFocus) {
     this.#held = held2;
@@ -10863,6 +11061,7 @@ var SlottedFindPanel = class {
     slot.className = "ex-find-slot";
     form.append(slot);
     body.append(form);
+    this.#body = body;
     const toField = () => {
       this.#request(false);
     };
@@ -10929,6 +11128,17 @@ var SlottedFindPanel = class {
       replaceAll: act(() => {
         answers.replaceAll();
       }),
+      findAll: act(() => {
+        answers.findAll();
+      }),
+      listFindAll: act((list) => {
+        answers.listFindAll(list);
+      }, (list) => {
+        if (typeof list !== "function") throw new TypeError("listFindAll is handed a function that answers the list, asked in its turn (ADR-0470 \xA77).");
+      }),
+      dropFindAll: act(() => {
+        answers.dropFindAll();
+      }),
       close: act(() => {
         answers.close();
       }),
@@ -10960,6 +11170,18 @@ var SlottedFindPanel = class {
     this.#outcome = text3;
     this.#changed();
   }
+  offerFindAll(offered) {
+    if (offered === this.#findAllShown) return;
+    this.#findAllShown = offered;
+    this.#changed();
+  }
+  /** The list stands under the contents, in the core's own place, whichever Chrome draws them (ADR-0470 §3). */
+  showFindAll(part2) {
+    if (part2 === this.#findAllPart) return;
+    this.#findAllPart?.remove();
+    this.#findAllPart = part2;
+    if (part2 !== void 0) this.#body.append(part2);
+  }
   /** Mounts the contents with the next request for the field, whose text is selected. */
   focusField() {
     this.#request(true);
@@ -10982,7 +11204,8 @@ var SlottedFindPanel = class {
       replaceShown: this.#replaceShown,
       replaceText: this.#held.replaceText,
       replaceWaiting: this.#waiting,
-      outcome: this.#outcome
+      outcome: this.#outcome,
+      findAllShown: this.#findAllShown
     });
     return this.#view;
   }
@@ -11168,6 +11391,169 @@ var BarField = class _BarField {
   }
 };
 
+// src/dom/find-all-list.ts
+var findAllVisibleLines = 8;
+var lists = 0;
+var FindAllList = class {
+  /** The part's box, `.ex-find-all`, which the panel places under its contents. */
+  element;
+  /** The listbox, which takes the keyboard for the list's keys. */
+  list;
+  #countLine;
+  #doc;
+  #model;
+  #lineHeightPx;
+  #spacer;
+  #id;
+  #scrollTopPx = 0;
+  // The active line last brought into view: a line is revealed as it becomes active, never again while it stays so,
+  // so the user scrolls the list away from it freely.
+  #revealed;
+  // The lines drawn, by index, so a refresh rewrites only what changed.
+  #drawn = /* @__PURE__ */ new Map();
+  constructor(doc, model, lineHeightPx) {
+    if (!(lineHeightPx > 0)) throw new RangeError(`A Find All list's lines are taller than 0px, not ${lineHeightPx}.`);
+    this.#doc = doc;
+    this.#model = model;
+    this.#lineHeightPx = lineHeightPx;
+    lists += 1;
+    this.#id = `ex-find-all-${lists}`;
+    this.element = doc.createElement("div");
+    this.element.className = "ex-find-all";
+    this.#countLine = doc.createElement("div");
+    this.#countLine.className = "ex-find-all-count";
+    this.#countLine.setAttribute("role", "status");
+    const element = doc.createElement("div");
+    element.className = "ex-find-all-list";
+    element.setAttribute("role", "listbox");
+    element.setAttribute("aria-label", model.label);
+    element.tabIndex = 0;
+    element.setAttribute("data-ex-claims", "keydown click");
+    element.style.height = `${findAllVisibleLines * lineHeightPx}px`;
+    this.#spacer = doc.createElement("div");
+    this.#spacer.className = "ex-find-all-spacer";
+    element.append(this.#spacer);
+    element.addEventListener("scroll", () => {
+      if (element.scrollTop === this.#scrollTopPx) return;
+      this.#scrollTopPx = element.scrollTop;
+      this.refresh();
+    });
+    element.addEventListener("click", (event) => {
+      const line = event.target instanceof Element ? event.target.closest(".ex-find-all-line") : null;
+      if (!(line instanceof HTMLElement) || !element.contains(line)) return;
+      const index = Number(line.dataset["exIndex"]);
+      if (!Number.isInteger(index)) throw new Error("Internal: a Find All line without its index.");
+      model.answered();
+      model.choose(index);
+    });
+    element.addEventListener("keydown", (event) => {
+      if (event.ctrlKey || event.altKey || event.metaKey || event.isComposing) return;
+      const target = this.#keyTarget(event.key);
+      if (target === void 0) return;
+      event.preventDefault();
+      model.answered();
+      if (target >= 0) model.choose(target);
+    });
+    this.list = element;
+    this.element.append(this.#countLine, element);
+    this.refresh();
+  }
+  /** What the count line says: how many cells were found, or why the list went (ADR-0470 §5). */
+  say(text3) {
+    if (this.#countLine.textContent !== text3) this.#countLine.textContent = text3;
+  }
+  // The line a key moves to (ADR-0470 §4), read or not yet, -1 for a key the list takes that moves nowhere, or
+  // `undefined` for a key that is not the list's.
+  #keyTarget(key2) {
+    const count = this.#model.count();
+    if (!["ArrowDown", "ArrowUp", "Home", "End", "Enter", "PageDown", "PageUp"].includes(key2)) return void 0;
+    if (count === void 0 || count === 0) return -1;
+    const active = this.#model.active();
+    const last = count - 1;
+    switch (key2) {
+      case "ArrowDown":
+        return active === void 0 ? 0 : Math.min(last, active + 1);
+      case "ArrowUp":
+        return active === void 0 ? 0 : Math.max(0, active - 1);
+      case "PageDown":
+        return active === void 0 ? 0 : Math.min(last, active + findAllVisibleLines);
+      case "PageUp":
+        return active === void 0 ? 0 : Math.max(0, active - findAllVisibleLines);
+      case "Home":
+        return 0;
+      case "End":
+        return last;
+      default:
+        return active === void 0 ? -1 : active;
+    }
+  }
+  /** Draws the lines in view as the model now holds them, and brings the active line into view. */
+  refresh() {
+    const count = this.#model.count();
+    const lines = count === void 0 ? 0 : count;
+    this.#spacer.style.height = `${lines * this.#lineHeightPx}px`;
+    const active = this.#model.active();
+    if (active !== this.#revealed) {
+      this.#revealed = active;
+      if (active !== void 0 && active < lines) this.#reveal(active);
+    }
+    const first = Math.min(Math.max(0, lines - 1), Math.floor(this.#scrollTopPx / this.#lineHeightPx));
+    const last = Math.min(lines - 1, first + findAllVisibleLines);
+    for (const [index, line] of this.#drawn) {
+      if (index < first || index > last) {
+        line.remove();
+        this.#drawn.delete(index);
+      }
+    }
+    for (let index = first; index <= last; index++) this.#draw(index, index === active);
+    this.list.hidden = lines === 0;
+    if (active !== void 0 && active < lines) this.list.setAttribute("aria-activedescendant", `${this.#id}-${active}`);
+    else this.list.removeAttribute("aria-activedescendant");
+    if (lines > 0) this.#model.inView(first, last);
+  }
+  // The active line scrolled into view, as far as it must, as the grid reveals its Focus.
+  #reveal(index) {
+    const top = index * this.#lineHeightPx;
+    const room = findAllVisibleLines * this.#lineHeightPx;
+    let scrollTop = this.#scrollTopPx;
+    if (top < scrollTop) scrollTop = top;
+    else if (top + this.#lineHeightPx > scrollTop + room) scrollTop = top + this.#lineHeightPx - room;
+    if (scrollTop === this.#scrollTopPx) return;
+    this.#scrollTopPx = scrollTop;
+    this.list.scrollTop = scrollTop;
+  }
+  #draw(index, active) {
+    let line = this.#drawn.get(index);
+    if (line === void 0) {
+      line = this.#doc.createElement("div");
+      line.className = "ex-find-all-line";
+      line.id = `${this.#id}-${index}`;
+      line.setAttribute("role", "option");
+      line.dataset["exIndex"] = String(index);
+      line.style.top = `${index * this.#lineHeightPx}px`;
+      line.style.height = `${this.#lineHeightPx}px`;
+      const where2 = this.#doc.createElement("span");
+      where2.className = "ex-find-all-where";
+      const text4 = this.#doc.createElement("span");
+      text4.className = "ex-find-all-text";
+      line.append(where2, text4);
+      this.#spacer.append(line);
+      this.#drawn.set(index, line);
+    }
+    const read = this.#model.line(index);
+    const [where, text3] = [line.children[0], line.children[1]];
+    if (where === void 0 || text3 === void 0) throw new Error("Internal: a Find All line without its two parts.");
+    const whereText = read === void 0 ? "" : read.where;
+    const shownText = read === void 0 ? "" : read.text;
+    if (where.textContent !== whereText) where.textContent = whereText;
+    if (text3.textContent !== shownText) text3.textContent = shownText;
+    if (read === void 0) line.setAttribute("aria-busy", "true");
+    else line.removeAttribute("aria-busy");
+    line.setAttribute("aria-selected", active ? "true" : "false");
+    line.classList.toggle("ex-find-all-active", active);
+  }
+};
+
 // src/dom/grid-marks.ts
 var headerChecked = { none: "false", some: "mixed", all: "true" };
 var GridMarks = class {
@@ -11725,10 +12111,11 @@ function namesTheStartOfTheRow(action2) {
 // src/dom/selection-layers.ts
 var pieceOf = (className, style) => style === void 0 ? [] : [{ className, style }];
 var nothing2 = Object.freeze({ shade: void 0, pinned: Object.freeze([]), scrollable: Object.freeze([]) });
+var noBands = Object.freeze({ hoverRow: void 0, focusRow: false, focusColumn: false, rowCount: 0 });
 var noFill = Object.freeze({ outline: void 0, handle: void 0 });
 var noOutlines = Object.freeze({ references: Object.freeze([]), columns: Object.freeze([]), point: void 0, pointDashes: void 0 });
 var outlineClass = ([, colour]) => `ex-reference-outline ex-reference-${String(colour)}`;
-function selectionLayers(selection, copied2, columns, rowHeightPx, painted, cover, bands = { hoverRow: void 0, focusRow: false }, fill = noFill, outlines = noOutlines) {
+function selectionLayers(selection, copied2, columns, rowHeightPx, painted, cover, bands = noBands, fill = noFill, outlines = noOutlines) {
   const dashes2 = (pinnedLayer) => copied2.flatMap((range) => pieceOf("ex-copied-range", copied(range, columns, rowHeightPx, painted, pinnedLayer, cover)));
   const bandOf = (row) => ({ topRow: row, leftColumn: 0, rowCount: 1, columnCount: columns.count });
   const fillPieces = (pinnedLayer) => [
@@ -11744,12 +12131,24 @@ function selectionLayers(selection, copied2, columns, rowHeightPx, painted, cove
     // Point's outline is one more rectangle over them; the Selection and the Focus beneath it do not move.
     ...withReferences && outlines.point !== void 0 ? pieceOf(outlines.point.className, pinnedLayer ? pinned(outlines.point.range, columns, rowHeightPx, painted) : scrollable(outlines.point.range, columns, rowHeightPx, painted)) : [],
     // What a press outside the grid wrote for is dashed, Selection or none, cut at the boundary as a column is.
-    ...outlines.pointDashes === void 0 ? [] : pieceOf("ex-point-dashes", pinnedLayer ? pinned(outlines.pointDashes, columns, rowHeightPx, painted) : scrollable(outlines.pointDashes, columns, rowHeightPx, painted))
+    ...outlines.pointDashes === void 0 ? [] : pieceOf("ex-point-dashes", pinnedLayer ? pinned(outlines.pointDashes, columns, rowHeightPx, painted) : scrollable(outlines.pointDashes, columns, rowHeightPx, painted)),
+    // The grips last, over everything a layer holds, a later outline's over an earlier's (ADR-0480).
+    ...withReferences && outlines.grips !== void 0 ? gripPieces(outlines.grips, pinnedLayer) : []
   ];
+  const gripPieces = (grips, pinnedLayer) => grips.outlines.flatMap(({ outline, range, named: named3, colour }) => referenceGrips(range, columns, rowHeightPx, painted, pinnedLayer, grips.gripPx, grips.squarePx, pinnedLayer ? grips.pinnedLeftPx : grips.scrollableLeftPx, named3).map(({ kind, leftPx, topPx, widthPx, heightPx }) => ({
+    className: `ex-reference-grip ex-reference-grip-${kind}${gripResizes(kind) ? " ex-reference-square" : ""} ex-reference-${String(colour)}`,
+    style: `left: ${String(leftPx)}px; top: ${String(topPx)}px; width: ${String(widthPx)}px; height: ${String(heightPx)}px${gripResizes(kind) ? `; border-width: ${String(referenceSquareMarginPx)}px` : ""}`,
+    grip: { outline, kind, leftPx, topPx }
+  })));
   const focus = selection.focus;
+  const columnBandsOf = (at) => !bands.focusRow ? [selectionRange(0, at.column, bands.rowCount, 1)] : [
+    ...at.row > 0 ? [selectionRange(0, at.column, at.row, 1)] : [],
+    ...at.row + 1 < bands.rowCount ? [selectionRange(at.row + 1, at.column, bands.rowCount - at.row - 1, 1)] : []
+  ];
   const rowBands = columns.count === 0 ? [] : [
     ...bands.hoverRow === void 0 ? [] : [{ className: "ex-hover-row", range: bandOf(bands.hoverRow) }],
-    ...bands.focusRow && focus !== void 0 ? [{ className: "ex-focus-row", range: bandOf(focus.row) }] : []
+    ...bands.focusRow && focus !== void 0 ? [{ className: "ex-focus-row", range: bandOf(focus.row) }] : [],
+    ...bands.focusColumn && focus !== void 0 && bands.rowCount > 0 ? columnBandsOf(focus).map((range) => ({ className: "ex-focus-column", range })) : []
   ];
   const pinnedBands = rowBands.flatMap(({ className, range }) => pieceOf(className, pinned(range, columns, rowHeightPx, painted)));
   const scrollableBands = rowBands.flatMap(({ className, range }) => pieceOf(className, scrollable(range, columns, rowHeightPx, painted)));
@@ -12082,7 +12481,7 @@ function boxClass(status) {
 
 // src/dom/shipped-stylesheet.ts
 var stylesheetName = "ex-grid.css";
-var stylesheetStamp = "670feeb20f929018c24b2d39d2543ffa85fe4ea73b627ca17aa58cec983a3c8f";
+var stylesheetStamp = "63b729dd8e7c4d0d507d810eee14b23894982022d2efbaec94f42280fcca9d7b";
 
 // src/dom/cell-paint.ts
 var CellPaint = class _CellPaint {
@@ -13373,7 +13772,7 @@ function colourOfKey(keys, key2) {
 
 // src/dom/reference-outlines.ts
 function referenceOutlineOptions(given2) {
-  const { referencesIn, onReferenceKeyColoursChanged, outlinedColumns } = given2;
+  const { referencesIn, onReferenceKeyColoursChanged, outlinedColumns, moveReference } = given2;
   if (referencesIn !== void 0 && typeof referencesIn !== "function") {
     throw new TypeError("referencesIn is a function of the editor's text, answering its References (ADR-0057).");
   }
@@ -13383,11 +13782,15 @@ function referenceOutlineOptions(given2) {
   if (outlinedColumns !== void 0 && !Array.isArray(outlinedColumns)) {
     throw new TypeError("outlinedColumns is a list of columns, each named with its colour (ADR-0057).");
   }
+  if (moveReference !== void 0 && typeof moveReference !== "function") {
+    throw new TypeError("moveReference is a function of a Reference's text and the range it is to name (ADR-0480).");
+  }
   const asked = given2.outlinedColumns;
   return {
     referencesIn: given2.referencesIn,
     onReferenceKeyColoursChanged: given2.onReferenceKeyColoursChanged,
-    outlinedColumns: asked === void 0 ? void 0 : Object.freeze(asked.map(outlinedColumn))
+    outlinedColumns: asked === void 0 ? void 0 : Object.freeze(asked.map(outlinedColumn)),
+    moveReference: given2.moveReference
   };
 }
 function outlinedColumn(asked, i) {
@@ -13750,6 +14153,13 @@ var MatchMarks = class {
     return shown3 !== void 0 && this.rule === void 0 ? this.#matcher(shown3) : this.#judge(row, column);
   }
 };
+var findAllPageSize = 100;
+function isFindAllList(value) {
+  return typeof value === "object" && value !== null && "count" in value && typeof value.count === "number" && "line" in value && typeof value.line === "function" && "choose" in value && typeof value.choose === "function";
+}
+function isFindAllLine(value) {
+  return typeof value === "object" && value !== null && "where" in value && typeof value.where === "string" && "text" in value && typeof value.text === "string";
+}
 var userWriteCellsFollowed = 1024;
 var userWritesKept = 64;
 function checkedPointedAt(given2) {
@@ -13762,6 +14172,16 @@ function checkedPointedAt(given2) {
 function sameDashesAsked(was, now) {
   return was.dashes === now.dashes && was.columns === now.columns && was.window === now.window && was.windowStart === now.windowStart && was.start === now.start && was.count === now.count && was.totalRows === now.totalRows;
 }
+function oppositeCorner(range, kind) {
+  const top = kind === "bottomLeft" || kind === "bottomRight";
+  const left = kind === "topRight" || kind === "bottomRight";
+  return cell(top ? range.topRow : bottomRow(range), left ? range.leftColumn : rightColumn(range));
+}
+function edgeCellOf(range, kind, at) {
+  const row = kind === "top" ? range.topRow : kind === "bottom" ? bottomRow(range) : clamp(at.row, range.topRow, bottomRow(range));
+  const column = kind === "left" ? range.leftColumn : kind === "right" ? rightColumn(range) : clamp(at.column, range.leftColumn, rightColumn(range));
+  return cell(row, column);
+}
 function toneOf(column, value) {
   const tone = defined(column.tone, "a tone rule")(value);
   if (tone !== "none" && tone !== "positive" && tone !== "negative") {
@@ -13923,6 +14343,7 @@ var GridView = class {
   #handlePointer;
   #handleOutline;
   #highlightFocusRow = false;
+  #highlightFocusColumn = false;
   #highlightHoverRow = false;
   #stripeRows = false;
   // The pager (ADR-0015): the rows a page holds while one stands, and the page shown, transient view state as the
@@ -14185,6 +14606,8 @@ var GridView = class {
   #findHeld = { text: "", matchCase: false, wholeCell: false, replaceText: "" };
   #findOutcome = { kind: "none" };
   #findStepping;
+  // The list of the last Find All while it stands (ADR-0470).
+  #findAll;
   #replacing = 0;
   // A Pending Commit (ADR-0380 section 3), and the stamps given so far. `#input` is the last input the root heard
   // ahead of everything in it: while its dispatch is under way, it is the gesture a commit made in its handler
@@ -14239,7 +14662,12 @@ var GridView = class {
   #topRowOwed;
   #layerInputs;
   // The Reference Outline options (ADR-0057), and the colouring, columns and key colours they make.
-  #referenceOptions = { referencesIn: void 0, onReferenceKeyColoursChanged: void 0, outlinedColumns: void 0 };
+  #referenceOptions = {
+    referencesIn: void 0,
+    onReferenceKeyColoursChanged: void 0,
+    outlinedColumns: void 0,
+    moveReference: void 0
+  };
   #referenceOutlines = new ReferenceOutlines();
   // Point (ADR-0051): the options, and the pointing outline as a Focus and an Extent of its own, a one-range
   // selection moved by the transitions the Selection's own use; the span of the text its Reference occupies, and
@@ -14257,6 +14685,10 @@ var GridView = class {
   #pointLength = 0;
   #pointWritten;
   #pointDragging = false;
+  // A Reference Outline's grip drag (ADR-0480): what it was pressed on and against, and what it has reached. The
+  // grips as last drawn, each element with what it is, so a press on one is read without the layout.
+  #gripDrag;
+  #gripElements = /* @__PURE__ */ new WeakMap();
   // Whether what Point wrote was handed in from outside (ADR-0058): no outline stands over this grid's cells for
   // it, and F4 and the arrows change nothing while it stands. With it, the edit as it was before that write.
   #pointedFromOutside = false;
@@ -14903,10 +15335,13 @@ var GridView = class {
     const { showFillHandle, onFill } = options;
     if (showFillHandle !== void 0 && typeof showFillHandle !== "boolean") throw new TypeError("showFillHandle is true or false.");
     if (onFill !== void 0 && typeof onFill !== "function") throw new TypeError("onFill is a function of the fill's intent.");
-    const { highlightFocusRow, highlightHoverRow } = options;
+    const { highlightFocusRow, highlightFocusColumn, highlightHoverRow } = options;
     if (highlightFocusRow !== void 0 && typeof highlightFocusRow !== "boolean") {
       throw new TypeError("highlightFocusRow is true or false.");
     }
+    if (highlightFocusColumn !== void 0 && typeof highlightFocusColumn !== "boolean") {
+      throw new TypeError("highlightFocusColumn is true or false.");
+    }
     if (highlightHoverRow !== void 0 && typeof highlightHoverRow !== "boolean") {
       throw new TypeError("highlightHoverRow is true or false.");
     }
@@ -15102,6 +15537,7 @@ var GridView = class {
       showFillHandle: options.showFillHandle === true,
       onFill: options.onFill,
       highlightFocusRow: options.highlightFocusRow === true,
+      highlightFocusColumn: options.highlightFocusColumn === true,
       highlightHoverRow: (options.highlightHoverRow ?? options.presentationDefaults?.highlightHoverRow) === true,
       cellMessage: options.cellMessage,
       declaredKeys,
@@ -15318,6 +15754,7 @@ var GridView = class {
     this.#fillHeard = taken.onFill;
     if (!taken.showFillHandle && this.#handleDrag !== void 0) this.#setDragging(false);
     this.#highlightFocusRow = taken.highlightFocusRow;
+    this.#highlightFocusColumn = taken.highlightFocusColumn;
     if (taken.highlightHoverRow !== this.#highlightHoverRow) {
       this.#highlightHoverRow = taken.highlightHoverRow;
       if (taken.highlightHoverRow) {
@@ -15907,6 +16344,10 @@ var GridView = class {
       this.#taken(event);
       return;
     }
+    if (escape && !event.repeat && this.#gripDrag !== void 0 && this.#cancelGripDrag()) {
+      this.#taken(event);
+      return;
+    }
     if (popover !== void 0 && escape && (onGrid || inPopover) && !innerPopupOpen(popover)) {
       this.#taken(event);
       this.#closePopover(true);
@@ -16392,12 +16833,20 @@ var GridView = class {
     }
     this.#pressHandedOver = false;
     this.#secondaryPress = event.target === this.#viewport && (event.button === 2 || event.button === 0 && event.ctrlKey) ? { at: this.#cellUnder(event), leftPx: event.offsetX - this.#scrollLeftPx, topPx: this.#viewportYOf(event) } : void 0;
-    if (event.button !== 0 || event.target !== this.#viewport) return;
-    const grabbed = event.shiftKey || event.ctrlKey || event.metaKey ? void 0 : this.#fillHandleUnder(event);
+    const grip = event.button === 0 && event.target instanceof Element ? this.#gripElements.get(event.target) : void 0;
+    if (event.button !== 0 || grip === void 0 && event.target !== this.#viewport) return;
+    const modified = event.shiftKey || event.ctrlKey || event.metaKey || event.altKey;
+    if (grip !== void 0 && !modified && this.#pressGrip(grip.grip, this.#cellAtGrip(event, grip, true))) {
+      this.#answered += 1;
+      event.preventDefault();
+      this.#invalidate();
+      return;
+    }
+    const grabbed = grip !== void 0 || event.shiftKey || event.ctrlKey || event.metaKey ? void 0 : this.#fillHandleUnder(event);
     this.#reconcileSelection();
-    const at = this.#cellUnder(event);
+    const at = grip === void 0 ? this.#cellUnder(event) : this.#cellAtGrip(event, grip);
     if (at === void 0) return;
-    if (this.#inRowHeadings(event)) {
+    if (grip === void 0 && this.#inRowHeadings(event)) {
       this.#pressRowHeading(event, at.row);
       return;
     }
@@ -16441,6 +16890,12 @@ var GridView = class {
     if (event.target !== this.#viewport) return;
     const at = this.#cellUnder(event);
     if (at === void 0) return;
+    if (this.#gripDrag !== void 0) {
+      this.#moveGripDrag(at);
+      const gripY = this.#viewportYOf(event);
+      if (gripY !== void 0) this.#updateEdgeBand(event.offsetX - this.#scrollLeftPx, gripY);
+      return;
+    }
     if (this.#pointDragging) {
       this.#pointDrag(at);
       return;
@@ -16463,6 +16918,10 @@ var GridView = class {
   // would hear every drag (ADR-0018).
   #onDragEnd = (event) => {
     if (this.#headingDrag && this.#headingHears(event)) this.#moveHeadingDrag(event);
+    if (this.#gripDrag !== void 0 && event.target === this.#viewport) {
+      const at = this.#cellUnder(event);
+      if (at !== void 0) this.#moveGripDrag(at);
+    }
     if (this.#handleDrag !== void 0) {
       this.#finishHandleDrag(event.target === this.#viewport ? this.#cellUnder(event) : void 0);
       return;
@@ -17971,7 +18430,7 @@ var GridView = class {
     const edit = this.#edit;
     if (edit === void 0) return;
     this.#edit = void 0;
-    if (this.#endPointing()) this.#setDragging(false);
+    if (this.#endPointing() || this.#gripDrag !== void 0) this.#setDragging(false);
     this.#closeCompletion();
     this.#completionSeen = void 0;
     this.#tellPointState();
@@ -18199,6 +18658,185 @@ var GridView = class {
     this.#pointer = pointer.extendTo(at, this.#extent);
     this.#writePointedReference(edit, false);
   }
+  // ---- Dragging a Reference Outline (ADR-0480) ---------------------------------------------------------------
+  // Whether the open edit's outlines carry grips: a Reference can be dragged while an edit is open whose References
+  // the Consumer answers and rewrites, its commit not waiting on a verdict, and pointed at from outside by no one.
+  #gripsShown() {
+    const { referencesIn, moveReference } = this.#referenceOptions;
+    return this.#edit !== void 0 && referencesIn !== void 0 && moveReference !== void 0 && this.#pending === void 0 && !this.#pointedAtNow();
+  }
+  // The outlines that carry grips, by their place among the colouring's outlines, as they are drawn on the grid.
+  #gripPaint(colouring, rowCount, columnCount) {
+    const visible = this.#visible;
+    const geometry = this.#geometry;
+    if (visible === void 0 || geometry === void 0) return void 0;
+    const outlines = colouring.outlines.flatMap(([range, colour], outline) => {
+      const drawn = withinExtent(range, { rowCount, columnCount });
+      return drawn === void 0 ? [] : [{ outline, range: drawn, named: range, colour }];
+    });
+    if (outlines.length === 0) return void 0;
+    const readable = this.#readableEdge(visible, geometry);
+    return {
+      outlines,
+      gripPx: this.#metrics.referenceGripPx,
+      squarePx: this.#metrics.referenceHandleSizePx,
+      pinnedLeftPx: this.#styles.geometry.leadWidthPx,
+      scrollableLeftPx: readable.leftPx
+    };
+  }
+  // The cell under a press on a grip, from where the grip was drawn and the press's offset inside it: a pinned
+  // layer's coordinates are the Viewport's less the scroll offset, as it is held against the Viewport's left edge.
+  // `along` reads an edge's strip only along its edge: across it, half the strip lies outside the range, past the
+  // last row or column where the range ends there, and the drag holds the edge's own row or column (edgeCellOf),
+  // so the axis across is not read and is answered as 0.
+  #cellAtGrip(event, drawn, along = false) {
+    const geometry = this.#geometry;
+    const visible = this.#visible;
+    if (geometry === void 0 || visible === void 0) return void 0;
+    const x = drawn.grip.leftPx + event.offsetX + (drawn.pinned ? this.#scrollLeftPx : 0);
+    const row = geometry.rowAt(drawn.grip.topPx + event.offsetY + geometry.offsetPxOf(visible.start));
+    const column = this.#styles.geometry.columnAt(x, this.#scrollLeftPx);
+    const { kind } = drawn.grip;
+    if (along && (kind === "left" || kind === "right")) return row === void 0 ? void 0 : cell(row, 0);
+    if (along && (kind === "top" || kind === "bottom")) return column === void 0 ? void 0 : cell(0, column);
+    return row === void 0 || column === void 0 ? void 0 : cell(row, column);
+  }
+  /**
+   * A press on a grip (ADR-0480, section 3): an edge holds the cell of the range nearest the press, a square the
+   * opposite corner, and the drag begins; the text is not touched until the range reached changes. Taken against
+   * the colouring the grips were drawn for: an outline gone, or text changed since, refuses the press, which does
+   * nothing. Whether the press was the grip's.
+   */
+  #pressGrip(grip, at) {
+    const edit = this.#edit;
+    const moveReference = this.#referenceOptions.moveReference;
+    if (edit === void 0 || moveReference === void 0 || !this.#gripsShown()) return false;
+    const text3 = this.#editorText(edit);
+    const colouring = this.#referenceOutlines.asked;
+    const named3 = colouring.references.filter((reference) => reference.range !== void 0)[grip.outline];
+    const from = colouring.outlines[grip.outline]?.[0];
+    const resizes = gripResizes(grip.kind);
+    if (this.#referenceOutlines.askedFor !== text3 || named3 === void 0 || from === void 0 || withinExtent(from, this.#extent) === void 0 || !resizes && at === void 0) return true;
+    const surface = this.#surfaceOf(edit);
+    const held2 = resizes ? oppositeCorner(from, grip.kind) : edgeCellOf(from, grip.kind, defined(at, "the cell an edge was pressed on"));
+    this.#gripDrag = {
+      edit,
+      resizes,
+      from,
+      held: held2,
+      start: named3.start,
+      length: named3.length,
+      written: text3,
+      reached: from,
+      before: {
+        text: text3,
+        selectionStart: surface?.selectionStart ?? -1,
+        selectionEnd: surface?.selectionEnd ?? -1,
+        // oxlint-disable-line ex-grid/no-stand-in-default -- ADR-0480: a caret not known is put back as not known
+        mode: edit.mode,
+        pointer: this.#pointer,
+        pointStart: this.#pointStart,
+        pointLength: this.#pointLength,
+        pointWritten: this.#pointWritten
+      }
+    };
+    this.#root.setAttribute("data-ex-reference-drag", gripCursor(grip.kind));
+    this.#setDragging(true);
+    if (surface !== void 0 && this.#root.ownerDocument.activeElement !== surface) surface.focus({ preventScroll: true });
+    return true;
+  }
+  /**
+   * The drag reached `at` (ADR-0480, section 3): a move takes the range by as many rows and columns as `at` lies
+   * from the cell held, kept inside the grid, or where it reached past the grid when pressed, no further past it
+   * than it was; a resize spans the held corner and `at`. Where the range reached
+   * changed, the Reference is rewritten in place by the Consumer's answer, the caret and Point's span moved with the
+   * text around them. Text changed meanwhile by anything but the drag ends it: the span it holds is no longer the
+   * Reference's. Whether anything changed.
+   */
+  #moveGripDrag(at) {
+    const drag = this.#gripDrag;
+    const edit = this.#edit;
+    const moveReference = this.#referenceOptions.moveReference;
+    if (drag === void 0) return false;
+    if (edit === void 0 || edit !== drag.edit || moveReference === void 0 || this.#editorText(edit) !== drag.written) {
+      this.#setDragging(false);
+      return false;
+    }
+    const extent = this.#extent;
+    const { from, held: held2 } = drag;
+    const reached = drag.resizes ? fromCorners(held2, at) : selectionRange(
+      clamp(from.topRow + at.row - held2.row, 0, Math.max(extent.rowCount - from.rowCount, from.topRow)),
+      clamp(from.leftColumn + at.column - held2.column, 0, Math.max(extent.columnCount - from.columnCount, from.leftColumn)),
+      from.rowCount,
+      from.columnCount
+    );
+    if (sameRange(reached, drag.reached)) return false;
+    const answer = moveReference(drag.written.slice(drag.start, drag.start + drag.length), reached);
+    if (typeof answer !== "string" || answer === "") {
+      throw new TypeError("moveReference answered no text for a dragged Reference: a Reference is a non-empty string (ADR-0480).");
+    }
+    const [text3] = replaceSpan(drag.written, drag.start, drag.length, answer);
+    const end = drag.start + drag.length;
+    const delta = answer.length - drag.length;
+    const moved = (place) => place < 0 || place <= drag.start ? place : place >= end ? place + delta : drag.start + answer.length;
+    const surface = this.#surfaceOf(edit);
+    const selectionStart = moved(surface?.selectionStart ?? -1);
+    const selectionEnd = moved(surface?.selectionEnd ?? -1);
+    if (this.#pointWritten !== void 0 && this.#pointingContinues(edit)) {
+      if (this.#pointStart === drag.start && this.#pointer !== void 0) {
+        this.#pointLength = answer.length;
+        this.#pointer = Selection.empty.click(cell(reached.topRow, reached.leftColumn), extent).extendTo(cell(bottomRow(reached), rightColumn(reached)), extent);
+      } else if (this.#pointStart >= end) {
+        this.#pointStart += delta;
+      }
+      this.#pointWritten = text3;
+    }
+    this.#writeEditorText(edit, text3);
+    if (this.#formulaBarDeclared.shown) this.#bar.showText(text3);
+    if (surface !== void 0 && selectionStart >= 0) surface.setSelectionRange(selectionStart, Math.max(selectionStart, selectionEnd));
+    drag.length = answer.length;
+    drag.written = text3;
+    drag.reached = reached;
+    this.#closeCompletion();
+    this.#askReferences();
+    this.#tellPointState();
+    this.#invalidate();
+    return true;
+  }
+  // Escape mid-drag (ADR-0480, section 6): the edit as the press found it, its text, caret, mode and pointing, and
+  // the drag over. The edit stays open. Text typed since the drag last wrote has ended the drag already, as the
+  // next move would find (#moveGripDrag): the drag is over, nothing is put back, and the Escape is not the drag's.
+  // Whether the Escape was the drag's.
+  #cancelGripDrag() {
+    const drag = this.#gripDrag;
+    const edit = this.#edit;
+    this.#setDragging(false);
+    if (drag === void 0 || edit === void 0 || edit !== drag.edit || this.#editorText(edit) !== drag.written) return false;
+    const { before } = drag;
+    if (this.#editorText(edit) !== before.text) {
+      this.#writeEditorText(edit, before.text);
+      if (this.#formulaBarDeclared.shown) this.#bar.showText(before.text);
+      const surface = this.#surfaceOf(edit);
+      if (surface !== void 0 && before.selectionStart >= 0) surface.setSelectionRange(before.selectionStart, before.selectionEnd);
+    }
+    edit.mode = before.mode;
+    if (before.pointWritten !== void 0) {
+      this.#pointer = before.pointer;
+      this.#pointStart = before.pointStart;
+      this.#pointLength = before.pointLength;
+      this.#pointWritten = before.pointWritten;
+    }
+    this.#askReferences();
+    this.#tellPointState();
+    this.#invalidate();
+    return true;
+  }
+  // The drag is over, wherever it reached: the root's cursor and the grips' pointer events come back.
+  #endGripDrag() {
+    if (this.#gripDrag === void 0) return;
+    this.#gripDrag = void 0;
+    this.#root.removeAttribute("data-ex-reference-drag");
+  }
   // F2 moves between the states (ADR-0010), and where pointing is declared between Caret and Point: from Caret it
   // points where the Consumer says a Reference can go at the caret, and from Point it moves the caret again, the
   // outline gone and its Reference left written (ADR-0051).
@@ -19601,6 +20239,7 @@ var GridView = class {
     if (popover.kind === "find") {
       this.#findStepping?.abort();
       this.#findStepping = void 0;
+      this.#dropFindAll();
     }
     const active = doc.activeElement;
     const ours = active === null || active === doc.body || active === doc.documentElement || this.#root.contains(active);
@@ -19980,7 +20619,17 @@ var GridView = class {
       replaceAll: () => {
         this.#replaceAll();
       },
+      findAll: () => {
+        this.#findAllStart();
+      },
+      listFindAll: (list) => {
+        this.#findAllOwn(list);
+      },
+      dropFindAll: () => {
+        this.#dropFindAll();
+      },
       heldChanged: () => {
+        this.#findAllHeldChanged();
         this.#invalidate();
       },
       answered: this.#answer
@@ -20543,6 +21192,7 @@ var GridView = class {
       return;
     }
     this.#askSummaryAgain();
+    this.#dropFindAll();
     this.#setFindOutcome({ kind: "replaced", count: result.count });
   }
   // A Replace that wrote nothing (ADR-0332 §2): the panel names the cells and why, and the Consumer is told.
@@ -20550,6 +21200,395 @@ var GridView = class {
     this.#setFindOutcome({ kind: "replaceRefused", cells });
     this.#onRefused?.({ kind: "find", reason: "replaceRefused" });
   }
+  // ---- Find All (ADR-0470) -----------------------------------------------------------------------------------
+  // Whether Find All can be asked (ADR-0470 §1): the source lists every match beside finding the next.
+  get #canFindAll() {
+    return this.#source.find !== void 0 && this.#source.findAll !== void 0;
+  }
+  /**
+   * Find All (ADR-0470): the list of every match, asked of the source a page at a time under the version its
+   * positions are read in, with the headers the grid searches itself listed first (ADR-0333). Its first page is an
+   * answer out, as a step's is: the inputs made meanwhile wait for it, and an Escape cancels it (ADR-0451 section 3).
+   * The Focus does not move: the list is the whole set, and a line chosen from it moves the Focus there.
+   */
+  #findAllStart() {
+    if (this.#stepInTurn(() => {
+      this.#findAllStart();
+    })) return;
+    const popover = this.#popover;
+    const source = this.#source;
+    if (popover?.kind !== "find" || this.#findHeld.text === "" || !this.#canFindAll) return;
+    this.#dropFindAll();
+    this.#reconcileSelection();
+    const selection = this.#held.selection;
+    const scope = !selection.isEmpty && selection.cellCount > 1 ? selection.ranges : void 0;
+    const pattern = this.#findPattern();
+    const headers = scope === void 0 ? this.#findHeaders() : [];
+    const request = Object.freeze({
+      ...pattern,
+      scope,
+      columns: Object.freeze(this.#columns.map(({ column }) => column.name)),
+      rowSequenceVersion: this.#state.rowSequenceVersion
+    });
+    const list = {
+      source,
+      sequence: this.#sequence(),
+      request,
+      columnCount: request.columns.length,
+      headers: matchingHeaders(headers, pattern).map((index) => itemAt(headers, index)),
+      rowTotal: void 0,
+      pages: /* @__PURE__ */ new Map(),
+      asking: /* @__PURE__ */ new Map(),
+      active: void 0,
+      activeFor: void 0,
+      view: void 0,
+      gone: void 0,
+      part: void 0,
+      own: void 0
+    };
+    this.#showFindAll(popover.panel, list);
+    this.#askFindAllPage(list, 0, "first");
+  }
+  /**
+   * Find All with a list the find panel slot's contents hold themselves (ADR-0470 §7), as ExSheet's over its
+   * Workbook: asked in its turn, drawn as the grid's own list is, its count and lines the contents', a choice taken in
+   * its turn and handed back to them. It goes when the text or an option changes or the panel closes, never with the
+   * order: what the contents list is theirs to drop.
+   */
+  #findAllOwn(made4) {
+    if (this.#stepInTurn(() => {
+      this.#findAllOwn(made4);
+    })) return;
+    const popover = this.#popover;
+    if (popover?.kind !== "find" || this.#findHeld.text === "") return;
+    this.#dropFindAll();
+    const listed2 = made4();
+    if (!isFindAllList(listed2)) throw new TypeError("listFindAll's function answers a list: { count, line, choose } (ADR-0470 \xA77).");
+    if (!Number.isInteger(listed2.count) || listed2.count < 0) {
+      throw new RangeError(`listFindAll's list holds ${String(listed2.count)} lines: a count is a whole number from 0 (ADR-0470 \xA77).`);
+    }
+    const request = Object.freeze({
+      ...this.#findPattern(),
+      columns: Object.freeze(this.#columns.map(({ column }) => column.name)),
+      rowSequenceVersion: this.#state.rowSequenceVersion
+    });
+    const list = {
+      source: this.#source,
+      sequence: this.#sequence(),
+      request,
+      columnCount: request.columns.length,
+      headers: [],
+      rowTotal: listed2.count,
+      pages: /* @__PURE__ */ new Map(),
+      asking: /* @__PURE__ */ new Map(),
+      active: void 0,
+      activeFor: void 0,
+      view: void 0,
+      gone: void 0,
+      part: void 0,
+      own: listed2
+    };
+    this.#showFindAll(popover.panel, list);
+    this.#invalidate();
+  }
+  // The list's part, made and placed under the panel's contents.
+  #showFindAll(panel, list) {
+    this.#findAll = list;
+    const part2 = new FindAllList(this.#root.ownerDocument, {
+      count: () => this.#findAllCount(list),
+      line: (index) => this.#findAllLine(list, index),
+      active: () => list.active,
+      inView: (first, last) => {
+        this.#findAllInView(list, first, last);
+      },
+      choose: (index) => {
+        this.#findAllChoose(list, index);
+      },
+      answered: this.#answer,
+      label: this.#labelOf(findPanelLabelIds.findAllList)
+    }, this.#metrics.rowHeightPx);
+    list.part = part2;
+    panel.showFindAll(part2.element);
+    this.#sayFindAll(list);
+  }
+  // The lines the list holds: the headers matched and every row's match, none once it has gone, or `undefined`
+  // while the first page is out.
+  #findAllCount(list) {
+    if (list.gone !== void 0) return 0;
+    if (list.own !== void 0) return list.own.count;
+    return list.rowTotal === void 0 ? void 0 : list.headers.length + list.rowTotal;
+  }
+  // Line `index` in the grid's words (ADR-0470 §3), or `undefined` while its page is not read.
+  #findAllLine(list, index) {
+    if (list.own !== void 0) {
+      const line = list.own.line(index);
+      if (!isFindAllLine(line)) throw new TypeError(`listFindAll's list answered line ${String(index)} as something other than { where, text } (ADR-0470 \xA77).`);
+      return line;
+    }
+    const header = list.headers[index];
+    if (header !== void 0) {
+      return { where: filledWords(this.#labelOf(findPanelLabelIds.findAllInHeader), { column: header.text }), text: header.text };
+    }
+    const match = this.#findAllMatchAt(list, index - list.headers.length);
+    if (match === void 0) return void 0;
+    const resolved = this.#columns.find(({ column: column2 }) => column2.name === match.column);
+    const column = resolved === void 0 ? match.column : headerOf(resolved);
+    const where = match.rowLabel === void 0 ? filledWords(this.#labelOf(findPanelLabelIds.findAllInRow), { row: String(match.row + 1), column }) : filledWords(this.#labelOf(findPanelLabelIds.findAllInLabelledRow), { row: match.rowLabel, column });
+    return { where, text: match.text };
+  }
+  // The row match at `at` among the rows' matches, where its page has been read.
+  #findAllMatchAt(list, at) {
+    if (at < 0) return void 0;
+    return list.pages.get(Math.floor(at / findAllPageSize))?.[at % findAllPageSize];
+  }
+  // What the count line says (ADR-0470 §3, §5).
+  #sayFindAll(list) {
+    const count = this.#findAllCount(list);
+    const text3 = list.gone !== void 0 ? this.#labelOf(list.gone === "orderChanged" ? findPanelLabelIds.orderChanged : findPanelLabelIds.sourceChanged) : count === void 0 ? "" : count === 0 ? this.#labelOf(findPanelLabelIds.findAllNone) : count === 1 ? this.#labelOf(findPanelLabelIds.findAllFoundOne) : filledWords(this.#labelOf(findPanelLabelIds.findAllFound), { count: String(count) });
+    list.part?.say(text3);
+  }
+  // The list's lines from `first` to `last` are in view: their pages are asked, and the next one ahead, one at a time
+  // (ADR-0470 §2): a page asked while another is out waits for it.
+  #findAllInView(list, first, last) {
+    list.view = { first, last };
+    if (this.#findAll !== list || list.own !== void 0 || list.gone !== void 0 || list.rowTotal === void 0 || list.asking.size > 0) return;
+    const rows = list.rowTotal;
+    const from = Math.max(0, first - list.headers.length);
+    const to = Math.min(rows - 1, last - list.headers.length + findAllVisibleLines);
+    for (let page = Math.floor(from / findAllPageSize); page <= Math.floor(to / findAllPageSize); page++) {
+      if (!list.pages.has(page)) {
+        this.#askFindAllPage(list, page, void 0);
+        return;
+      }
+    }
+  }
+  /**
+   * One page of the list asked of the source. The first, and one a choice waits on, is an answer out in the Input
+   * Order (ADR-0451 section 3): the inputs made meanwhile wait for it, and an Escape cancels it. `then` runs once it
+   * has landed, before those inputs.
+   */
+  #askFindAllPage(list, page, pended, then) {
+    const { source } = list;
+    const controller = new AbortController();
+    list.asking.set(page, controller);
+    const request = Object.freeze({ ...list.request, start: page * findAllPageSize, count: findAllPageSize });
+    if (pended !== void 0) this.#invalidate();
+    const asked = Promise.resolve().then(() => {
+      if (source.findAll === void 0) throw new Error("Internal: a Find All page asked of a source that lists nothing.");
+      return source.findAll(request, controller.signal);
+    });
+    const next2 = () => {
+      const { view } = list;
+      if (this.#findAll === list && list.gone === void 0 && view !== void 0) this.#findAllInView(list, view.first, view.last);
+    };
+    const landed = asked.then((answer) => {
+      if (this.#destroyed || list.asking.get(page) !== controller) return;
+      list.asking.delete(page);
+      if (pended !== void 0) this.#invalidate();
+      if (this.#findAll === list && list.gone === void 0) this.#findAllAnswered(list, page, request, answer);
+      then?.();
+      next2();
+    }, (error) => {
+      if (this.#destroyed || list.asking.get(page) !== controller) return;
+      list.asking.delete(page);
+      if (pended !== void 0) this.#invalidate();
+      if (error instanceof DOMException && error.name === "AbortError") {
+        if (pended === "first" && this.#findAll === list) this.#dropFindAll();
+        else next2();
+        return;
+      }
+      throw error;
+    });
+    if (pended === void 0) return;
+    this.#pendStep(landed, controller, () => {
+      if (list.asking.get(page) !== controller) return;
+      list.asking.delete(page);
+      if (pended === "first" && this.#findAll === list) this.#dropFindAll();
+      this.#invalidate();
+    });
+  }
+  // A page's answer, judged against what it was asked under (ADR-0470 §2).
+  #findAllAnswered(list, page, request, answer) {
+    const given2 = answer;
+    if (typeof given2 !== "object" || given2 === null || !Array.isArray(given2.matches) || typeof given2.total !== "number" || typeof given2.rowSequenceVersion !== "number") {
+      throw new TypeError("The source's findAll answered something other than a Find All page: { total, matches, rowSequenceVersion }, as findAllPage makes one (ADR-0470).");
+    }
+    if (list.source !== this.#source) {
+      this.#findAllGone(list, "sourceChanged");
+      return;
+    }
+    if (answer.rowSequenceVersion !== request.rowSequenceVersion || list.sequence !== this.#sequence()) {
+      this.#findAllGone(list, "orderChanged");
+      return;
+    }
+    const { total, matches: matches3 } = answer;
+    if (!Number.isInteger(total) || total < 0) throw new RangeError(`The Find All answer counts ${total} matches: a count is a whole number from 0 (ADR-0470).`);
+    if (list.rowTotal !== void 0 && total !== list.rowTotal) {
+      this.#findAllGone(list, "orderChanged");
+      return;
+    }
+    const owed = Math.max(0, Math.min(request.count, total - request.start));
+    if (matches3.length !== owed) {
+      throw new RangeError(`The Find All answer holds ${matches3.length} matches for the entries ${request.start} on of a list of ${total}: it owes ${owed} (ADR-0470 \xA72).`);
+    }
+    let before = -1;
+    for (const match of matches3) {
+      const column = request.columns.indexOf(match.column);
+      const ordinal2 = match.row * list.columnCount + column;
+      if (column < 0 || !Number.isInteger(match.row) || match.row < 0 || match.row >= this.#totalRows || typeof match.text !== "string" || match.rowLabel !== void 0 && typeof match.rowLabel !== "string" || request.scope !== void 0 && !inScope(request.scope, match.row, column) || ordinal2 <= before) {
+        throw new RangeError(`The Find All answer names row ${match.row}, column '${match.column}', outside the request or out of its order: it asked about the columns [${request.columns.join(", ")}] of a result of ${this.#totalRows} rows, by rows (ADR-0470 \xA72).`);
+      }
+      before = ordinal2;
+    }
+    list.rowTotal = total;
+    list.pages.set(page, matches3);
+    this.#sayFindAll(list);
+    list.part?.refresh();
+  }
+  /**
+   * A line chosen from the list (ADR-0470 §4): the Focus moves to its cell and reveals it, as a step that found it
+   * does, or a header becomes the current match. Taken in its turn, against what the list was read under: under
+   * another version or source, the list goes and says so, and nothing moves. A line whose page is not yet read, as
+   * End's in a long list, waits for its page as an answer out, and is chosen once it is in.
+   */
+  #findAllChoose(list, index) {
+    if (this.#stepInTurn(() => {
+      this.#findAllChoose(list, index);
+    })) return;
+    this.#findAllChooseNow(list, index, true);
+  }
+  #findAllChooseNow(list, index, mayAsk) {
+    if (this.#findAll !== list || list.gone !== void 0) return;
+    if (list.own !== void 0) {
+      if (index < 0 || index >= list.own.count) return;
+      const moved = list.own.choose(index);
+      if (typeof moved !== "boolean") throw new TypeError(`listFindAll's choose answers whether it moved, not ${typeof moved} (ADR-0470 \xA77).`);
+      if (moved && this.#findAll === list) {
+        list.active = index;
+        list.activeFor = this.#findCurrent ?? this.#findCurrentHeader;
+      }
+      if (this.#findAll === list) list.part?.refresh();
+      this.#invalidate();
+      return;
+    }
+    if (list.source !== this.#source) {
+      this.#findAllGone(list, "sourceChanged");
+      return;
+    }
+    if (list.sequence !== this.#sequence()) {
+      this.#findAllGone(list, "orderChanged");
+      return;
+    }
+    const header = list.headers[index];
+    const match = header === void 0 ? this.#findAllMatchAt(list, index - list.headers.length) : void 0;
+    if (header === void 0 && match === void 0) {
+      const count = this.#findAllCount(list);
+      if (!mayAsk || count === void 0 || index < list.headers.length || index >= count) return;
+      for (const controller of list.asking.values()) controller.abort();
+      list.asking.clear();
+      this.#askFindAllPage(list, Math.floor((index - list.headers.length) / findAllPageSize), "choice", () => {
+        this.#findAllChooseNow(list, index, false);
+      });
+      return;
+    }
+    this.#findStepping?.abort();
+    this.#findStepping = void 0;
+    this.#reconcileSelection();
+    if (header !== void 0) {
+      const now = this.#findHeaders().find(({ id }) => id === header.id);
+      if (now === void 0) {
+        this.#findAllGone(list, "orderChanged");
+        return;
+      }
+      list.active = index;
+      this.#landOnHeader(now);
+      list.activeFor = this.#findCurrentHeader;
+    } else if (match !== void 0) {
+      const column = this.#columns.findIndex(({ column: declared }) => declared.name === match.column);
+      if (column < 0) {
+        this.#findAllGone(list, "orderChanged");
+        return;
+      }
+      list.active = index;
+      const found = cell(match.row, column);
+      this.#findCurrent = { cell: found, version: this.#sequence() };
+      list.activeFor = this.#findCurrent;
+      this.#findCurrentHeader = void 0;
+      this.#setFindOutcome({ kind: "found" });
+      const held2 = this.#held.selection;
+      this.#apply(list.request.scope !== void 0 && held2.cellCount > 1 && held2.contains(found) ? held2.focusOn(found) : held2.click(found, this.#extent));
+      this.#revealOwed = { target: found, extending: void 0, rowStart: false, stepRows: 0 };
+      this.#revealHeaderOwed = void 0;
+      this.#followArmed = { focus: found, target: found };
+    }
+    list.part?.refresh();
+    this.#invalidate();
+  }
+  // In each pass: the list's current line follows the current match, which a step, a Replace or a placed match may
+  // have moved since the line was chosen (ADR-0470 §4): the line of the new one where its page is read, else none.
+  // A list of the Chrome's own keeps the line it chose: what its contents' current match is, the contents know.
+  #findAllFollowCurrent() {
+    const list = this.#findAll;
+    if (list === void 0 || list.own !== void 0 || list.gone !== void 0) return;
+    const current = this.#findCurrent ?? this.#findCurrentHeader;
+    if (current === list.activeFor) return;
+    list.activeFor = current;
+    list.active = this.#findAllLineOf(list);
+    list.part?.refresh();
+  }
+  // The line the current match stands on among what the list has read, or none.
+  #findAllLineOf(list) {
+    const header = this.#findCurrentHeader;
+    if (header !== void 0) {
+      const at = list.headers.findIndex(({ id }) => id === header.id);
+      return at < 0 ? void 0 : at;
+    }
+    const current = this.#findCurrent;
+    if (current === void 0 || current.version !== list.sequence) return void 0;
+    const column = this.#columns[current.cell.column]?.column.name;
+    for (const [page, matches3] of list.pages) {
+      const at = matches3.findIndex((match) => match.row === current.cell.row && match.column === column);
+      if (at >= 0) return list.headers.length + page * findAllPageSize + at;
+    }
+    return void 0;
+  }
+  // The list read under another order or from another source (ADR-0470 §5): its lines go, the count line says why,
+  // and nothing is asked again.
+  #findAllGone(list, reason) {
+    if (list.gone !== void 0) return;
+    list.gone = reason;
+    for (const controller of list.asking.values()) controller.abort();
+    list.asking.clear();
+    list.pages.clear();
+    list.active = void 0;
+    this.#sayFindAll(list);
+    list.part?.refresh();
+  }
+  // The list taken away (ADR-0470 §5): a new Find All, a new search, the panel closed, a Replace All.
+  #dropFindAll() {
+    const list = this.#findAll;
+    if (list === void 0) return;
+    this.#findAll = void 0;
+    for (const controller of list.asking.values()) controller.abort();
+    list.asking.clear();
+    const popover = this.#popover;
+    if (popover?.kind === "find") popover.panel.showFindAll(void 0);
+    else list.part?.element.remove();
+  }
+  // In each pass: a list whose order or source has moved since it was read goes (ADR-0470 §5).
+  #forgetFindAllOffSequence() {
+    const list = this.#findAll;
+    if (list === void 0 || list.own !== void 0 || list.gone !== void 0) return;
+    if (list.source !== this.#source) this.#findAllGone(list, "sourceChanged");
+    else if (list.sequence !== this.#sequence()) this.#findAllGone(list, "orderChanged");
+  }
+  // The search the panel holds changed: a list of another search goes, so it never lists what the field no longer asks.
+  #findAllHeldChanged() {
+    const list = this.#findAll;
+    if (list === void 0) return;
+    const { text: text3, matchCase, wholeCell } = this.#findHeld;
+    if (list.request.text !== text3 || list.request.matchCase !== matchCase || list.request.wholeCell !== wholeCell) this.#dropFindAll();
+  }
   // ---- The clipboard (ADR-0005) ------------------------------------------------------------------------
   // A copy the browser's command asked for. Refused, the clipboard stays as it was: the default copy of a
   // user-select: none root carries nothing, so the event is left alone. Approved, a Selection the Window
@@ -21070,6 +22109,7 @@ var GridView = class {
     if (!dragging) {
       this.#forgetHeadingDrag();
       this.#endHandleDrag();
+      this.#endGripDrag();
       this.#pointDragging = false;
       this.#pointedDrag = void 0;
     }
@@ -21694,7 +22734,7 @@ var GridView = class {
     if (row !== void 0 && column !== void 0) {
       const extent = this.#extent;
       const current = this.#held.selection;
-      changed = this.#handleDrag !== void 0 ? this.#moveHandlePointer(cell(row, column)) : this.#apply(!this.#headingDrag ? current.extendTo(cell(row, column), extent) : this.#headingAxis === "rows" ? current.extendToRow(row, extent, this.#firstVisibleColumn) : current.extendToColumn(column, extent, this.#firstVisibleRow));
+      changed = this.#gripDrag !== void 0 ? this.#moveGripDrag(cell(row, column)) : this.#handleDrag !== void 0 ? this.#moveHandlePointer(cell(row, column)) : this.#apply(!this.#headingDrag ? current.extendTo(cell(row, column), extent) : this.#headingAxis === "rows" ? current.extendToRow(row, extent, this.#firstVisibleColumn) : current.extendToColumn(column, extent, this.#firstVisibleRow));
     }
     if (moved || changed) this.#invalidate();
   };
@@ -21951,13 +22991,18 @@ var GridView = class {
       // A row the source has since taken away has no band; the next movement finds the row there now.
       hoverRow: this.#hoverRow !== void 0 && this.#hoverRow < this.#totalRows ? this.#hoverRow : void 0,
       focusRow: this.#highlightFocusRow,
+      focusColumn: this.#highlightFocusColumn,
       // Each held, so a pass that changed neither text nor columns finds them the same.
       colouring: this.#colouring(),
       extentRows: this.#totalRows,
       extentColumns: this.#columns.length,
       pointer: this.#edit === void 0 ? void 0 : this.#pointer,
       outlinedColumns: this.#referenceOutlines.columns(this.#outlinedColumnsBoth(), this.#columnNames, this.#totalRows),
-      pointDashes: this.#pointDashesRange()
+      pointDashes: this.#pointDashesRange(),
+      // The grips (ADR-0480): drawn while a Reference can be dragged, held at the edges of what covers them.
+      grips: this.#gripsShown(),
+      pinnedWidthPx: this.#styles.geometry.pinnedWidthPx,
+      leadWidthPx: this.#styles.geometry.leadWidthPx
     };
     const was = this.#layerInputs;
     if (was === void 0 || Object.entries(inputs).some(([name, value]) => was[name] !== value)) {
@@ -21969,7 +23014,7 @@ var GridView = class {
         inputs.rowHeightPx,
         visible,
         { firstOpenRow, scrollLeftPx: this.#scrollLeftPx, hasHeader: true },
-        { hoverRow: inputs.hoverRow, focusRow: inputs.focusRow },
+        { hoverRow: inputs.hoverRow, focusRow: inputs.focusRow, focusColumn: inputs.focusColumn, rowCount: inputs.extentRows },
         this.#fillPaint(handle2, readable),
         {
           references: inputs.colouring.outlines.flatMap(([range, colour]) => {
@@ -21978,17 +23023,23 @@ var GridView = class {
           }),
           columns: inputs.outlinedColumns,
           point: this.#pointPaint(inputs.pointer, inputs.colouring),
-          pointDashes: inputs.pointDashes
+          pointDashes: inputs.pointDashes,
+          grips: inputs.grips ? this.#gripPaint(inputs.colouring, inputs.extentRows, inputs.extentColumns) : void 0
         }
       );
       const signature = JSON.stringify(pieces);
       if (signature !== this.#paintedLayers) {
         this.#paintedLayers = signature;
         const fill = (layer, held2) => {
-          layer.replaceChildren(...held2.map(({ className, style }) => {
+          const pinned2 = layer !== this.#selectionLayer;
+          layer.replaceChildren(...held2.map(({ className, style, grip }) => {
             const made4 = this.#root.ownerDocument.createElement("div");
             made4.className = className;
             made4.setAttribute("style", style);
+            if (grip !== void 0) {
+              made4.setAttribute("data-ex-grip", grip.kind);
+              this.#gripElements.set(made4, { grip, pinned: pinned2 });
+            }
             return made4;
           }));
         };
@@ -22099,6 +23150,9 @@ var GridView = class {
     this.#write(this.#scroller, "scroller", "style", this.#scrollerStyle());
     this.#write(this.#spacer, "spacer", "style", `width: ${geometry.totalWidthPx}px; height: ${this.#bandHeightPx + scrollHeightPx}px`);
     this.#forgetCurrentMatchOffFocus();
+    this.#forgetFindAllOffSequence();
+    this.#findAllFollowCurrent();
+    if (this.#popover?.kind === "find") this.#popover.panel.offerFindAll(this.#canFindAll);
     this.#paintHeader();
     this.#paintViewport();
     this.#paintStatus();
@@ -23842,8 +24896,11 @@ function wireFindPanel(contents, context, answered2 = false) {
       case "replaceAll":
         context.replaceAll();
         break;
+      case "findAll":
+        context.findAll();
+        break;
       default:
-        throw new RangeError(`A find panel's button is marked ${findPanelAttributes.step}="${marked.value}": it is next, previous, replace or replaceAll.`);
+        throw new RangeError(`A find panel's button is marked ${findPanelAttributes.step}="${marked.value}": it is next, previous, replace, replaceAll or findAll.`);
     }
   };
   contents.addEventListener("input", input);
@@ -23891,9 +24948,9 @@ var completionAttributes = Object.freeze({
   candidate: "data-ex-candidate"
 });
 function wireEditorCompletion(contents, context, current) {
-  const lists = contents.querySelectorAll(`[${completionAttributes.list}]`);
-  if (lists.length > 1) throw new Error(`The completion's contents drew ${lists.length} lists marked ${completionAttributes.list}: mark the one holding the candidates.`);
-  const list = lists[0];
+  const lists2 = contents.querySelectorAll(`[${completionAttributes.list}]`);
+  if (lists2.length > 1) throw new Error(`The completion's contents drew ${lists2.length} lists marked ${completionAttributes.list}: mark the one holding the candidates.`);
+  const list = lists2[0];
   if (list !== void 0) {
     list.id = context.listId;
     list.setAttribute("role", "listbox");
@@ -23963,6 +25020,14 @@ var japaneseGridWordTable = /* @__PURE__ */ new Map([
   ["find-replace-refused-cell", "{row} \u884C\u76EE\u3001{column}: {reason}\u3002"],
   ["find-replace-refused-more", "\u307B\u304B {count} \u4EF6\u3002"],
   ["find-not-editable", "\u3053\u306E\u5217\u306F\u7DE8\u96C6\u3067\u304D\u307E\u305B\u3093"],
+  ["find-all", "\u3059\u3079\u3066\u691C\u7D22"],
+  ["find-all-list", "\u691C\u7D22\u7D50\u679C"],
+  ["find-all-found", "{count} \u500B\u306E\u30BB\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F"],
+  ["find-all-found-one", "1 \u500B\u306E\u30BB\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F"],
+  ["find-all-none", "\u4E00\u81F4\u3059\u308B\u30BB\u30EB\u306F\u3042\u308A\u307E\u305B\u3093"],
+  ["find-all-in-row", "{row} \u884C\u76EE\u3001{column}"],
+  ["find-all-in-labelled-row", "{row}\u3001{column}"],
+  ["find-all-in-header", "\u898B\u51FA\u3057 {column}"],
   ["filter-ok", "OK"],
   ["filter-cancel", "\u30AD\u30E3\u30F3\u30BB\u30EB"],
   ["filter-search", "\u691C\u7D22"],
@@ -24592,7 +25657,7 @@ var FetchingGridSource = class _FetchingGridSource {
   #named;
   constructor(fetch, options) {
     if (typeof fetch !== "function") throw new TypeError("GridSource.fetch takes a function that answers a Query with a page.");
-    const { readAheadRows = defaultReadAheadRows, distinctValues, find, summarize, rowKey, marks: marks2, onFetchFailed, clock = systemClock } = options;
+    const { readAheadRows = defaultReadAheadRows, distinctValues, find, findAll: findAll2, summarize, rowKey, marks: marks2, onFetchFailed, clock = systemClock } = options;
     if (!Number.isSafeInteger(readAheadRows) || readAheadRows < 0) {
       throw new RangeError(`readAheadRows is a whole number of at least 0, not ${readAheadRows}.`);
     }
@@ -24618,6 +25683,13 @@ var FetchingGridSource = class _FetchingGridSource {
         return find(request, this.#inForce(), signal);
       };
     }
+    if (findAll2 !== void 0) {
+      if (find === void 0) throw new TypeError("A Find All is offered beside a Find: give `find` with `findAll` (ADR-0470 \xA71).");
+      this.findAll = async (request, signal) => {
+        this.#requireUndisposed();
+        return findAll2(request, this.#inForce(), signal);
+      };
+    }
     if (summarize !== void 0) {
       this.summarize = async (request, signal) => {
         this.#requireUndisposed();
@@ -27270,6 +28342,7 @@ export {
   EditorHint,
   FetchingGridSource,
   FetchingRowMarks,
+  FindAllMatches,
   FormatCode,
   GlyphWidthTable,
   GridMetrics,
@@ -27308,6 +28381,8 @@ export {
   exactDecimalDigits,
   filterPanelAttributes,
   filterPanelLabelIds,
+  findAll,
+  findAllPage,
   findMatches,
   findOutcomeText,
   findPanelAttributes,