@input/pen-search 0.1.0

package/dist/index.cjs

@@ -0,0 +1,886 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_SEARCH_LOCALE: () => DEFAULT_SEARCH_LOCALE,
+  DEFAULT_SEARCH_OPTIONS: () => DEFAULT_SEARCH_OPTIONS,
+  SEARCH_BUDGET_EXCEEDED_CODE: () => SEARCH_BUDGET_EXCEEDED_CODE,
+  SEARCH_EXECUTION_BUDGET_MS: () => SEARCH_EXECUTION_BUDGET_MS,
+  SEARCH_EXTENSION_NAME: () => SEARCH_EXTENSION_NAME,
+  SEARCH_INVALID_PATTERN_CODE: () => SEARCH_INVALID_PATTERN_CODE,
+  SEARCH_QUERY_MAX_LENGTH: () => SEARCH_QUERY_MAX_LENGTH,
+  SEARCH_REGEX_SEGMENT_MAX_CODE_UNITS: () => SEARCH_REGEX_SEGMENT_MAX_CODE_UNITS,
+  buildReplaceAllOps: () => buildReplaceAllOps,
+  buildReplaceOps: () => buildReplaceOps,
+  buildSearchRegex: () => buildSearchRegex,
+  findDocumentMatches: () => findDocumentMatches,
+  getSearchController: () => getSearchController,
+  searchExtension: () => searchExtension
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/extension.ts
+var import_pen_types = require("@input/pen-types");
+var import_pen_core3 = require("@input/pen-core");
+
+// src/controller.ts
+var import_pen_core2 = require("@input/pen-core");
+
+// src/search.ts
+var import_pen_core = require("@input/pen-core");
+var SEARCH_QUERY_MAX_LENGTH = 1024;
+var SEARCH_EXECUTION_BUDGET_MS = 50;
+var SEARCH_REGEX_SEGMENT_MAX_CODE_UNITS = 64 * 1024;
+var SEARCH_BUDGET_EXCEEDED_CODE = "search-budget-exceeded";
+var SEARCH_INVALID_PATTERN_CODE = "search-invalid-pattern";
+var DEFAULT_SEARCH_LOCALE = "en";
+var DEFAULT_SEARCH_OPTIONS = {
+  caseSensitive: false,
+  regex: false,
+  wholeWord: false
+};
+function createInitialSearchState() {
+  return {
+    open: false,
+    query: "",
+    replaceText: "",
+    matches: [],
+    activeIndex: -1,
+    options: DEFAULT_SEARCH_OPTIONS
+  };
+}
+function findDocumentMatches(editor, query, options) {
+  if (!query) {
+    return [];
+  }
+  if (query.length > SEARCH_QUERY_MAX_LENGTH) {
+    emitSearchDiagnostic(
+      editor,
+      SEARCH_INVALID_PATTERN_CODE,
+      `Search query exceeds the ${SEARCH_QUERY_MAX_LENGTH}-character limit.`
+    );
+    return [];
+  }
+  const locale = resolveSearchLocale(editor, options);
+  const regex = options.regex ? buildSearchRegex(query, options) : null;
+  if (options.regex && !regex) {
+    emitSearchDiagnostic(
+      editor,
+      SEARCH_INVALID_PATTERN_CODE,
+      "Search pattern is invalid."
+    );
+    return [];
+  }
+  const matches = [];
+  const deadline = options.regex ? performance.now() + SEARCH_EXECUTION_BUDGET_MS : null;
+  const execution = {
+    query,
+    options,
+    locale,
+    regex,
+    deadline
+  };
+  for (const handle of editor.documentState.allBlocks()) {
+    if (hasExceededDeadline(deadline)) {
+      emitBudgetExceeded(editor);
+      return matches;
+    }
+    const blockResult = findMatchesInBlock(handle, execution, matches.length);
+    matches.push(...blockResult.matches);
+    if (blockResult.exceeded) {
+      emitBudgetExceeded(editor);
+      return matches;
+    }
+  }
+  return matches;
+}
+function buildSearchRegex(query, options) {
+  if (!query || query.length > SEARCH_QUERY_MAX_LENGTH) {
+    return null;
+  }
+  const pattern = options.regex ? query : escapeRegExp(query);
+  const flags = options.caseSensitive ? "gu" : "giu";
+  try {
+    return new RegExp(pattern, flags);
+  } catch {
+    return null;
+  }
+}
+function normalizeActiveIndex(activeIndex, matchCount) {
+  if (matchCount === 0) {
+    return -1;
+  }
+  if (activeIndex < 0) {
+    return 0;
+  }
+  if (activeIndex >= matchCount) {
+    return matchCount - 1;
+  }
+  return activeIndex;
+}
+function getNextActiveIndex(activeIndex, matchCount) {
+  if (matchCount === 0) {
+    return -1;
+  }
+  if (activeIndex < 0) {
+    return 0;
+  }
+  return (activeIndex + 1) % matchCount;
+}
+function getPreviousActiveIndex(activeIndex, matchCount) {
+  if (matchCount === 0) {
+    return -1;
+  }
+  if (activeIndex <= 0) {
+    return matchCount - 1;
+  }
+  return activeIndex - 1;
+}
+function buildReplaceOps(match, replaceText) {
+  if (!match) {
+    return [];
+  }
+  if (match.kind === "block") {
+    return [
+      {
+        type: "splice-text",
+        blockId: match.blockId,
+        from: match.from,
+        to: match.from + match.to - match.from,
+        insert: ""
+      },
+      {
+        type: "splice-text",
+        blockId: match.blockId,
+        from: match.from,
+        to: match.from,
+        insert: replaceText
+      }
+    ];
+  }
+  if (match.kind === "table-cell") {
+    return [
+      {
+        type: "splice-text",
+        blockId: match.blockId,
+        cell: { row: match.row ?? 0, col: match.col ?? 0 },
+        from: match.from,
+        to: match.to,
+        insert: ""
+      },
+      {
+        type: "splice-text",
+        blockId: match.blockId,
+        cell: { row: match.row ?? 0, col: match.col ?? 0 },
+        from: match.from,
+        to: match.from,
+        insert: replaceText
+      }
+    ];
+  }
+  return [];
+}
+function buildReplaceAllOps(matches, replaceText) {
+  const matchesByTarget = /* @__PURE__ */ new Map();
+  for (const match of matches) {
+    const targetMatches = matchesByTarget.get(getMatchTargetKey(match)) ?? [];
+    targetMatches.push(match);
+    matchesByTarget.set(getMatchTargetKey(match), targetMatches);
+  }
+  const ops = [];
+  for (const [, blockMatches] of matchesByTarget) {
+    const sortedMatches = [...blockMatches].sort((left, right) => {
+      return right.from - left.from;
+    });
+    const firstMatch = sortedMatches[0];
+    if (!firstMatch) {
+      continue;
+    }
+    for (const match of sortedMatches) {
+      if (match.kind === "block") {
+        ops.push(
+          {
+            type: "splice-text",
+            blockId: match.blockId,
+            from: match.from,
+            to: match.from + match.to - match.from,
+            insert: ""
+          },
+          {
+            type: "splice-text",
+            blockId: match.blockId,
+            from: match.from,
+            to: match.from,
+            insert: replaceText
+          }
+        );
+        continue;
+      }
+      ops.push(
+        {
+          type: "splice-text",
+          blockId: match.blockId,
+          cell: { row: match.row ?? 0, col: match.col ?? 0 },
+          from: match.from,
+          to: match.to,
+          insert: ""
+        },
+        {
+          type: "splice-text",
+          blockId: match.blockId,
+          cell: { row: match.row ?? 0, col: match.col ?? 0 },
+          from: match.from,
+          to: match.from,
+          insert: replaceText
+        }
+      );
+    }
+  }
+  return ops;
+}
+function revealActiveMatch(editor, match) {
+  if (!match) {
+    return;
+  }
+  if (match.kind === "block") {
+    editor.selectText(match.blockId, match.from, match.to);
+  } else {
+    const row = match.row ?? 0;
+    const col = match.col ?? 0;
+    editor.selectCellRange(
+      match.blockId,
+      { row, col },
+      { row, col }
+    );
+  }
+  editor.scrollToBlock?.(match.blockId);
+}
+function findMatchesInBlock(handle, execution, startIndex) {
+  const matches = [];
+  const text = handle.textContent();
+  if (text) {
+    const textResult = collectMatchesInText(
+      text,
+      execution,
+      startIndex,
+      (from, to, matchedText, index) => ({
+        kind: "block",
+        blockId: handle.id,
+        from,
+        to,
+        text: matchedText,
+        index
+      })
+    );
+    matches.push(...textResult.matches);
+    if (textResult.exceeded) {
+      return { matches, exceeded: true };
+    }
+  }
+  const tableResult = findMatchesInGridCells(
+    handle,
+    execution,
+    startIndex + matches.length
+  );
+  matches.push(...tableResult.matches);
+  if (tableResult.exceeded) {
+    return { matches, exceeded: true };
+  }
+  return { matches, exceeded: false };
+}
+function findMatchesInGridCells(handle, execution, startIndex) {
+  const table = handle.as("table");
+  if (!table) {
+    return { matches: [], exceeded: false };
+  }
+  const matches = [];
+  const rowCount = table.tableRowCount();
+  const columnCount = table.tableColumnCount();
+  for (let row = 0; row < rowCount; row += 1) {
+    for (let col = 0; col < columnCount; col += 1) {
+      const cell = table.tableCell(row, col);
+      const cellText = cell?.textContent() ?? "";
+      if (!cellText) {
+        continue;
+      }
+      const cellResult = collectMatchesInText(
+        cellText,
+        execution,
+        startIndex + matches.length,
+        (from, to, matchedText, index) => ({
+          kind: "table-cell",
+          blockId: handle.id,
+          row,
+          col,
+          from,
+          to,
+          text: matchedText,
+          index,
+          cellText
+        })
+      );
+      matches.push(...cellResult.matches);
+      if (cellResult.exceeded) {
+        return { matches, exceeded: true };
+      }
+    }
+  }
+  return { matches, exceeded: false };
+}
+function collectMatchesInText(text, execution, startIndex, createMatch) {
+  if (execution.regex) {
+    return collectSegmentedMatches(
+      text,
+      execution,
+      startIndex,
+      createMatch
+    );
+  }
+  return {
+    matches: collectLiteralMatches(text, execution, startIndex, createMatch),
+    exceeded: false
+  };
+}
+function collectSegmentedMatches(text, execution, startIndex, createMatch) {
+  const matches = [];
+  const regex = execution.regex;
+  if (!regex) {
+    return { matches, exceeded: false };
+  }
+  for (let segmentStart = 0; segmentStart < text.length; segmentStart += SEARCH_REGEX_SEGMENT_MAX_CODE_UNITS) {
+    if (hasExceededDeadline(execution.deadline)) {
+      return { matches, exceeded: true };
+    }
+    const segment = text.slice(
+      segmentStart,
+      segmentStart + SEARCH_REGEX_SEGMENT_MAX_CODE_UNITS
+    );
+    matches.push(
+      ...collectTextMatches(
+        text,
+        segment,
+        segmentStart,
+        regex,
+        execution,
+        startIndex + matches.length,
+        createMatch
+      )
+    );
+  }
+  return { matches, exceeded: false };
+}
+function collectTextMatches(text, segment, segmentStart, regex, execution, startIndex, createMatch) {
+  const matches = [];
+  const localRegex = new RegExp(regex.source, regex.flags);
+  let match;
+  while ((match = localRegex.exec(segment)) !== null) {
+    const from = segmentStart + match.index;
+    const to = from + match[0].length;
+    if (!execution.options.wholeWord || isWholeWordMatch(text, from, to, execution.locale)) {
+      matches.push(
+        createMatch(from, to, match[0], startIndex + matches.length)
+      );
+    }
+    if (!localRegex.global) {
+      break;
+    }
+    if (match[0].length === 0) {
+      localRegex.lastIndex += 1;
+    }
+  }
+  return matches;
+}
+function collectLiteralMatches(text, execution, startIndex, createMatch) {
+  const matches = [];
+  const ranges = execution.options.caseSensitive ? findExactRanges(text, execution.query) : findFoldedRanges(text, execution.query, execution.locale);
+  for (const range of ranges) {
+    if (execution.options.wholeWord && !isWholeWordMatch(text, range.from, range.to, execution.locale)) {
+      continue;
+    }
+    matches.push(
+      createMatch(
+        range.from,
+        range.to,
+        text.slice(range.from, range.to),
+        startIndex + matches.length
+      )
+    );
+  }
+  return matches;
+}
+function getMatchTargetKey(match) {
+  if (match.kind === "block") {
+    return `block:${match.blockId}`;
+  }
+  return `table:${match.blockId}:${match.row ?? -1}:${match.col ?? -1}`;
+}
+function resolveSearchLocale(editor, options) {
+  return options.locale ?? editor.facet(import_pen_core.localeFacet);
+}
+function isWordSegmentBoundary(text, offset, locale) {
+  if (offset <= 0 || offset >= text.length) {
+    return true;
+  }
+  const range = (0, import_pen_core.wordRangeAt)(text, offset, locale);
+  if (!range) {
+    return true;
+  }
+  return offset === range.start || offset === range.end;
+}
+function isWholeWordMatch(text, from, to, locale) {
+  return isWordSegmentBoundary(text, from, locale) && isWordSegmentBoundary(text, to, locale);
+}
+function findExactRanges(text, query) {
+  const ranges = [];
+  let searchFrom = 0;
+  while (searchFrom <= text.length - query.length) {
+    const index = text.indexOf(query, searchFrom);
+    if (index === -1) {
+      break;
+    }
+    ranges.push({ from: index, to: index + query.length });
+    searchFrom = index + query.length;
+  }
+  return ranges;
+}
+function findFoldedRanges(text, query, locale) {
+  const foldedQuery = (0, import_pen_core.foldAndNormalize)(query, locale);
+  if (!foldedQuery) {
+    return [];
+  }
+  const { folded, originAt } = foldTextWithOriginMap(text, locale);
+  const ranges = [];
+  let searchFrom = 0;
+  while (searchFrom <= folded.length - foldedQuery.length) {
+    const index = folded.indexOf(foldedQuery, searchFrom);
+    if (index === -1) {
+      break;
+    }
+    const from = originAt[index] ?? 0;
+    const to = originAt[index + foldedQuery.length] ?? text.length;
+    if (to > from) {
+      ranges.push({ from, to });
+      searchFrom = index + foldedQuery.length;
+      continue;
+    }
+    searchFrom = index + 1;
+  }
+  return ranges;
+}
+function foldTextWithOriginMap(text, locale) {
+  const foldedWhole = (0, import_pen_core.foldAndNormalize)(text, locale);
+  if (foldedWhole.length === text.length) {
+    const originAt2 = new Array(foldedWhole.length + 1);
+    for (let index = 0; index <= foldedWhole.length; index += 1) {
+      originAt2[index] = index;
+    }
+    return { folded: foldedWhole, originAt: originAt2 };
+  }
+  let folded = "";
+  const originAt = [];
+  let offset = 0;
+  while (offset < text.length) {
+    const next = (0, import_pen_core.nextGraphemeBoundary)(text, offset, locale);
+    const piece = (0, import_pen_core.foldAndNormalize)(text.slice(offset, next), locale);
+    for (let index = 0; index < piece.length; index += 1) {
+      originAt.push(offset);
+    }
+    folded += piece;
+    offset = next;
+  }
+  originAt.push(text.length);
+  return { folded, originAt };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasExceededDeadline(deadline) {
+  return deadline !== null && performance.now() >= deadline;
+}
+function emitBudgetExceeded(editor) {
+  emitSearchDiagnostic(
+    editor,
+    SEARCH_BUDGET_EXCEEDED_CODE,
+    "Search stopped after the execution budget was exceeded."
+  );
+}
+function emitSearchDiagnostic(editor, code, message) {
+  const event = {
+    code,
+    level: "warn",
+    source: "search",
+    extension: "search",
+    message
+  };
+  editor.internals.emit("diagnostic", event);
+}
+
+// src/controller.ts
+var SearchControllerImpl = class {
+  editor;
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(editor) {
+    this.editor = editor;
+    this.state = createInitialSearchState();
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  open() {
+    this.updateState({
+      ...this.state,
+      open: true
+    });
+  }
+  close() {
+    this.updateState({
+      ...this.state,
+      open: false
+    });
+  }
+  toggleOpen() {
+    this.updateState({
+      ...this.state,
+      open: !this.state.open
+    });
+  }
+  setQuery(query) {
+    const nextState = {
+      ...this.state,
+      query,
+      activeIndex: query ? this.state.activeIndex : -1
+    };
+    if (!this.updateState(nextState)) {
+      return;
+    }
+    this.recompute();
+  }
+  setReplaceText(replaceText) {
+    this.updateState({
+      ...this.state,
+      replaceText
+    });
+  }
+  setOptions(options) {
+    const nextState = {
+      ...this.state,
+      options: {
+        ...this.state.options,
+        ...options
+      }
+    };
+    if (!this.updateState(nextState)) {
+      return;
+    }
+    this.recompute();
+  }
+  next() {
+    const nextIndex = getNextActiveIndex(
+      this.state.activeIndex,
+      this.state.matches.length
+    );
+    if (nextIndex === this.state.activeIndex && this.state.matches.length === 0) {
+      return;
+    }
+    this.state = {
+      ...this.state,
+      activeIndex: nextIndex
+    };
+    revealActiveMatch(this.editor, this.getActiveMatch());
+    this.notify();
+  }
+  previous() {
+    const previousIndex = getPreviousActiveIndex(
+      this.state.activeIndex,
+      this.state.matches.length
+    );
+    if (previousIndex === this.state.activeIndex && this.state.matches.length === 0) {
+      return;
+    }
+    this.state = {
+      ...this.state,
+      activeIndex: previousIndex
+    };
+    revealActiveMatch(this.editor, this.getActiveMatch());
+    this.notify();
+  }
+  replace() {
+    const activeMatch = this.getActiveMatch();
+    const ops = buildReplaceOps(activeMatch, this.state.replaceText);
+    if (ops.length === 0) {
+      return;
+    }
+    this.editor.apply(ops, {
+      origin: "user",
+      undoGroup: true
+    });
+    this.recompute();
+    revealActiveMatch(this.editor, this.getActiveMatch());
+  }
+  replaceAll() {
+    const ops = buildReplaceAllOps(this.state.matches, this.state.replaceText);
+    if (ops.length === 0) {
+      return;
+    }
+    this.editor.apply(ops, {
+      origin: "user",
+      undoGroup: true
+    });
+    this.recompute();
+  }
+  recompute() {
+    const previousCount = this.state.matches.length;
+    const matches = findDocumentMatches(
+      this.editor,
+      this.state.query,
+      this.state.options
+    );
+    this.updateState({
+      ...this.state,
+      matches,
+      activeIndex: normalizeActiveIndex(this.state.activeIndex, matches.length)
+    });
+    if (this.state.query.length > 0 && matches.length !== previousCount) {
+      (0, import_pen_core2.announceEditorA11y)(this.editor, "findMatches", {
+        count: matches.length
+      });
+    }
+  }
+  getActiveMatch() {
+    return this.state.matches[this.state.activeIndex] ?? null;
+  }
+  notify() {
+    for (const listener of this.listeners) {
+      listener();
+    }
+  }
+  updateState(nextState) {
+    if (searchStatesEqual(this.state, nextState)) {
+      return false;
+    }
+    this.state = nextState;
+    this.notify();
+    return true;
+  }
+};
+function searchStatesEqual(left, right) {
+  return left.open === right.open && left.query === right.query && left.replaceText === right.replaceText && left.activeIndex === right.activeIndex && left.options.caseSensitive === right.options.caseSensitive && left.options.regex === right.options.regex && left.options.wholeWord === right.options.wholeWord && left.options.locale === right.options.locale && searchMatchesEqual(left.matches, right.matches);
+}
+function searchMatchesEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index += 1) {
+    const leftMatch = left[index];
+    const rightMatch = right[index];
+    if (leftMatch?.kind !== rightMatch?.kind || leftMatch?.blockId !== rightMatch?.blockId || leftMatch?.row !== rightMatch?.row || leftMatch?.col !== rightMatch?.col || leftMatch?.cellText !== rightMatch?.cellText || leftMatch?.from !== rightMatch?.from || leftMatch?.to !== rightMatch?.to || leftMatch?.text !== rightMatch?.text || leftMatch?.index !== rightMatch?.index) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/decorations.ts
+function buildSearchDecorations(state) {
+  if (!state.open || state.matches.length === 0) {
+    return [];
+  }
+  return state.matches.flatMap((match, index) => {
+    if (match.kind !== "block") {
+      return [];
+    }
+    const isActive = index === state.activeIndex;
+    return [{
+      type: "inline",
+      blockId: match.blockId,
+      from: match.from,
+      to: match.to,
+      attributes: {
+        class: isActive ? "pen-search-match pen-search-match-active" : "pen-search-match",
+        "data-pen-search-match": "",
+        "data-search-match-index": String(match.index),
+        "data-search-match-active": String(isActive)
+      }
+    }];
+  });
+}
+
+// src/extension.ts
+var SEARCH_EXTENSION_NAME = "search";
+var SEARCH_KEY_BINDINGS = [
+  {
+    key: "Mod-f",
+    description: "Open search",
+    handler: (editor, event) => {
+      const controller = getSearchController(editor);
+      if (!controller) {
+        return false;
+      }
+      event.preventDefault();
+      controller.open();
+      return true;
+    }
+  },
+  {
+    key: "Mod-g",
+    description: "Next search match",
+    handler: (editor, event) => {
+      const controller = getSearchController(editor);
+      const state = controller?.getState();
+      if (!controller || !state?.open || state.query.length === 0) {
+        return false;
+      }
+      event.preventDefault();
+      controller.next();
+      return true;
+    }
+  },
+  {
+    key: "Shift-Mod-g",
+    description: "Previous search match",
+    handler: (editor, event) => {
+      const controller = getSearchController(editor);
+      const state = controller?.getState();
+      if (!controller || !state?.open || state.query.length === 0) {
+        return false;
+      }
+      event.preventDefault();
+      controller.previous();
+      return true;
+    }
+  },
+  {
+    key: "Enter",
+    description: "Next search match",
+    handler: (editor, event) => {
+      const controller = getSearchController(editor);
+      const state = controller?.getState();
+      if (!controller || !state?.open || state.query.length === 0) {
+        return false;
+      }
+      event.preventDefault();
+      controller.next();
+      return true;
+    }
+  },
+  {
+    key: "Shift-Enter",
+    description: "Previous search match",
+    handler: (editor, event) => {
+      const controller = getSearchController(editor);
+      const state = controller?.getState();
+      if (!controller || !state?.open || state.query.length === 0) {
+        return false;
+      }
+      event.preventDefault();
+      controller.previous();
+      return true;
+    }
+  },
+  {
+    key: "Escape",
+    description: "Close search",
+    handler: (editor, event) => {
+      const controller = getSearchController(editor);
+      const state = controller?.getState();
+      if (!controller || !state?.open) {
+        return false;
+      }
+      event.preventDefault();
+      controller.close();
+      return true;
+    }
+  }
+];
+function searchExtension() {
+  let activeEditor = null;
+  let controller = null;
+  let unsubscribeCommit = null;
+  let unsubscribeController = null;
+  return (0, import_pen_core3.defineExtension)({
+    name: SEARCH_EXTENSION_NAME,
+    facets: [
+      ...searchKeymapProviders(SEARCH_KEY_BINDINGS),
+      import_pen_core3.decorationsFacet.of(() => {
+        const state = controller?.getState();
+        if (!state || state.matches.length === 0) {
+          return (0, import_pen_core3.createDecorationSet)([]);
+        }
+        return (0, import_pen_core3.createDecorationSet)(buildSearchDecorations(state));
+      })
+    ],
+    activateClient: async ({ editor }) => {
+      activeEditor = editor;
+      controller = new SearchControllerImpl(editor);
+      editor.internals.assignSlot(import_pen_types.SEARCH_CONTROLLER_SLOT, controller);
+      unsubscribeCommit = editor.on("commit", () => {
+        controller?.recompute();
+      });
+      unsubscribeController = controller.subscribe(() => {
+        activeEditor?.requestDecorationUpdate();
+      });
+    },
+    deactivateClient: async () => {
+      unsubscribeCommit?.();
+      unsubscribeCommit = null;
+      unsubscribeController?.();
+      unsubscribeController = null;
+      activeEditor?.internals.assignSlot(import_pen_types.SEARCH_CONTROLLER_SLOT, null);
+      controller = null;
+      activeEditor = null;
+    }
+  });
+}
+function getSearchController(editor) {
+  return editor.facet(import_pen_core3.searchControllerFacet) ?? null;
+}
+function searchKeymapProviders(bindings) {
+  return bindings.map(
+    (binding) => import_pen_core3.keymapFacet.of(
+      [binding],
+      (0, import_pen_core3.keyBindingPriorityToPrecedence)(binding.priority ?? 300)
+    )
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SEARCH_LOCALE,
+  DEFAULT_SEARCH_OPTIONS,
+  SEARCH_BUDGET_EXCEEDED_CODE,
+  SEARCH_EXECUTION_BUDGET_MS,
+  SEARCH_EXTENSION_NAME,
+  SEARCH_INVALID_PATTERN_CODE,
+  SEARCH_QUERY_MAX_LENGTH,
+  SEARCH_REGEX_SEGMENT_MAX_CODE_UNITS,
+  buildReplaceAllOps,
+  buildReplaceOps,
+  buildSearchRegex,
+  findDocumentMatches,
+  getSearchController,
+  searchExtension
+});