@coze-editor/extensions 0.1.0-alpha.0fd19e

package/dist/index.js

@@ -0,0 +1,1305 @@
+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, {
+  FocusableWidget: () => FocusableWidget,
+  SelectionSide: () => SelectionSide,
+  astDebugger: () => astDebugger,
+  astDecorator: () => astDecorator,
+  autoSelectRanges: () => rangesFacet,
+  autoSelectUserEvent: () => selectUserEvent,
+  backgroundDecorations: () => backgroundDecorations,
+  colorizationBrackets: () => colorizationBrackets,
+  deletionEnlarger: () => deletionEnlarger,
+  elementAtPosition: () => elementAtPosition,
+  focusableKeymap: () => focusableKeymap,
+  indentGuides: () => indentGuides,
+  inputRules: () => inputRules,
+  matchingBrackets: () => matchingBrackets,
+  mergeableMarkers: () => mergeableMarkers,
+  mixLanguages: () => mixLanguages,
+  positionElementLayer: () => positionElementLayer,
+  scrollBeyondLastLine: () => scrollBeyondLastLine,
+  selectionEnlarger: () => selectionEnlarger,
+  updateWholeDecorations: () => updateWholeDecorations
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ast-decorator/whole.ts
+var import_es_toolkit = require("es-toolkit");
+var import_utils = require("@coze-editor/utils");
+var import_view2 = require("@codemirror/view");
+var import_state2 = require("@codemirror/state");
+var import_language = require("@codemirror/language");
+
+// src/background-decorations/index.ts
+var import_view = require("@codemirror/view");
+var import_state = require("@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 = (0, import_view.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) => import_view.RectangleMarker.forRange(
+        view,
+        deco.className,
+        import_state.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 = import_state.Facet.define({
+  enables: [backgroundDecoratorLayer]
+});
+
+// src/ast-decorator/whole.ts
+var updateWholeDecorationsEffect = import_state2.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,
+      import_view2.Decoration.mark({
+        class: className
+      })
+    );
+  }
+  return classNameDecorationCache.get(className);
+}
+function buildDecorations(state, tree) {
+  const decorates = state.facet(wholeASTDecoratorFacet) ?? [];
+  const treeCursor = tree.cursor();
+  const decorations = {
+    highest: import_view2.Decoration.none,
+    high: import_view2.Decoration.none,
+    default: import_view2.Decoration.none,
+    low: import_view2.Decoration.none,
+    lowest: import_view2.Decoration.none
+  };
+  let atomicRanges = import_state2.RangeSet.empty;
+  let backgroundDecorations2 = [];
+  const from = 0;
+  const to = state.doc.length;
+  (0, import_utils.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 = import_view2.Decoration.replace(
+        (0, import_es_toolkit.omit)(decorationSpec, omitKeys)
+      ).range(from, to);
+      break;
+    case "widget":
+      decorationRange = import_view2.Decoration.widget((0, import_es_toolkit.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 = import_state2.StateField.define({
+  create(state) {
+    return buildDecorations(state, (0, import_language.syntaxTree)(state));
+  },
+  update(value, tr) {
+    const tree = (0, import_language.syntaxTree)(tr.state);
+    const hasUpdateEffect = tr.effects.some(
+      (effect) => effect.is(updateWholeDecorationsEffect)
+    );
+    const syntaxTreeChanged = (0, import_language.syntaxTree)(tr.startState) !== tree;
+    if (syntaxTreeChanged || hasUpdateEffect) {
+      value = buildDecorations(tr.state, tree);
+    }
+    return value;
+  },
+  provide(field) {
+    return [
+      import_state2.Prec.highest(
+        import_view2.EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.highest
+        )
+      ),
+      import_state2.Prec.high(
+        import_view2.EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.high
+        )
+      ),
+      import_state2.Prec.default(
+        import_view2.EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.default
+        )
+      ),
+      import_state2.Prec.low(
+        import_view2.EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.low
+        )
+      ),
+      import_state2.Prec.lowest(
+        import_view2.EditorView.decorations.compute(
+          [field],
+          (state) => state.field(field).decorations.lowest
+        )
+      ),
+      import_view2.EditorView.atomicRanges.of((view) => view.state.field(field).atomicRanges),
+      backgroundDecorations.of(
+        (view) => view.state.field(field).backgroundDecorations
+      )
+    ];
+  }
+});
+var wholeASTDecoratorFacet = import_state2.Facet.define({
+  enables: [decorateField, backgroundDecoratorLayer]
+});
+
+// src/ast-decorator/cursor.ts
+var import_view3 = require("@codemirror/view");
+var import_state3 = require("@codemirror/state");
+var import_language2 = require("@codemirror/language");
+var CursorASTView = class {
+  constructor(view) {
+    this.view = view;
+  }
+  classNameDecorationCache = /* @__PURE__ */ new Map();
+  decorations = import_view3.Decoration.none;
+  backgroundDecorations = [];
+  getClassDecoration(className) {
+    if (!this.classNameDecorationCache.has(className)) {
+      this.classNameDecorationCache.set(
+        className,
+        import_view3.Decoration.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 = (0, import_language2.syntaxTree)(update.state);
+      const pos = update.state.selection.main.head;
+      const decorators = update.state.facet(cursorASTDecoratorFacet);
+      const cursor = tree.cursorAt(pos, 0);
+      const builder = new import_state3.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 = import_view3.Decoration.none;
+      this.backgroundDecorations = [];
+    }
+  }
+};
+var cursorASTDecoratorFacet = import_state3.Facet.define({
+  enables: [
+    import_view3.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
+var import_utils2 = require("@coze-editor/utils");
+var import_view4 = require("@codemirror/view");
+var import_language3 = require("@codemirror/language");
+var astDebugger = import_view4.ViewPlugin.fromClass(
+  class {
+    constructor(view) {
+      printTreeFromState(view.state);
+    }
+    update(update) {
+      if (update.docChanged) {
+        printTreeFromState(update.state);
+      }
+    }
+  }
+);
+function printTreeFromState(state) {
+  const tree = (0, import_language3.syntaxTree)(state);
+  console.groupCollapsed("Syntax Tree");
+  const cursor = tree.cursor();
+  (0, import_utils2.traverseAST)(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
+var import_view5 = require("@codemirror/view");
+var focusableKeymap = import_view5.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 import_view5.WidgetType {
+};
+
+// src/auto-select-ranges/extension.ts
+var import_utils3 = require("@coze-editor/utils");
+var import_view6 = require("@codemirror/view");
+var import_state4 = require("@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 = import_view6.ViewPlugin.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(
+          (0, import_utils3.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(
+                import_state4.EditorSelection.range(currentRange.from, currentRange.to)
+              )
+            });
+          });
+        }
+      }
+      if (this.lastFocus !== update.view.hasFocus) {
+        this.lastFocus = update.view.hasFocus;
+      }
+    }
+  }
+);
+var rangesFacet = import_state4.Facet.define({
+  enables: extension
+});
+var selectUserEvent = import_state4.Facet.define({
+  combine: import_utils3.FacetCombineStrategy.Last
+});
+
+// src/selection-enlarger/extension.ts
+var import_utils5 = require("@coze-editor/utils");
+var import_state5 = require("@codemirror/state");
+var extension2 = import_state5.EditorState.transactionFilter.of((tr) => {
+  if (tr.docChanged || tr.newSelection.eq(tr.startState.selection)) {
+    return tr;
+  }
+  const providers = tr.startState.facet(selectionEnlarger);
+  const specs = (0, import_utils5.flatten)(providers.map((provider) => provider(tr.startState)));
+  let { newSelection } = tr;
+  newSelection.ranges.forEach((range2, index) => {
+    for (const spec of specs) {
+      if ((0, import_utils5.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 ? import_state5.EditorSelection.range(
+          to,
+          from,
+          range2.goalColumn,
+          range2.bidiLevel ?? void 0
+        ) : import_state5.EditorSelection.range(
+          from,
+          to,
+          range2.goalColumn,
+          range2.bidiLevel ?? void 0
+        );
+        newSelection = newSelection.replaceRange(newRange, index);
+      }
+    }
+  });
+  return [
+    tr,
+    {
+      selection: newSelection
+    }
+  ];
+});
+var selectionEnlarger = import_state5.Facet.define({
+  enables: extension2
+});
+
+// src/deletion-enlarger/extension.ts
+var import_utils6 = require("@coze-editor/utils");
+var import_state6 = require("@codemirror/state");
+var extension3 = import_state6.EditorState.transactionFilter.of((tr) => {
+  const providers = tr.startState.facet(deletionEnlarger);
+  const specs = (0, import_utils6.flatten)(providers.map((provider) => provider(tr.startState)));
+  const { length } = tr.startState.doc;
+  let changes = import_state6.ChangeSet.empty(length);
+  tr.changes.iterChanges((fromA, toA, fromB, toB) => {
+    const isDeletion = fromB === toB;
+    if (!isDeletion) {
+      return;
+    }
+    for (const spec of specs) {
+      if ((0, import_utils6.hasOverlap)(
+        {
+          from: fromA,
+          to: toA
+        },
+        spec.source
+      )) {
+        const change = import_state6.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 = import_state6.Facet.define({
+  enables: extension3
+});
+
+// src/input-rules/index.ts
+var import_view7 = require("@codemirror/view");
+var import_state7 = require("@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 import_view7.EditorView.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 import_state7.Prec.high(ruleExtensions);
+};
+
+// src/mix-languages/mix.ts
+var import_common = require("@lezer/common");
+var import_lezer_parser_template = require("@coze-editor/lezer-parser-template");
+var import_language4 = require("@codemirror/language");
+function mixLanguages({ name, outerLanguage, innerLanguage }) {
+  return import_language4.LRLanguage.define({
+    name,
+    parser: import_lezer_parser_template.parser.configure({
+      wrap: (0, import_common.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
+var import_es_toolkit2 = require("es-toolkit");
+var import_view8 = require("@codemirror/view");
+var import_state8 = require("@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 = import_view8.Decoration.mark({ class: "cm-indentation-guide" });
+var indentationLevelMarks = (0, import_es_toolkit2.range)(20).map(
+  (i) => import_view8.Decoration.line({ class: `cm-indentation-level-${i}` })
+);
+var IndentationWidget = class _IndentationWidget extends import_view8.WidgetType {
+  constructor(indents) {
+    super();
+    this.indents = indents;
+  }
+  static create(indents) {
+    return import_view8.Decoration.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 import_state8.RangeSetBuilder();
+  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 = import_view8.ViewPlugin.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 = import_view8.EditorView.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
+var import_view9 = require("@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) => [
+  (0, import_view9.layer)({
+    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];
+    }
+  }),
+  import_view9.EditorView.theme({
+    "& .cm-empty-marker-layer": {
+      height: "100%"
+    }
+  })
+];
+
+// src/brackets/matching-brackets.ts
+var import_view10 = require("@codemirror/view");
+var import_state9 = require("@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 = import_view10.Decoration.mark({ class: "cm-matchingBracket" });
+  decorations.push(mark.range(match, match + 1));
+  return decorations;
+};
+var bracketMatchingState = import_state9.StateField.define({
+  create() {
+    return import_view10.Decoration.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 import_view10.Decoration.set(decorations, true);
+  },
+  provide: (f) => import_view10.EditorView.decorations.from(f)
+});
+var matchingBrackets = [bracketMatchingState];
+
+// src/brackets/colorization.ts
+var import_view11 = require("@codemirror/view");
+var import_language5 = require("@codemirror/language");
+var DEFAULT_COLORS = ["#ffd700", "#da70d6", "#179fff"];
+var ColorizationBracketsPlugin = import_view11.ViewPlugin.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 = (0, import_language5.syntaxTree)(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(
+              import_view11.Decoration.mark({ class: `colorization-bracket-${index}` }).range(
+                open.from,
+                open.from + 1
+              ),
+              import_view11.Decoration.mark({ class: `colorization-bracket-${index}` }).range(
+                pos,
+                pos + 1
+              )
+            );
+          }
+        }
+      }
+      decorations.sort((a, b) => a.from - b.from || a.startSide - b.startSide);
+      return import_view11.Decoration.set(decorations);
+    }
+    getMatchingBracket(closingBracket) {
+      switch (closingBracket) {
+        case ")":
+          return "(";
+        case "]":
+          return "[";
+        case "}":
+          return "{";
+        default:
+          return null;
+      }
+    }
+  },
+  {
+    decorations: (v) => v.decorations
+  }
+);
+var colorizationBrackets = [
+  ColorizationBracketsPlugin,
+  import_view11.EditorView.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
+var import_view12 = require("@codemirror/view");
+var import_state10 = require("@codemirror/state");
+var SelectionSide = /* @__PURE__ */ ((SelectionSide2) => {
+  SelectionSide2["Head"] = "head";
+  SelectionSide2["Anchor"] = "anchor";
+  return SelectionSide2;
+})(SelectionSide || {});
+var elementAtPosition = import_state10.Facet.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 === import_view12.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 = (0, import_view12.layer)({
+  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
+var import_view13 = require("@codemirror/view");
+var import_state11 = require("@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 = import_view13.Decoration.mark({ class: className });
+    cache.set(cacheKey, mark);
+  }
+  return cache.get(cacheKey);
+}
+var mergeableMarkers = import_state11.Facet.define({
+  combine(specs) {
+    const builder = new import_state11.RangeSetBuilder();
+    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 import_view13.EditorView.decorations.compute([self], (state) => state.facet(self));
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FocusableWidget,
+  SelectionSide,
+  astDebugger,
+  astDecorator,
+  autoSelectRanges,
+  autoSelectUserEvent,
+  backgroundDecorations,
+  colorizationBrackets,
+  deletionEnlarger,
+  elementAtPosition,
+  focusableKeymap,
+  indentGuides,
+  inputRules,
+  matchingBrackets,
+  mergeableMarkers,
+  mixLanguages,
+  positionElementLayer,
+  scrollBeyondLastLine,
+  selectionEnlarger,
+  updateWholeDecorations
+});
+//# sourceMappingURL=index.js.map