@coze-editor/extensions 0.1.0-alpha.09ffeb

package/dist/esm/index.js

@@ -0,0 +1,1399 @@
+// src/ast-decorator/whole.ts
+import { omit } from "es-toolkit";
+import { traverseAST } from "@coze-editor/utils";
+import {
+  Decoration,
+  EditorView
+} from "@codemirror/view";
+import {
+  Facet as Facet2,
+  RangeSet,
+  StateEffect,
+  StateField,
+  Prec
+} from "@codemirror/state";
+import { syntaxTree } from "@codemirror/language";
+
+// src/background-decorations/index.ts
+import {
+  RectangleMarker,
+  layer
+} from "@codemirror/view";
+import { EditorSelection, Facet } from "@codemirror/state";
+
+// src/background-decorations/squash.ts
+function squash(decorations) {
+  const result = [];
+  const grouped = groupDecorationsByClassName(decorations);
+  grouped.forEach((decos, className) => {
+    const merged = mergeIntervals(decos);
+    result.push(
+      ...merged.map((m) => ({
+        from: m.start,
+        to: m.end,
+        className
+      }))
+    );
+  });
+  return result;
+}
+function groupDecorationsByClassName(decorations) {
+  const map = /* @__PURE__ */ new Map();
+  decorations.forEach((deco) => {
+    if (!map.has(deco.className)) {
+      map.set(deco.className, []);
+    }
+    map.get(deco.className).push(deco);
+  });
+  return map;
+}
+function mergeIntervals(decorations) {
+  const merged = [];
+  const cloned = decorations.map((deco) => ({
+    start: deco.from,
+    end: deco.to
+  }));
+  cloned.sort((a, b) => a.start - b.start);
+  let current = cloned[0];
+  for (let i = 1; i < cloned.length; i++) {
+    const next = cloned[i];
+    if (next.start <= current.end) {
+      current.end = Math.max(current.end, next.end);
+    } else {
+      merged.push(current);
+      current = next;
+    }
+  }
+  merged.push(current);
+  return merged;
+}
+
+// src/background-decorations/cut.ts
+function cutAtLineBreak(decorations, state) {
+  const cuts = [];
+  decorations.forEach((deco) => {
+    const startLine = state.doc.lineAt(deco.from);
+    const endLine = state.doc.lineAt(deco.to);
+    if (startLine.number !== endLine.number) {
+      const slices = [];
+      let pos = deco.from;
+      for (let i = startLine.number; i < endLine.number; i++) {
+        const line = state.doc.line(i);
+        slices.push({
+          from: pos,
+          to: line.to,
+          className: deco.className
+        });
+        pos = line.to + 1;
+      }
+      slices.push({
+        from: pos,
+        to: deco.to,
+        className: deco.className
+      });
+      cuts.push(...slices);
+    } else {
+      cuts.push(deco);
+    }
+  });
+  return cuts;
+}
+
+// src/background-decorations/index.ts
+function configChanged(update) {
+  return update.startState.facet(backgroundDecorations) !== update.state.facet(backgroundDecorations);
+}
+var backgroundDecoratorLayer = layer({
+  above: false,
+  markers(view) {
+    const decorations = view.state.facet(backgroundDecorations).reduce((memo, current) => [...memo, ...current(view)], []);
+    return cutAtLineBreak(squash(decorations), view.state).map(
+      (deco) => RectangleMarker.forRange(
+        view,
+        deco.className,
+        EditorSelection.range(deco.from, deco.to)
+      )
+    ).reduce((memo, current) => [...memo, ...current], []);
+  },
+  update(update) {
+    return update.focusChanged || update.docChanged || update.selectionSet || update.viewportChanged || configChanged(update);
+  },
+  class: "cm-backgroundDecoratorLayer"
+});
+var backgroundDecorations = Facet.define({
+  enables: [backgroundDecoratorLayer]
+});
+
+// src/ast-decorator/whole.ts
+var updateWholeDecorationsEffect = StateEffect.define();
+function updateWholeDecorations(view) {
+  view.dispatch({
+    effects: updateWholeDecorationsEffect.of(null)
+  });
+}
+var classNameDecorationCache = /* @__PURE__ */ new Map();
+function getClassDecoration(className) {
+  if (!classNameDecorationCache.has(className)) {
+    classNameDecorationCache.set(
+      className,
+      Decoration.mark({
+        class: className
+      })
+    );
+  }
+  return classNameDecorationCache.get(className);
+}
+function buildDecorations(state, tree) {
+  const decorates = state.facet(wholeASTDecoratorFacet) ?? [];
+  const treeCursor = tree.cursor();
+  const decorations = {
+    highest: Decoration.none,
+    high: Decoration.none,
+    default: Decoration.none,
+    low: Decoration.none,
+    lowest: Decoration.none
+  };
+  let atomicRanges = RangeSet.empty;
+  let backgroundDecorations2 = [];
+  const from = 0;
+  const to = state.doc.length;
+  traverseAST(treeCursor, from, to, (cursor) => {
+    decorates.forEach((decorate) => {
+      const decorationSpec = decorate(cursor, state);
+      let specs = [];
+      if (Array.isArray(decorationSpec)) {
+        specs = decorationSpec;
+      } else if (decorationSpec) {
+        specs = [decorationSpec];
+      }
+      specs.forEach((spec) => {
+        const result = updateDecorationSpec(cursor, spec, {
+          decorations,
+          backgroundDecorations: backgroundDecorations2,
+          atomicRanges
+        });
+        if (!result) {
+          return;
+        }
+        backgroundDecorations2 = result.backgroundDecorations;
+        atomicRanges = result.atomicRanges;
+      });
+    });
+  });
+  return {
+    decorations,
+    atomicRanges,
+    backgroundDecorations: backgroundDecorations2
+  };
+}
+function updateDecorationSpec(cursor, decorationSpec, {
+  decorations,
+  backgroundDecorations: backgroundDecorations2,
+  atomicRanges
+}) {
+  if (!decorationSpec) {
+    return;
+  }
+  const from = decorationSpec.from ?? cursor.from;
+  const to = decorationSpec.to ?? cursor.to;
+  const omitKeys = ["type", "from", "to", "atomicRange"];
+  let decorationRange = null;
+  switch (decorationSpec.type) {
+    case "className":
+      decorationRange = from === to ? null : getClassDecoration(decorationSpec.className).range(from, to);
+      break;
+    case "replace":
+      decorationRange = Decoration.replace(
+        omit(decorationSpec, omitKeys)
+      ).range(from, to);
+      break;
+    case "widget":
+      decorationRange = Decoration.widget(omit(decorationSpec, omitKeys)).range(
+        from
+      );
+      break;
+    case "background":
+      backgroundDecorations2.push({
+        from: decorationSpec.from ?? cursor.from,
+        to: decorationSpec.to ?? cursor.to,
+        className: decorationSpec.className
+      });
+      break;
+  }
+  if (decorationRange) {
+    const prec = decorationSpec.type === "className" ? decorationSpec.prec ?? "default" : "default";
+    if (decorations[prec]) {
+      decorations[prec] = decorations[prec].update({
+        add: [decorationRange],
+        sort: true
+      });
+    }
+  }
+  if (decorationSpec.type !== "background" && decorationRange && decorationSpec.atomicRange === true) {
+    atomicRanges = atomicRanges.update({
+      add: [decorationRange],
+      sort: true
+    });
+  }
+  return {
+    decorations,
+    backgroundDecorations: backgroundDecorations2,
+    atomicRanges
+  };
+}
+var decorateField = StateField.define({
+  create(state) {
+    return buildDecorations(state, syntaxTree(state));
+  },
+  update(value, tr) {
+    const tree = syntaxTree(tr.state);
+    const hasUpdateEffect = tr.effects.some(
+      (effect) => effect.is(updateWholeDecorationsEffect)
+    );
+    const syntaxTreeChanged = syntaxTree(tr.startState) !== tree;
+    if (syntaxTreeChanged || hasUpdateEffect) {
+      value = buildDecorations(tr.state, tree);
+    }
+    return value;
+  },
+  provide(field) {
+    return [
+      Prec.highest(
+        EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.highest
+        )
+      ),
+      Prec.high(
+        EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.high
+        )
+      ),
+      Prec.default(
+        EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.default
+        )
+      ),
+      Prec.low(
+        EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.low
+        )
+      ),
+      Prec.lowest(
+        EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.lowest
+        )
+      ),
+      EditorView.atomicRanges.of((view) => view.state.field(field).atomicRanges),
+      backgroundDecorations.of(
+        (view) => view.state.field(field).backgroundDecorations
+      )
+    ];
+  }
+});
+var wholeASTDecoratorFacet = Facet2.define({
+  enables: [decorateField, backgroundDecoratorLayer]
+});
+
+// src/ast-decorator/cursor.ts
+import {
+  Decoration as Decoration2,
+  ViewPlugin
+} from "@codemirror/view";
+import { Facet as Facet3, RangeSetBuilder } from "@codemirror/state";
+import { syntaxTree as syntaxTree2 } from "@codemirror/language";
+var CursorASTView = class {
+  constructor(view) {
+    this.view = view;
+  }
+  classNameDecorationCache = /* @__PURE__ */ new Map();
+  decorations = Decoration2.none;
+  backgroundDecorations = [];
+  getClassDecoration(className) {
+    if (!this.classNameDecorationCache.has(className)) {
+      this.classNameDecorationCache.set(
+        className,
+        Decoration2.mark({
+          class: className
+        })
+      );
+    }
+    return this.classNameDecorationCache.get(className);
+  }
+  update(update) {
+    if (update.focusChanged && update.view.hasFocus || !update.startState.selection.eq(update.state.selection)) {
+      const tree = syntaxTree2(update.state);
+      const pos = update.state.selection.main.head;
+      const decorators = update.state.facet(cursorASTDecoratorFacet);
+      const cursor = tree.cursorAt(pos, 0);
+      const builder = new RangeSetBuilder();
+      const bgDecorations = [];
+      do {
+        decorators.forEach((decorator) => {
+          const decorationSpec = decorator(cursor, update.state);
+          if (!decorationSpec) {
+            return;
+          }
+          let decoration;
+          switch (decorationSpec.type) {
+            case "className":
+              decoration = this.getClassDecoration(decorationSpec.className);
+              break;
+            case "background":
+              bgDecorations.push({
+                from: decorationSpec.from ?? cursor.from,
+                to: decorationSpec.to ?? cursor.to,
+                className: decorationSpec.className
+              });
+              break;
+          }
+          if (decoration) {
+            builder.add(
+              decorationSpec.from ?? cursor.from,
+              decorationSpec.to ?? cursor.to,
+              decoration
+            );
+          }
+        });
+      } while (cursor.parent());
+      this.decorations = builder.finish();
+      this.backgroundDecorations = bgDecorations;
+    }
+    if (update.focusChanged && !update.view.hasFocus) {
+      this.decorations = Decoration2.none;
+      this.backgroundDecorations = [];
+    }
+  }
+};
+var cursorASTDecoratorFacet = Facet3.define({
+  enables: [
+    ViewPlugin.fromClass(CursorASTView, {
+      decorations: (v) => v.decorations,
+      provide(plugin) {
+        return [
+          backgroundDecorations.of(
+            (view) => {
+              var _a;
+              return ((_a = view.plugin(plugin)) == null ? void 0 : _a.backgroundDecorations) ?? [];
+            }
+          )
+        ];
+      }
+    })
+  ]
+});
+
+// src/ast-decorator/index.ts
+var astDecorator = {
+  whole: wholeASTDecoratorFacet,
+  fromCursor: cursorASTDecoratorFacet
+};
+
+// src/ast-debugger/index.ts
+import { traverseAST as traverseAST2 } from "@coze-editor/utils";
+import { ViewPlugin as ViewPlugin2 } from "@codemirror/view";
+import { syntaxTree as syntaxTree3 } from "@codemirror/language";
+var astDebugger = ViewPlugin2.fromClass(
+  class {
+    constructor(view) {
+      printTreeFromState(view.state);
+    }
+    update(update) {
+      if (update.docChanged) {
+        printTreeFromState(update.state);
+      }
+    }
+  }
+);
+function printTreeFromState(state) {
+  const tree = syntaxTree3(state);
+  console.groupCollapsed("Syntax Tree");
+  const cursor = tree.cursor();
+  traverseAST2(cursor, 0, tree.length, (cursor2) => {
+    console.group(
+      `%c${cursor2.name}(${cursor2.from}:${cursor2.to})`,
+      "color: purple;"
+    );
+    console.log(state.sliceDoc(cursor2.from, cursor2.to));
+    console.groupEnd();
+  });
+  console.groupEnd();
+}
+
+// src/focusable/focusable.ts
+import { WidgetType, keymap } from "@codemirror/view";
+var focusableKeymap = keymap.of([
+  {
+    key: "ArrowLeft",
+    run(view) {
+      const mainSelection = view.state.selection.main;
+      if (!mainSelection.empty) {
+        return false;
+      }
+      let handled = false;
+      const pos = mainSelection.from;
+      for (const line of view.docView.children) {
+        for (const child of line.children) {
+          if (child.isWidget && child.widget instanceof FocusableWidget && child.posAtEnd === pos) {
+            child.widget.focus(1);
+            handled = true;
+          }
+        }
+        if (handled) {
+          break;
+        }
+      }
+      return handled;
+    }
+  },
+  {
+    key: "ArrowRight",
+    run(view) {
+      const mainSelection = view.state.selection.main;
+      if (!mainSelection.empty) {
+        return false;
+      }
+      let handled = false;
+      const pos = mainSelection.from;
+      for (const line of view.docView.children) {
+        for (const child of line.children) {
+          if (child.isWidget && child.widget instanceof FocusableWidget && child.posAtStart === pos) {
+            child.widget.focus(-1);
+            handled = true;
+            break;
+          }
+        }
+        if (handled) {
+          break;
+        }
+      }
+      return handled;
+    }
+  }
+]);
+var FocusableWidget = class extends WidgetType {
+};
+
+// src/auto-select-ranges/extension.ts
+import { FacetCombineStrategy, flatten } from "@coze-editor/utils";
+import { ViewPlugin as ViewPlugin3 } from "@codemirror/view";
+import { EditorSelection as EditorSelection2, Facet as Facet4 } from "@codemirror/state";
+
+// src/auto-select-ranges/utils.ts
+function mergeIntervals2(ranges) {
+  if (ranges.length === 0) {
+    return [];
+  }
+  const merged = [];
+  const cloned = ranges.map((range2) => ({
+    from: range2.from,
+    to: range2.to
+  }));
+  cloned.sort((a, b) => a.from - b.from);
+  let current = cloned[0];
+  for (let i = 1; i < cloned.length; i++) {
+    const next = cloned[i];
+    if (next.from <= current.to) {
+      current.to = Math.max(current.to, next.to);
+    } else {
+      merged.push(current);
+      current = next;
+    }
+  }
+  if (current) {
+    merged.push(current);
+  }
+  return merged;
+}
+function findContainingRange(ranges, pos) {
+  for (const range2 of ranges) {
+    if (pos >= range2.from && pos <= range2.to) {
+      return range2;
+    }
+  }
+}
+
+// src/auto-select-ranges/extension.ts
+var extension = ViewPlugin3.fromClass(
+  class {
+    lastFocus = false;
+    constructor(view) {
+      this.lastFocus = view.hasFocus;
+    }
+    update(update) {
+      const userEvent = update.state.facet(selectUserEvent) ?? "select";
+      const hasSelectUserEvent = update.transactions.some(
+        (tr) => tr.isUserEvent(userEvent)
+      );
+      if (hasSelectUserEvent) {
+        const lastHasFocus = this.lastFocus;
+        const startSelection = update.startState.selection;
+        const { selection } = update.state;
+        const rangesProviders = update.state.facet(rangesFacet);
+        const ranges = mergeIntervals2(
+          flatten(
+            rangesProviders.map((provider) => provider(update.view.state))
+          ).filter(Boolean)
+        );
+        const currentRange = findContainingRange(ranges, selection.main.from);
+        if (selection.main.empty && currentRange && (!lastHasFocus || // 上一次的选区 from 或 to 在当前选区外（“首次进入”当前选区）
+        findContainingRange(ranges, startSelection.main.from) !== currentRange || findContainingRange(ranges, startSelection.main.to) !== currentRange)) {
+          queueMicrotask(() => {
+            update.view.dispatch({
+              selection: selection.replaceRange(
+                EditorSelection2.range(currentRange.from, currentRange.to)
+              )
+            });
+          });
+        }
+      }
+      if (this.lastFocus !== update.view.hasFocus) {
+        this.lastFocus = update.view.hasFocus;
+      }
+    }
+  }
+);
+var rangesFacet = Facet4.define({
+  enables: extension
+});
+var selectUserEvent = Facet4.define({
+  combine: FacetCombineStrategy.Last
+});
+
+// src/selection-enlarger/extension.ts
+import { flatten as flatten2, hasOverlap } from "@coze-editor/utils";
+import { EditorSelection as EditorSelection3, EditorState, Facet as Facet5 } from "@codemirror/state";
+var extension2 = EditorState.transactionFilter.of((tr) => {
+  if (tr.docChanged || tr.newSelection.eq(tr.startState.selection)) {
+    return tr;
+  }
+  const providers = tr.startState.facet(selectionEnlarger);
+  const specs = flatten2(providers.map((provider) => provider(tr.startState)));
+  let { newSelection } = tr;
+  newSelection.ranges.forEach((range2, index) => {
+    for (const spec of specs) {
+      if (hasOverlap(range2, spec.source)) {
+        const isReversed = range2.head < range2.anchor;
+        const from = Math.min(range2.from, spec.target.from);
+        const to = Math.max(range2.to, spec.target.to);
+        const newRange = isReversed ? EditorSelection3.range(
+          to,
+          from,
+          range2.goalColumn,
+          range2.bidiLevel ?? void 0
+        ) : EditorSelection3.range(
+          from,
+          to,
+          range2.goalColumn,
+          range2.bidiLevel ?? void 0
+        );
+        newSelection = newSelection.replaceRange(newRange, index);
+      }
+    }
+  });
+  return [
+    tr,
+    {
+      selection: newSelection
+    }
+  ];
+});
+var selectionEnlarger = Facet5.define({
+  enables: extension2
+});
+
+// src/deletion-enlarger/extension.ts
+import { flatten as flatten3, hasOverlap as hasOverlap2 } from "@coze-editor/utils";
+import { ChangeSet, EditorState as EditorState2, Facet as Facet6 } from "@codemirror/state";
+var extension3 = EditorState2.transactionFilter.of((tr) => {
+  const providers = tr.startState.facet(deletionEnlarger);
+  const specs = flatten3(providers.map((provider) => provider(tr.startState)));
+  const { length } = tr.startState.doc;
+  let changes = ChangeSet.empty(length);
+  tr.changes.iterChanges((fromA, toA, fromB, toB) => {
+    const isDeletion = fromB === toB;
+    if (!isDeletion) {
+      return;
+    }
+    for (const spec of specs) {
+      if (hasOverlap2(
+        {
+          from: fromA,
+          to: toA
+        },
+        spec.source
+      )) {
+        const change = ChangeSet.of([{ ...spec.target, insert: "" }], length);
+        changes = changes.compose(change.map(changes));
+      }
+    }
+  });
+  const nextChanges = changes.map(tr.changes);
+  if (nextChanges.empty) {
+    return tr;
+  }
+  return [
+    tr,
+    {
+      changes: nextChanges,
+      sequential: true
+    }
+  ];
+});
+var deletionEnlarger = Facet6.define({
+  enables: extension3
+});
+
+// src/input-rules/index.ts
+import { EditorView as EditorView2 } from "@codemirror/view";
+import { Prec as Prec2 } from "@codemirror/state";
+var android = typeof navigator === "object" && /Android\b/.test(navigator.userAgent);
+var isExtension = (v) => Boolean(v);
+var inputRules = (rules) => {
+  const ruleExtensions = (rules ?? []).map(({ type, triggerCharacter, handler }) => {
+    if (type === "character") {
+      return EditorView2.inputHandler.of((view, from, to, insert) => {
+        if ((android ? view.composing : view.compositionStarted) || view.state.readOnly) {
+          return false;
+        }
+        const sel = view.state.selection.main;
+        if (insert !== triggerCharacter || from !== sel.from || to !== sel.to) {
+          return false;
+        }
+        return handler({
+          view,
+          state: view.state,
+          from,
+          to
+        });
+      });
+    }
+  }).filter((v) => isExtension(v));
+  return Prec2.high(ruleExtensions);
+};
+
+// src/mix-languages/mix.ts
+import { parseMixed } from "@lezer/common";
+import { parser as templateParser } from "@coze-editor/lezer-parser-template";
+import { LRLanguage } from "@codemirror/language";
+function mixLanguages({ name, outerLanguage, innerLanguage }) {
+  return LRLanguage.define({
+    name,
+    parser: templateParser.configure({
+      wrap: parseMixed((node) => {
+        if (outerLanguage && node.type.isTop) {
+          return {
+            parser: outerLanguage.parser,
+            overlay: (n) => n.type.name === "Text"
+          };
+        }
+        if (innerLanguage && node.name === "InterpolationContent") {
+          return {
+            parser: innerLanguage.parser
+          };
+        }
+        return null;
+      })
+    })
+  });
+}
+
+// src/indent-guides/index.ts
+import { range } from "es-toolkit";
+import {
+  Decoration as Decoration3,
+  EditorView as EditorView3,
+  ViewPlugin as ViewPlugin4,
+  WidgetType as WidgetType2
+} from "@codemirror/view";
+import { RangeSetBuilder as RangeSetBuilder2 } from "@codemirror/state";
+
+// src/indent-guides/utils.ts
+var SPACES = /^\s*/;
+var getCodeStart = (text) => text.match(SPACES)[0].length;
+var fromPairs = (pairs2) => {
+  let index = -1;
+  const length = pairs2 == null ? 0 : pairs2.length;
+  const result = {};
+  while (++index < length) {
+    const pair = pairs2[index];
+    result[pair[0]] = pair[1];
+  }
+  return result;
+};
+
+// src/indent-guides/index.ts
+var indentationMark = Decoration3.mark({ class: "cm-indentation-guide" });
+var indentationLevelMarks = range(20).map(
+  (i) => Decoration3.line({ class: `cm-indentation-level-${i}` })
+);
+var IndentationWidget = class _IndentationWidget extends WidgetType2 {
+  constructor(indents) {
+    super();
+    this.indents = indents;
+  }
+  static create(indents) {
+    return Decoration3.widget({
+      widget: new _IndentationWidget(indents),
+      side: 1
+    });
+  }
+  toDOM() {
+    const wrap = document.createElement("span");
+    wrap.className = "cm-indentation-widget";
+    for (const indent of this.indents) {
+      const marker = wrap.appendChild(document.createElement("span"));
+      marker.className = "cm-indentation-guide";
+      marker.textContent = " ";
+      wrap.append(" ".repeat(indent - 1));
+    }
+    return wrap;
+  }
+};
+function makeIndentationMark(from, to, indent, tabSize, builder) {
+  builder.add(from, from, indentationLevelMarks[indent / tabSize]);
+  for (let i = from; i < Math.min(from + indent, to); i += tabSize) {
+    builder.add(i, i + 1, indentationMark);
+  }
+}
+function makeIndentationWidget(from, to, tabSize, builder) {
+  const length = to - from;
+  if (length !== 0) {
+    return;
+  }
+  if (tabSize > 2) {
+    builder.add(to, to, IndentationWidget.create([tabSize]));
+  } else {
+    builder.add(to, to, IndentationWidget.create([2, tabSize * 2]));
+  }
+}
+function makeIndentationDecorators(view) {
+  const builder = new RangeSetBuilder2();
+  const tabSize = Number(view.state.tabSize);
+  const { doc } = view.state;
+  const spaceOnlyLines = [];
+  let currentIndent = 0;
+  for (const { from: visibleFrom, to: visibleTo } of view.visibleRanges) {
+    let to = visibleFrom - 1;
+    let pos, from, length, text;
+    while ((pos = to + 1) <= visibleTo) {
+      ({ from, to, length, text } = doc.lineAt(pos));
+      const codeStartsAt = getCodeStart(text);
+      const isAllSpaces = codeStartsAt === length;
+      const skipIndent = codeStartsAt === 0;
+      const isComment = text[codeStartsAt] === "/";
+      if (isAllSpaces) {
+        spaceOnlyLines.push({ from, to });
+        continue;
+      } else if (skipIndent) {
+        spaceOnlyLines.length = 0;
+        continue;
+      }
+      const indent = Math.ceil(codeStartsAt / tabSize) * tabSize;
+      if (!isComment) {
+        currentIndent = indent;
+      }
+      for (const { from: spaceFrom, to: spaceTo } of spaceOnlyLines) {
+        makeIndentationMark(
+          spaceFrom,
+          spaceTo,
+          currentIndent,
+          tabSize,
+          builder
+        );
+        makeIndentationWidget(spaceFrom, spaceTo, tabSize, builder);
+      }
+      spaceOnlyLines.length = 0;
+      makeIndentationMark(from, to, indent, tabSize, builder);
+    }
+  }
+  return builder.finish();
+}
+var showIndentations = ViewPlugin4.fromClass(
+  class {
+    decorations;
+    constructor(view) {
+      this.decorations = makeIndentationDecorators(view);
+    }
+    update(update) {
+      if (update.docChanged || update.viewportChanged) {
+        this.decorations = makeIndentationDecorators(update.view);
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);
+var indentationTheme = EditorView3.baseTheme({
+  ".cm-line": {
+    paddingLeft: 0,
+    marginLeft: "2px"
+  },
+  ".cm-indentation-guide": {
+    position: "relative"
+  },
+  ".cm-indentation-guide:after": {
+    position: "absolute",
+    content: "''",
+    right: "0.9ch",
+    height: "1.4em",
+    borderLeft: "1px solid rgba(28, 31, 35, .08)"
+  },
+  ...fromPairs(
+    indentationLevelMarks.map((_decoration, i) => [
+      `.cm-indentation-level-${i}`,
+      { textIndent: `-${i * 2}ch`, paddingLeft: `${i * 2}ch` }
+    ])
+  )
+});
+var indentGuides = () => [showIndentations, indentationTheme];
+
+// src/scroll-beyond-last-line/index.ts
+import { EditorView as EditorView4, layer as layer2 } from "@codemirror/view";
+
+// src/scroll-beyond-last-line/empty-block.ts
+var EmptyBlock = class {
+  constructor(lineNumber, contentHeight, scrollHeight) {
+    this.lineNumber = lineNumber;
+    this.contentHeight = contentHeight;
+    this.scrollHeight = scrollHeight;
+  }
+  draw() {
+    const elt = document.createElement("div");
+    elt.className = "cm-empty-scroll-block-maker";
+    this.adjust(elt);
+    return elt;
+  }
+  update(_, prev) {
+    return prev.lineNumber === this.lineNumber && prev.contentHeight === this.contentHeight && prev.scrollHeight === this.scrollHeight;
+  }
+  adjust(elt) {
+    elt.style.display = "block";
+    elt.style.width = "1px";
+    if (this.lineNumber > 1) {
+      elt.style.height = `calc(${typeof this.scrollHeight === "number" ? `${this.scrollHeight}px` : "100%"} + ${this.contentHeight}px)`;
+    } else {
+      elt.style.height = "0";
+    }
+  }
+  eq(p) {
+    return this.lineNumber === p.lineNumber && this.contentHeight === p.contentHeight && this.scrollHeight === p.scrollHeight;
+  }
+};
+
+// src/scroll-beyond-last-line/index.ts
+var scrollBeyondLastLine = (scrollHeight) => [
+  layer2({
+    above: false,
+    updateOnDocViewUpdate: true,
+    class: "cm-empty-marker-layer",
+    update(update) {
+      return update.state.doc.lines !== update.startState.doc.lines;
+    },
+    markers(view) {
+      const maker = new EmptyBlock(
+        view.state.doc.lines,
+        view.contentHeight,
+        scrollHeight
+      );
+      return [maker];
+    }
+  }),
+  EditorView4.theme({
+    "& .cm-empty-marker-layer": {
+      height: "100%"
+    }
+  })
+];
+
+// src/brackets/matching-brackets.ts
+import { Decoration as Decoration4, EditorView as EditorView5 } from "@codemirror/view";
+import { StateField as StateField2 } from "@codemirror/state";
+var pairs = {
+  "(": ")",
+  "{": "}",
+  "[": "]",
+  ")": "(",
+  "}": "{",
+  "]": "["
+};
+var findMatchingBracket = (state, cursorPos) => {
+  try {
+    const doc = state.doc.toString();
+    let stack = [];
+    let leftIndex = -1;
+    let rightIndex = -1;
+    for (let i = cursorPos - 1; i >= 0; i--) {
+      const char = doc[i];
+      if (pairs[char]) {
+        if ([")", "}", "]"].includes(char)) {
+          stack.push(char);
+        } else {
+          if (stack.length === 0) {
+            leftIndex = i;
+            break;
+          }
+          const lastBracket = stack.pop();
+          if (pairs[char] !== lastBracket) {
+            return null;
+          }
+        }
+      }
+    }
+    stack = [];
+    for (let i = cursorPos; i < doc.length; i++) {
+      const char = doc[i];
+      if (pairs[char]) {
+        if (["(", "{", "["].includes(char)) {
+          stack.push(char);
+        } else {
+          if (stack.length === 0) {
+            rightIndex = i;
+            break;
+          }
+          const lastBracket = stack.pop();
+          if (pairs[char] !== lastBracket) {
+            return null;
+          }
+        }
+      }
+    }
+    if (leftIndex !== -1 && rightIndex !== -1) {
+      return [leftIndex, rightIndex];
+    }
+    return null;
+  } catch (e) {
+    console.error("findMatchingBracket failed", e);
+    return null;
+  }
+};
+var renderMatch = (match) => {
+  const decorations = [];
+  const mark = Decoration4.mark({ class: "cm-matchingBracket" });
+  decorations.push(mark.range(match, match + 1));
+  return decorations;
+};
+var bracketMatchingState = StateField2.define({
+  create() {
+    return Decoration4.none;
+  },
+  update(deco, tr) {
+    if (!tr.docChanged && !tr.selection) {
+      return deco;
+    }
+    let decorations = [];
+    for (const range2 of tr.state.selection.ranges) {
+      if (!range2.empty) {
+        continue;
+      }
+      const match = findMatchingBracket(tr.state, range2.head);
+      if (match) {
+        decorations = decorations.concat(
+          renderMatch(match[0]),
+          renderMatch(match[1])
+        );
+      }
+    }
+    return Decoration4.set(decorations, true);
+  },
+  provide: (f) => EditorView5.decorations.from(f)
+});
+var matchingBrackets = [bracketMatchingState];
+
+// src/brackets/colorization.ts
+import {
+  EditorView as EditorView6,
+  Decoration as Decoration5,
+  ViewPlugin as ViewPlugin5
+} from "@codemirror/view";
+import { syntaxTree as syntaxTree4 } from "@codemirror/language";
+var DEFAULT_COLORS = ["#ffd700", "#da70d6", "#179fff"];
+var ColorizationBracketsPlugin = ViewPlugin5.fromClass(
+  class {
+    decorations;
+    constructor(view) {
+      this.decorations = this.getBracketDecorations(view);
+    }
+    update(update) {
+      if (update.docChanged || update.selectionSet || update.viewportChanged) {
+        this.decorations = this.getBracketDecorations(update.view);
+      }
+    }
+    getBracketDecorations(view) {
+      const { doc } = view.state;
+      const decorations = [];
+      const stack = [];
+      const limitNodeType = ["Comment", "String"];
+      const tree = syntaxTree4(view.state);
+      for (let pos = 0; pos < doc.length; pos += 1) {
+        const char = doc.sliceString(pos, pos + 1);
+        const node = tree.resolveInner(pos);
+        if (limitNodeType.includes(node.type.name)) {
+          continue;
+        }
+        if (char === "(" || char === "[" || char === "{") {
+          stack.push({ type: char, from: pos });
+        } else if (char === ")" || char === "]" || char === "}") {
+          const open = stack.pop();
+          if (open && open.type === this.getMatchingBracket(char)) {
+            const index = stack.length % 3;
+            decorations.push(
+              Decoration5.mark({ class: `colorization-bracket-${index}` }).range(
+                open.from,
+                open.from + 1
+              ),
+              Decoration5.mark({ class: `colorization-bracket-${index}` }).range(
+                pos,
+                pos + 1
+              )
+            );
+          }
+        }
+      }
+      decorations.sort((a, b) => a.from - b.from || a.startSide - b.startSide);
+      return Decoration5.set(decorations);
+    }
+    getMatchingBracket(closingBracket) {
+      switch (closingBracket) {
+        case ")":
+          return "(";
+        case "]":
+          return "[";
+        case "}":
+          return "{";
+        default:
+          return null;
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);
+var colorizationBrackets = [
+  ColorizationBracketsPlugin,
+  EditorView6.baseTheme({
+    ".colorization-bracket-0": { color: DEFAULT_COLORS[0] },
+    ".colorization-bracket-0 > span": { color: DEFAULT_COLORS[0] },
+    ".colorization-bracket-1": { color: DEFAULT_COLORS[1] },
+    ".colorization-bracket-1 > span": { color: DEFAULT_COLORS[1] },
+    ".colorization-bracket-2": { color: DEFAULT_COLORS[2] },
+    ".colorization-bracket-2 > span": { color: DEFAULT_COLORS[2] }
+  })
+];
+
+// src/position/index.ts
+import {
+  Direction,
+  layer as layer3
+} from "@codemirror/view";
+import { Facet as Facet7 } from "@codemirror/state";
+var SelectionSide = /* @__PURE__ */ ((SelectionSide2) => {
+  SelectionSide2["Head"] = "head";
+  SelectionSide2["Anchor"] = "anchor";
+  return SelectionSide2;
+})(SelectionSide || {});
+var elementAtPosition = Facet7.define();
+function configChanged2(update) {
+  return update.startState.facet(elementAtPosition) !== update.state.facet(elementAtPosition);
+}
+var PositionMarker = class {
+  constructor(dom, rect) {
+    this.dom = dom;
+    this.rect = rect;
+  }
+  eq(marker) {
+    return Boolean(
+      (!this.rect && !marker.rect || this.rect && marker.rect && this.rect.left === marker.rect.left && this.rect.top === marker.rect.top && this.rect.width === marker.rect.width && this.rect.height === marker.rect.height) && this.dom === marker.dom
+    );
+  }
+  draw() {
+    this.adjust(this.dom);
+    return this.dom;
+  }
+  update() {
+    this.adjust(this.dom);
+    return true;
+  }
+  adjust(elt) {
+    elt.style.pointerEvents = "none";
+    if (!this.rect) {
+      return;
+    }
+    elt.style.left = `${this.rect.left}px`;
+    elt.style.top = `${this.rect.top}px`;
+    elt.style.width = `${this.rect.width}px`;
+    elt.style.height = `${this.rect.height}px`;
+  }
+};
+function getBase(view) {
+  const rect = view.scrollDOM.getBoundingClientRect();
+  const left = view.textDirection === Direction.LTR ? rect.left : rect.right - view.scrollDOM.clientWidth * view.scaleX;
+  return {
+    left: left - view.scrollDOM.scrollLeft * view.scaleX,
+    top: rect.top - view.scrollDOM.scrollTop * view.scaleY
+  };
+}
+var positionElementLayer = layer3({
+  above: true,
+  markers(view) {
+    const elements = view.state.facet(elementAtPosition);
+    if (!elements || elements.length === 0) {
+      return [];
+    }
+    const base = getBase(view);
+    const temp = [];
+    const markers = [];
+    for (const { dom, pos } of elements) {
+      if (!dom) {
+        continue;
+      }
+      let finalPos = -1;
+      if (typeof pos === "function") {
+        finalPos = pos(view);
+      } else if (typeof pos === "number") {
+        finalPos = pos;
+      } else if (pos === "head" /* Head */) {
+        finalPos = view.state.selection.main.head;
+      } else if (pos === "anchor" /* Anchor */) {
+        finalPos = view.state.selection.main.anchor;
+      }
+      const coords = view.coordsAtPos(finalPos);
+      if (coords) {
+        temp.push(coords);
+        const width = 1;
+        const left = coords.left - base.left - width / 2;
+        const top = coords.top - base.top;
+        const height = coords.bottom - coords.top;
+        markers.push(new PositionMarker(dom, { left, top, width, height }));
+      } else {
+        markers.push(new PositionMarker(dom));
+      }
+    }
+    return markers;
+  },
+  update(update) {
+    return update.docChanged || update.selectionSet || update.viewportChanged || configChanged2(update);
+  },
+  class: "cm-positionReferenceLayer"
+});
+
+// src/mergeable-markers/index.ts
+import { Decoration as Decoration6, EditorView as EditorView7 } from "@codemirror/view";
+import { Facet as Facet8, RangeSetBuilder as RangeSetBuilder3 } from "@codemirror/state";
+
+// src/mergeable-markers/squash.ts
+function squash2(decorations) {
+  const result = [];
+  const grouped = groupDecorationsByClassName2(decorations);
+  grouped.forEach((decos, className) => {
+    const merged = mergeIntervals3(decos);
+    result.push(
+      ...merged.map((m) => ({
+        from: m.start,
+        to: m.end,
+        className
+      }))
+    );
+  });
+  result.sort((a, b) => a.from - b.from);
+  return result;
+}
+function groupDecorationsByClassName2(decorations) {
+  const map = /* @__PURE__ */ new Map();
+  decorations.forEach((deco) => {
+    if (!map.has(deco.className)) {
+      map.set(deco.className, []);
+    }
+    map.get(deco.className).push(deco);
+  });
+  return map;
+}
+function mergeIntervals3(decorations) {
+  const merged = [];
+  const cloned = decorations.map((deco) => ({
+    start: deco.from,
+    end: deco.to
+  }));
+  cloned.sort((a, b) => a.start - b.start);
+  let current = cloned[0];
+  for (let i = 1; i < cloned.length; i++) {
+    const next = cloned[i];
+    if (next.start <= current.end) {
+      current.end = Math.max(current.end, next.end);
+    } else {
+      merged.push(current);
+      current = next;
+    }
+  }
+  merged.push(current);
+  return merged;
+}
+
+// src/mergeable-markers/index.ts
+var cache = /* @__PURE__ */ new Map();
+function getClassNameDecoration(className) {
+  const cacheKey = className;
+  if (!cache.has(cacheKey)) {
+    const mark = Decoration6.mark({ class: className });
+    cache.set(cacheKey, mark);
+  }
+  return cache.get(cacheKey);
+}
+var mergeableMarkers = Facet8.define({
+  combine(specs) {
+    const builder = new RangeSetBuilder3();
+    const flattened = specs.reduce(
+      (memo, current) => [...memo, ...current],
+      []
+    );
+    for (const spec of squash2(flattened)) {
+      const decoration = getClassNameDecoration(spec.className);
+      builder.add(spec.from, spec.to, decoration);
+    }
+    return builder.finish();
+  },
+  enables(self) {
+    return EditorView7.decorations.compute([self], (state) => state.facet(self));
+  }
+});
+
+// src/frozen-ranges/extension.ts
+import { hasOverlap as hasOverlap3 } from "@coze-editor/utils";
+import { EditorSelection as EditorSelection4, EditorState as EditorState3, Facet as Facet9 } from "@codemirror/state";
+var extension4 = [
+  // 禁止编辑
+  EditorState3.changeFilter.of((tr) => {
+    const providers = tr.startState.facet(frozenRanges);
+    const specs = providers.reduce(
+      (memo, provider) => [...memo, ...provider(tr.startState)],
+      []
+    );
+    if (Array.isArray(specs)) {
+      const flattened = specs.reduce(
+        (memo, current) => [...memo, current.from, current.to],
+        []
+      );
+      return flattened;
+    }
+    return true;
+  }),
+  // forbid cursor move into frozen ranges
+  EditorState3.transactionFilter.of((tr) => {
+    const len = tr.startState.doc.length;
+    const providers = tr.startState.facet(frozenRanges);
+    const specs = providers.reduce((memo, provider) => [...memo, ...provider(tr.state)], []).filter(
+      (spec) => spec.from >= 0 && spec.from < len && spec.to >= 0 && spec.to < len
+    );
+    let { newSelection } = tr;
+    newSelection.ranges.forEach((range2, index) => {
+      for (const spec of specs) {
+        if (range2.empty && range2.from > spec.from && range2.to < spec.to) {
+          newSelection = newSelection.replaceRange(
+            EditorSelection4.cursor(
+              range2.assoc > 0 ? spec.from : spec.to,
+              range2.assoc
+            ),
+            index
+          );
+        }
+        if (!range2.empty && hasOverlap3(range2, spec)) {
+          const isReversed = range2.head < range2.anchor;
+          if (
+            // anchor at left
+            range2.anchor < spec.from
+          ) {
+            newSelection = newSelection.replaceRange(
+              EditorSelection4.range(
+                range2.anchor,
+                spec.from,
+                range2.goalColumn,
+                range2.bidiLevel ?? void 0
+              ),
+              index
+            );
+          } else if (
+            // anchor at right
+            range2.anchor > spec.to
+          ) {
+            newSelection = newSelection.replaceRange(
+              EditorSelection4.range(
+                range2.anchor,
+                spec.to,
+                range2.goalColumn,
+                range2.bidiLevel ?? void 0
+              ),
+              index
+            );
+          } else if (
+            // anchor inside
+            range2.anchor >= spec.from && range2.anchor <= spec.to
+          ) {
+            if (isReversed) {
+              newSelection = newSelection.replaceRange(
+                EditorSelection4.range(
+                  spec.from,
+                  Math.min(range2.head, spec.from),
+                  range2.goalColumn,
+                  range2.bidiLevel ?? void 0
+                ),
+                index
+              );
+            } else {
+              newSelection = newSelection.replaceRange(
+                EditorSelection4.range(
+                  spec.to,
+                  Math.max(range2.head, spec.to),
+                  range2.goalColumn,
+                  range2.bidiLevel ?? void 0
+                ),
+                index
+              );
+            }
+          }
+        }
+      }
+    });
+    if (newSelection.eq(tr.newSelection)) {
+      return tr;
+    }
+    return [
+      tr,
+      {
+        selection: newSelection
+      }
+    ];
+  })
+];
+var frozenRanges = Facet9.define({
+  enables: () => extension4
+});
+export {
+  FocusableWidget,
+  SelectionSide,
+  astDebugger,
+  astDecorator,
+  rangesFacet as autoSelectRanges,
+  selectUserEvent as autoSelectUserEvent,
+  backgroundDecorations,
+  colorizationBrackets,
+  deletionEnlarger,
+  elementAtPosition,
+  focusableKeymap,
+  frozenRanges,
+  indentGuides,
+  inputRules,
+  matchingBrackets,
+  mergeableMarkers,
+  mixLanguages,
+  positionElementLayer,
+  scrollBeyondLastLine,
+  selectionEnlarger,
+  updateWholeDecorations
+};
+//# sourceMappingURL=index.js.map