@editora/light-code-editor 1.0.1

package/dist/index.es.js

@@ -0,0 +1,1116 @@
+class m {
+  constructor(e = "") {
+    this._lines = [], this._version = 0, this.setText(e);
+  }
+  // Get line at index
+  getLine(e) {
+    return this._lines[e] || "";
+  }
+  // Get all lines
+  getLines() {
+    return [...this._lines];
+  }
+  // Get total number of lines
+  getLineCount() {
+    return this._lines.length;
+  }
+  // Get total text content
+  getText() {
+    return this._lines.join(`
+`);
+  }
+  // Set entire text content
+  setText(e) {
+    this._lines = e.split(`
+`), this._version++;
+  }
+  // Get text in a range
+  getTextInRange(e) {
+    if (e.start.line === e.end.line)
+      return this.getLine(e.start.line).substring(e.start.column, e.end.column);
+    const t = [];
+    t.push(this.getLine(e.start.line).substring(e.start.column));
+    for (let n = e.start.line + 1; n < e.end.line; n++)
+      t.push(this.getLine(n));
+    return e.end.line < this.getLineCount() && t.push(this.getLine(e.end.line).substring(0, e.end.column)), t.join(`
+`);
+  }
+  // Replace text in range
+  replaceRange(e, t) {
+    const n = this.getTextInRange(e);
+    if (e.start.line === e.end.line) {
+      const i = this.getLine(e.start.line), s = i.substring(0, e.start.column) + t + i.substring(e.end.column);
+      this._lines[e.start.line] = s;
+    } else {
+      const i = this.getLine(e.start.line), s = this.getLine(e.end.line), o = i.substring(0, e.start.column) + t, h = s.substring(e.end.column), r = t.split(`
+`);
+      r[0] = o + r[0], r[r.length - 1] = r[r.length - 1] + h, this._lines.splice(e.start.line, e.end.line - e.start.line + 1, ...r);
+    }
+    return this._version++, { range: e, text: t, oldText: n };
+  }
+  // Insert text at position
+  insertText(e, t) {
+    const n = { start: e, end: e };
+    return this.replaceRange(n, t);
+  }
+  // Delete text in range
+  deleteRange(e) {
+    return this.replaceRange(e, "");
+  }
+  // Convert position to offset
+  positionToOffset(e) {
+    let t = 0;
+    for (let n = 0; n < e.line; n++)
+      t += this.getLine(n).length + 1;
+    return t += e.column, t;
+  }
+  // Convert offset to position
+  offsetToPosition(e) {
+    let t = e;
+    for (let n = 0; n < this.getLineCount(); n++) {
+      const i = this.getLine(n).length;
+      if (t <= i)
+        return { line: n, column: t };
+      t -= i + 1;
+    }
+    return {
+      line: this.getLineCount() - 1,
+      column: this.getLine(this.getLineCount() - 1).length
+    };
+  }
+  // Validate position
+  isValidPosition(e) {
+    return !(e.line < 0 || e.line >= this.getLineCount() || e.column < 0 || e.column > this.getLine(e.line).length);
+  }
+  // Validate range
+  isValidRange(e) {
+    return this.isValidPosition(e.start) && this.isValidPosition(e.end);
+  }
+  // Get version for change tracking
+  getVersion() {
+    return this._version;
+  }
+  // Clone the model
+  clone() {
+    const e = new m();
+    return e._lines = [...this._lines], e._version = this._version, e;
+  }
+}
+class p {
+  constructor(e) {
+    this.gutterWidth = 50, this.lineHeight = 21, this.container = e, this.createDOM();
+  }
+  createDOM() {
+    this.container.innerHTML = "";
+    const e = document.createElement("div");
+    e.style.cssText = `
+      position: relative;
+      display: flex;
+      width: 100%;
+      height: 100%;
+      background: var(--editor-background, #1e1e1e);
+      color: var(--editor-foreground, #f8f9fa);
+      font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+      font-size: 14px;
+      line-height: ${this.lineHeight}px;
+      overflow: hidden;
+    `, this.lineNumbersElement = document.createElement("div"), this.lineNumbersElement.style.cssText = `
+      position: sticky;
+      left: 0;
+      top: 0;
+      width: ${this.gutterWidth}px;
+      background: var(--editor-gutter-background, #252526);
+      color: var(--editor-gutter-foreground, #858585);
+      padding: 0;
+      text-align: right;
+      border-right: 1px solid var(--editor-gutter-border, #3e3e42);
+      user-select: none;
+      overflow: hidden;
+      z-index: 1;
+    `, this.contentElement = document.createElement("div"), this.contentElement.style.cssText = `
+      flex: 1;
+      padding: 0;
+      background: transparent;
+      border: none;
+      outline: none;
+      white-space: pre;
+      overflow-x: auto;
+      overflow-y: auto;
+      min-height: 400px;
+      font-family: inherit;
+      font-size: inherit;
+      line-height: inherit;
+      color: inherit;
+      tab-size: 2;
+      -moz-tab-size: 2;
+    `, this.contentElement.contentEditable = "true", this.contentElement.spellcheck = !1, e.appendChild(this.lineNumbersElement), e.appendChild(this.contentElement), this.container.appendChild(e), this.updateLineNumbers(1);
+  }
+  // Update line numbers
+  updateLineNumbers(e) {
+    const t = Math.max(e, 20), n = Array.from({ length: t }, (i, s) => s + 1);
+    this.lineNumbersElement.innerHTML = n.map((i) => `<div style="height: ${this.lineHeight}px; line-height: ${this.lineHeight}px; padding-right: 12px;">${i}</div>`).join("");
+  }
+  // Get content element
+  getContentElement() {
+    return this.contentElement;
+  }
+  // Get line numbers element
+  getLineNumbersElement() {
+    return this.lineNumbersElement;
+  }
+  // Get text content
+  getText() {
+    return this.contentElement.textContent || "";
+  }
+  // Set text content
+  setText(e) {
+    this.contentElement.textContent = e;
+    const t = e.split(`
+`).length;
+    this.updateLineNumbers(t);
+  }
+  // Get cursor position from DOM selection
+  getCursorPosition() {
+    const e = window.getSelection();
+    if (!e || e.rangeCount === 0)
+      return { line: 0, column: 0 };
+    const t = e.getRangeAt(0), n = t.cloneRange();
+    n.selectNodeContents(this.contentElement), n.setEnd(t.endContainer, t.endOffset);
+    const s = n.toString().split(`
+`);
+    return {
+      line: s.length - 1,
+      column: s[s.length - 1].length
+    };
+  }
+  // Set cursor position
+  setCursorPosition(e) {
+    const n = this.getText().split(`
+`), i = Math.min(e.line, n.length - 1), s = Math.min(e.column, n[i]?.length || 0);
+    let o = 0;
+    for (let g = 0; g < i; g++)
+      o += n[g].length + 1;
+    o += s;
+    const h = document.createRange(), r = window.getSelection();
+    let l = 0, c = null, a = 0;
+    const u = document.createTreeWalker(
+      this.contentElement,
+      NodeFilter.SHOW_TEXT,
+      null
+    );
+    let f;
+    for (; f = u.nextNode(); ) {
+      const g = f.textContent?.length || 0;
+      if (l + g >= o) {
+        c = f, a = o - l;
+        break;
+      }
+      l += g;
+    }
+    if (c)
+      try {
+        h.setStart(c, a), h.setEnd(c, a), r?.removeAllRanges(), r?.addRange(h);
+      } catch (g) {
+        console.warn("Could not set cursor position:", g);
+      }
+  }
+  // Get selection range
+  getSelectionRange() {
+    const e = window.getSelection();
+    if (!e || e.rangeCount === 0 || e.isCollapsed)
+      return;
+    const t = e.getRangeAt(0), n = t.cloneRange();
+    n.selectNodeContents(this.contentElement), n.setEnd(t.startContainer, t.startOffset);
+    const s = n.toString().split(`
+`), o = t.cloneRange();
+    o.selectNodeContents(this.contentElement), o.setEnd(t.endContainer, t.endOffset);
+    const r = o.toString().split(`
+`);
+    return {
+      start: {
+        line: s.length - 1,
+        column: s[s.length - 1].length
+      },
+      end: {
+        line: r.length - 1,
+        column: r[r.length - 1].length
+      }
+    };
+  }
+  // Set selection range
+  setSelectionRange(e) {
+    this.setCursorPosition(e.start);
+  }
+  // Focus the editor
+  focus() {
+    this.contentElement.focus();
+  }
+  // Blur the editor
+  blur() {
+    this.contentElement.blur();
+  }
+  // Set read-only mode
+  setReadOnly(e) {
+    this.contentElement.contentEditable = e ? "false" : "true";
+  }
+  // Apply theme
+  applyTheme(e) {
+    Object.entries(e).forEach(([t, n]) => {
+      this.container.style.setProperty(`--${t}`, n);
+    });
+  }
+  // Scroll to position
+  scrollToPosition(e) {
+    const t = this.lineNumbersElement.children[e.line];
+    t && t.scrollIntoView({ block: "center", behavior: "smooth" });
+  }
+  // Get scroll position
+  getScrollTop() {
+    return this.contentElement.scrollTop;
+  }
+  // Set scroll position
+  setScrollTop(e) {
+    this.contentElement.scrollTop = e, this.lineNumbersElement.scrollTop = e;
+  }
+  // Destroy the view
+  destroy() {
+    this.container && this.container.parentNode && this.container.parentNode.removeChild(this.container);
+  }
+}
+class x {
+  constructor(e, t = {}) {
+    this.extensions = /* @__PURE__ */ new Map(), this.commands = /* @__PURE__ */ new Map(), this.eventListeners = /* @__PURE__ */ new Map(), this.folds = [], this.currentTheme = "default", this.isDestroyed = !1, this.config = {
+      value: "",
+      theme: "default",
+      readOnly: !1,
+      tabSize: 2,
+      lineWrapping: !1,
+      lineNumbers: !0,
+      ...t
+    }, this.textModel = new m(this.config.value), this.view = new p(e), this.view.setText(this.textModel.getText()), this.view.setReadOnly(this.config.readOnly || !1), this.setupEventHandlers(), this.config.extensions && this.config.extensions.forEach((n) => this.addExtension(n)), this.setTheme(this.config.theme);
+  }
+  // Public accessors for extensions
+  getTextModel() {
+    return this.textModel;
+  }
+  getView() {
+    return this.view;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  // Get keymap extension if available
+  getKeymapExtension() {
+    return this.extensions.get("keymap");
+  }
+  // Setup DOM event handlers
+  setupEventHandlers() {
+    const e = this.view.getContentElement();
+    e.addEventListener("input", () => {
+      const t = this.view.getText(), n = this.textModel.getText();
+      t !== n && (this.textModel.setText(t), this.emit("change", [{ range: this.getFullRange(), text: t, oldText: n }]), this.updateLineNumbers());
+    }), e.addEventListener("selectionchange", () => {
+      const t = this.getCursor(), n = this.getSelection();
+      this.emit("cursor", t), n && this.emit("selection", n);
+    }), e.addEventListener("keydown", (t) => {
+      this.emit("keydown", t);
+      for (const n of this.extensions.values())
+        if (n.onKeyDown && n.onKeyDown(t) === !1) {
+          t.preventDefault(), t.stopPropagation();
+          return;
+        }
+    }), e.addEventListener("mousedown", (t) => {
+      this.emit("mousedown", t);
+      for (const n of this.extensions.values())
+        if (n.onMouseDown && n.onMouseDown(t) === !1) {
+          t.preventDefault(), t.stopPropagation();
+          return;
+        }
+    }), e.addEventListener("focus", () => {
+      this.emit("focus");
+    }), e.addEventListener("blur", () => {
+      this.emit("blur");
+    });
+  }
+  // Update line numbers display
+  updateLineNumbers() {
+    const e = this.textModel.getLineCount();
+    this.view.updateLineNumbers(e);
+  }
+  // Get full range of document
+  getFullRange() {
+    return {
+      start: { line: 0, column: 0 },
+      end: {
+        line: this.textModel.getLineCount() - 1,
+        column: this.textModel.getLine(this.textModel.getLineCount() - 1).length
+      }
+    };
+  }
+  // Emit events to listeners
+  emit(e, ...t) {
+    const n = this.eventListeners.get(e);
+    n && n.forEach((i) => i(...t));
+  }
+  // State management
+  getValue() {
+    return this.textModel.getText();
+  }
+  setValue(e) {
+    this.textModel.setText(e), this.view.setText(e), this.updateLineNumbers(), this.emit("change", [{ range: this.getFullRange(), text: e, oldText: this.getValue() }]);
+  }
+  getState() {
+    return {
+      text: this.getValue(),
+      cursor: this.getCursor(),
+      selection: this.getSelection(),
+      readOnly: this.config.readOnly || !1,
+      theme: this.currentTheme
+    };
+  }
+  // Cursor & Selection
+  getCursor() {
+    const e = this.view.getCursorPosition();
+    return {
+      position: e,
+      anchor: e
+      // For now, cursor and anchor are the same
+    };
+  }
+  setCursor(e) {
+    this.view.setCursorPosition(e), this.emit("cursor", this.getCursor());
+  }
+  getSelection() {
+    return this.view.getSelectionRange();
+  }
+  setSelection(e) {
+    this.view.setSelectionRange(e), this.emit("selection", e);
+  }
+  // Configuration
+  setTheme(e) {
+    this.currentTheme = e;
+    const t = {
+      "editor-background": e === "dark" ? "#1e1e1e" : "#ffffff",
+      "editor-foreground": e === "dark" ? "#f8f9fa" : "#1a1a1a",
+      "editor-gutter-background": e === "dark" ? "#252526" : "#f8f9fa",
+      "editor-gutter-foreground": e === "dark" ? "#858585" : "#666666",
+      "editor-gutter-border": e === "dark" ? "#3e3e42" : "#e1e5e9"
+    };
+    this.view.applyTheme(t);
+  }
+  setReadOnly(e) {
+    this.config.readOnly = e, this.view.setReadOnly(e);
+  }
+  // Extensions & Commands
+  addExtension(e) {
+    if (this.extensions.has(e.name))
+      throw new Error(`Extension '${e.name}' already exists`);
+    this.extensions.set(e.name, e), e.setup(this);
+  }
+  removeExtension(e) {
+    const t = this.extensions.get(e);
+    t && t.destroy && t.destroy(), this.extensions.delete(e);
+  }
+  executeCommand(e, ...t) {
+    const n = this.commands.get(e);
+    n ? n(this, ...t) : console.warn(`Command '${e}' not found`);
+  }
+  // Register a command
+  registerCommand(e, t) {
+    this.commands.set(e, t);
+  }
+  // Search & Navigation
+  search(e, t = {}) {
+    const n = {
+      caseSensitive: !1,
+      regex: !1,
+      ...t
+    }, i = [], s = this.getValue();
+    s.split(`
+`);
+    let o = n.caseSensitive ? s : s.toLowerCase(), h = n.caseSensitive ? e : e.toLowerCase();
+    if (n.regex) {
+      const r = new RegExp(h, n.caseSensitive ? "g" : "gi");
+      let l;
+      for (; (l = r.exec(o)) !== null; ) {
+        const c = this.textModel.offsetToPosition(l.index), a = this.textModel.offsetToPosition(l.index + l[0].length);
+        i.push({
+          range: { start: c, end: a },
+          match: l[0]
+        });
+      }
+    } else {
+      let r = 0, l = o.indexOf(h, r);
+      for (; l !== -1; ) {
+        const c = l + e.length, a = this.textModel.offsetToPosition(l), u = this.textModel.offsetToPosition(c);
+        i.push({
+          range: { start: a, end: u },
+          match: s.substring(l, c)
+        }), r = c, l = o.indexOf(h, r);
+      }
+    }
+    return i;
+  }
+  replace(e, t) {
+    const n = this.textModel.replaceRange(e, t);
+    this.view.setText(this.getValue()), this.emit("change", [n]);
+  }
+  replaceAll(e, t, n = {}) {
+    const i = this.search(e, n);
+    let s = 0;
+    for (let o = i.length - 1; o >= 0; o--)
+      this.replace(i[o].range, t), s++;
+    return s;
+  }
+  // Folding (basic implementation)
+  fold(e) {
+    const t = {
+      start: e.start,
+      end: e.end,
+      collapsed: !0,
+      level: 0
+    };
+    this.folds.push(t);
+  }
+  unfold(e) {
+    this.folds = this.folds.filter(
+      (t) => !(t.start.line === e.start.line && t.end.line === e.end.line)
+    );
+  }
+  getFolds() {
+    return [...this.folds];
+  }
+  // Utilities
+  focus() {
+    this.view.focus();
+  }
+  blur() {
+    this.view.blur();
+  }
+  destroy() {
+    if (!this.isDestroyed) {
+      this.isDestroyed = !0;
+      for (const e of this.extensions.values())
+        e.destroy && e.destroy();
+      this.extensions.clear(), this.view.destroy(), this.commands.clear(), this.eventListeners.clear();
+    }
+  }
+  // Events
+  on(e, t) {
+    this.eventListeners.has(e) || this.eventListeners.set(e, []), this.eventListeners.get(e).push(t);
+  }
+  off(e, t) {
+    if (!this.eventListeners.has(e)) return;
+    const n = this.eventListeners.get(e);
+    if (t) {
+      const i = n.indexOf(t);
+      i !== -1 && n.splice(i, 1);
+    } else
+      n.length = 0;
+  }
+}
+class y {
+  constructor(e) {
+    this.name = "keymap", this.editor = null, this.keymap = {}, this.isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0, this.keymap = e || this.getDefaultKeymap();
+  }
+  setup(e) {
+    this.editor = e, e.on("keydown", (t) => this.handleKeyDown(t));
+  }
+  handleKeyDown(e) {
+    if (!this.editor) return;
+    const t = this.findMatchingBinding(e);
+    if (t)
+      return this.editor.executeCommand(t.command), e.preventDefault(), e.stopPropagation(), !1;
+  }
+  findMatchingBinding(e) {
+    const { key: t, ctrlKey: n, altKey: i, shiftKey: s, metaKey: o } = e, h = t.toLowerCase(), r = this.keymap[h];
+    if (!r) return null;
+    for (const l of r)
+      if ((l.ctrlKey === n || !l.ctrlKey && !n) && (l.altKey === i || !l.altKey && !i) && (l.shiftKey === s || !l.shiftKey && !s) && (l.metaKey === o || !l.metaKey && !o))
+        return l;
+    return null;
+  }
+  getDefaultKeymap() {
+    const e = {};
+    return this.addBinding(e, "f", { ctrlKey: !this.isMac, metaKey: this.isMac }, "find"), this.addBinding(e, "h", { ctrlKey: !this.isMac, metaKey: this.isMac }, "replace"), this.addBinding(e, "f3", {}, "findNext"), this.addBinding(e, "f3", { shiftKey: !0 }, "findPrev"), this.addBinding(e, "g", { ctrlKey: !this.isMac, metaKey: this.isMac }, "findNext"), this.addBinding(e, "[", { ctrlKey: !this.isMac, metaKey: this.isMac, shiftKey: !0 }, "fold"), this.addBinding(e, "]", { ctrlKey: !this.isMac, metaKey: this.isMac, shiftKey: !0 }, "unfold"), this.addBinding(e, "s", { ctrlKey: !this.isMac, metaKey: this.isMac }, "save"), this.addBinding(e, "z", { ctrlKey: !this.isMac, metaKey: this.isMac }, "undo"), this.addBinding(e, "y", { ctrlKey: !this.isMac, metaKey: this.isMac }, "redo"), this.addBinding(e, "z", { ctrlKey: !this.isMac, metaKey: this.isMac, shiftKey: !0 }, "redo"), this.addBinding(e, "t", { ctrlKey: !this.isMac, metaKey: this.isMac, shiftKey: !0 }, "toggleTheme"), e;
+  }
+  addBinding(e, t, n, i) {
+    const s = t.toLowerCase();
+    e[s] || (e[s] = []), e[s].push({
+      key: s,
+      command: i,
+      ...n
+    });
+  }
+  // Public API for customizing keymap
+  setKeymap(e) {
+    this.keymap = { ...e };
+  }
+  addKeyBinding(e) {
+    const t = e.key.toLowerCase();
+    this.keymap[t] || (this.keymap[t] = []), this.keymap[t] = this.keymap[t].filter((n) => n.command !== e.command), this.keymap[t].push({
+      ...e,
+      key: t
+    });
+  }
+  removeKeyBinding(e, t) {
+    const n = e.toLowerCase();
+    t ? this.keymap[n] && (this.keymap[n] = this.keymap[n].filter((i) => i.command !== t), this.keymap[n].length === 0 && delete this.keymap[n]) : delete this.keymap[n];
+  }
+  getKeymap() {
+    return { ...this.keymap };
+  }
+  getBindingsForCommand(e) {
+    const t = [];
+    for (const n in this.keymap)
+      for (const i of this.keymap[n])
+        i.command === e && t.push({ ...i });
+    return t;
+  }
+  getPlatformInfo() {
+    return {
+      isMac: this.isMac,
+      platform: navigator.platform
+    };
+  }
+  destroy() {
+    this.keymap = {}, this.editor = null;
+  }
+}
+class b {
+  constructor() {
+    this.name = "line-numbers", this.editor = null, this.lineNumbersElement = null, this.isEnabled = !0;
+  }
+  setup(e) {
+    this.editor = e, this.createLineNumbers(), e.registerCommand("toggleLineNumbers", () => {
+      this.toggle();
+    }), e.on("change", () => {
+      this.updateLineNumbers();
+    }), this.updateLineNumbers();
+  }
+  createLineNumbers() {
+    if (!this.editor) return;
+    const e = this.editor.getView();
+    if (!e.container) return;
+    this.lineNumbersElement = document.createElement("div"), this.lineNumbersElement.style.cssText = `
+      position: absolute;
+      left: 0;
+      top: 0;
+      bottom: 0;
+      width: 50px;
+      background: var(--editor-gutter-background, #252526);
+      color: var(--editor-gutter-foreground, #858585);
+      font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+      font-size: 14px;
+      line-height: 21px;
+      padding: 0;
+      text-align: right;
+      border-right: 1px solid var(--editor-gutter-border, #3e3e42);
+      user-select: none;
+      overflow: hidden;
+      z-index: 1;
+      pointer-events: none;
+    `;
+    const n = e.getContentElement();
+    n && n.parentNode && (n.parentNode.insertBefore(this.lineNumbersElement, n), n.style.marginLeft = "60px");
+  }
+  updateLineNumbers() {
+    if (!this.lineNumbersElement || !this.editor || !this.isEnabled) return;
+    const e = this.editor.getValue().split(`
+`).length, t = Array.from({ length: Math.max(e, 20) }, (n, i) => i + 1);
+    this.lineNumbersElement.innerHTML = t.map((n) => `<div style="height: 21px; line-height: 21px; padding-right: 12px;">${n}</div>`).join("");
+  }
+  toggle() {
+    this.isEnabled = !this.isEnabled, this.lineNumbersElement && (this.lineNumbersElement.style.display = this.isEnabled ? "block" : "none");
+    const e = this.editor.getView().getContentElement();
+    e && (e.style.marginLeft = this.isEnabled ? "60px" : "0"), this.updateLineNumbers();
+  }
+  destroy() {
+    this.lineNumbersElement && this.lineNumbersElement.parentNode && this.lineNumbersElement.parentNode.removeChild(this.lineNumbersElement), this.lineNumbersElement = null, this.editor = null;
+  }
+}
+class v {
+  constructor() {
+    this.name = "theme", this.editor = null, this.currentTheme = "dark";
+  }
+  setup(e) {
+    this.editor = e, e.registerCommand("setTheme", (t) => {
+      this.setTheme(t);
+    }), e.registerCommand("toggleTheme", () => {
+      this.toggleTheme();
+    }), this.setTheme(this.currentTheme);
+  }
+  setTheme(e) {
+    this.editor && (this.currentTheme = e, this.editor.setTheme(e));
+  }
+  toggleTheme() {
+    const e = this.currentTheme === "dark" ? "light" : "dark";
+    this.setTheme(e);
+  }
+  getCurrentTheme() {
+    return this.currentTheme;
+  }
+  destroy() {
+    this.editor = null;
+  }
+}
+class E {
+  constructor() {
+    this.name = "read-only", this.editor = null, this.isReadOnly = !1;
+  }
+  setup(e) {
+    this.editor = e, e.registerCommand("setReadOnly", (t) => {
+      this.setReadOnly(t);
+    }), e.registerCommand("toggleReadOnly", () => {
+      this.toggleReadOnly();
+    }), e.on("keydown", (t) => {
+      if (t.ctrlKey && t.key === "r")
+        return t.preventDefault(), this.toggleReadOnly(), !1;
+    });
+  }
+  setReadOnly(e) {
+    this.editor && (this.isReadOnly = e, this.editor.setReadOnly(e));
+  }
+  toggleReadOnly() {
+    this.setReadOnly(!this.isReadOnly);
+  }
+  isCurrentlyReadOnly() {
+    return this.isReadOnly;
+  }
+  destroy() {
+    this.editor = null;
+  }
+}
+class w {
+  constructor() {
+    this.name = "search", this.editor = null, this.searchUI = null, this.isVisible = !1, this.currentResults = [], this.currentIndex = -1;
+  }
+  setup(e) {
+    this.editor = e, e.registerCommand("find", () => {
+      this.showSearch();
+    }), e.registerCommand("findNext", () => {
+      this.findNext();
+    }), e.registerCommand("findPrev", () => {
+      this.findPrev();
+    }), e.registerCommand("replace", () => {
+      this.showReplace();
+    }), e.registerCommand("replaceAll", (t, n) => {
+      this.replaceAll(t, n);
+    });
+  }
+  showSearch() {
+    if (this.editor && (this.searchUI || this.createSearchUI(), this.isVisible = !0, this.searchUI)) {
+      this.searchUI.style.display = "block";
+      const e = this.searchUI.querySelector("input");
+      e && (e.focus(), e.select());
+    }
+  }
+  showReplace() {
+    this.showSearch();
+    const e = this.searchUI?.querySelector(".search-replace-input");
+    e && (e.style.display = "block", e.focus());
+    const t = this.searchUI?.querySelector(".search-status");
+    t && (t.textContent = "Replace mode - Enter to replace, Shift+Enter to replace all");
+  }
+  hideSearch() {
+    this.isVisible = !1, this.searchUI && (this.searchUI.style.display = "none"), this.clearHighlights();
+  }
+  createSearchUI() {
+    if (!this.editor) return;
+    const e = document.querySelector(".rte-source-editor-modal");
+    if (!e) return;
+    this.searchUI = document.createElement("div"), this.searchUI.style.cssText = `
+      position: absolute;
+      top: 10px;
+      right: 10px;
+      background: var(--editor-background, #1e1e1e);
+      border: 1px solid var(--editor-gutter-border, #3e3e42);
+      border-radius: 4px;
+      padding: 8px;
+      z-index: 1000;
+      display: none;
+      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+      min-width: 250px;
+    `, this.searchUI.innerHTML = `
+      <div style="display: flex; align-items: center; gap: 4px; margin-bottom: 4px;">
+        <input type="text" placeholder="Find..." style="
+          flex: 1;
+          padding: 4px 8px;
+          background: var(--editor-gutter-background, #252526);
+          color: var(--editor-foreground, #f8f9fa);
+          border: 1px solid var(--editor-gutter-border, #3e3e42);
+          border-radius: 3px;
+          font-size: 12px;
+          outline: none;
+        " />
+        <button class="search-prev" style="
+          padding: 2px 6px;
+          background: var(--editor-gutter-background, #252526);
+          color: var(--editor-gutter-foreground, #858585);
+          border: 1px solid var(--editor-gutter-border, #3e3e42);
+          border-radius: 3px;
+          cursor: pointer;
+          font-size: 11px;
+        ">↑</button>
+        <button class="search-next" style="
+          padding: 2px 6px;
+          background: var(--editor-gutter-background, #252526);
+          color: var(--editor-gutter-foreground, #858585);
+          border: 1px solid var(--editor-gutter-border, #3e3e42);
+          border-radius: 3px;
+          cursor: pointer;
+          font-size: 11px;
+        ">↓</button>
+        <button class="search-close" style="
+          padding: 2px 6px;
+          background: var(--editor-gutter-background, #252526);
+          color: var(--editor-gutter-foreground, #858585);
+          border: 1px solid var(--editor-gutter-border, #3e3e42);
+          border-radius: 3px;
+          cursor: pointer;
+          font-size: 11px;
+        ">×</button>
+      </div>
+      <div class="search-status" style="
+        font-size: 11px;
+        color: var(--editor-gutter-foreground, #858585);
+        text-align: center;
+      "></div>
+      <input type="text" class="search-replace-input" placeholder="Replace with..." style="
+        width: 100%;
+        padding: 4px 8px;
+        background: var(--editor-gutter-background, #252526);
+        color: var(--editor-foreground, #f8f9fa);
+        border: 1px solid var(--editor-gutter-border, #3e3e42);
+        border-radius: 3px;
+        font-size: 12px;
+        outline: none;
+        display: none;
+        margin-top: 4px;
+      " />
+    `;
+    const t = this.searchUI.querySelector("input"), n = this.searchUI.querySelector(".search-replace-input"), i = this.searchUI.querySelector(".search-prev"), s = this.searchUI.querySelector(".search-next"), o = this.searchUI.querySelector(".search-close");
+    t.addEventListener("input", () => {
+      this.performSearch(t.value);
+    }), t.addEventListener("keydown", (h) => {
+      h.key === "Enter" && (h.preventDefault(), h.shiftKey ? this.findPrev() : this.findNext());
+    }), n.addEventListener("keydown", (h) => {
+      h.key === "Enter" && (h.preventDefault(), h.shiftKey ? this.replaceAll(t.value, n.value) : this.replaceCurrent(t.value, n.value));
+    }), i.addEventListener("click", () => this.findPrev()), s.addEventListener("click", () => this.findNext()), o.addEventListener("click", () => this.hideSearch()), e.appendChild(this.searchUI);
+  }
+  performSearch(e) {
+    if (!this.editor || !e.trim()) {
+      this.clearHighlights(), this.updateStatus("");
+      return;
+    }
+    const t = this.editor.getValue(), n = [];
+    let i = t.toLowerCase().indexOf(e.toLowerCase());
+    for (; i !== -1; ) {
+      const s = this.getPositionFromOffset(t, i), o = this.getPositionFromOffset(t, i + e.length);
+      n.push({
+        range: { start: s, end: o },
+        match: t.substring(i, i + e.length)
+      }), i = t.toLowerCase().indexOf(e.toLowerCase(), i + 1);
+    }
+    this.currentResults = n, this.currentIndex = this.currentResults.length > 0 ? 0 : -1, this.updateHighlights(), this.updateStatus(`${this.currentResults.length} matches`);
+  }
+  getPositionFromOffset(e, t) {
+    const n = e.substring(0, t).split(`
+`), i = n.length - 1, s = n[n.length - 1].length;
+    return { line: i, column: s };
+  }
+  findNext() {
+    this.currentResults.length !== 0 && (this.currentIndex = (this.currentIndex + 1) % this.currentResults.length, this.updateHighlights());
+  }
+  findPrev() {
+    this.currentResults.length !== 0 && (this.currentIndex = this.currentIndex <= 0 ? this.currentResults.length - 1 : this.currentIndex - 1, this.updateHighlights());
+  }
+  replaceCurrent(e, t) {
+    if (!this.editor || !e.trim() || this.currentIndex === -1) return;
+    const n = this.currentResults[this.currentIndex];
+    if (!n) return;
+    const i = this.editor.getValue(), s = this.getOffsetFromPosition(i, n.range.start), o = i.substring(0, s), h = i.substring(s + e.length), r = o + t + h;
+    this.editor.setValue(r), this.performSearch(e), this.updateStatus("Replaced current occurrence");
+  }
+  replaceAll(e, t) {
+    if (!this.editor || !e.trim()) return;
+    let n = this.editor.getValue(), i = 0, s = n.toLowerCase().indexOf(e.toLowerCase());
+    for (; s !== -1; )
+      n = n.substring(0, s) + t + n.substring(s + e.length), i++, s = n.toLowerCase().indexOf(e.toLowerCase(), s + t.length);
+    i > 0 && (this.editor.setValue(n), this.updateStatus(`Replaced ${i} occurrences`));
+  }
+  getOffsetFromPosition(e, t) {
+    const n = e.split(`
+`);
+    let i = 0;
+    for (let s = 0; s < t.line; s++)
+      i += n[s].length + 1;
+    return i += t.column, i;
+  }
+  updateHighlights() {
+    this.clearHighlights(), !(this.currentResults.length === 0 || this.currentIndex === -1) && (this.currentResults[this.currentIndex], this.updateStatus(`${this.currentResults.length} matches (showing ${this.currentIndex + 1}/${this.currentResults.length})`));
+  }
+  clearHighlights() {
+  }
+  updateStatus(e) {
+    const t = this.searchUI?.querySelector(".search-status");
+    t && (t.textContent = e);
+  }
+  destroy() {
+    this.searchUI && this.searchUI.parentNode && this.searchUI.parentNode.removeChild(this.searchUI), this.searchUI = null, this.editor = null;
+  }
+}
+class k {
+  constructor() {
+    this.name = "bracket-matching", this.editor = null, this.bracketPairs = {
+      "(": ")",
+      "[": "]",
+      "{": "}",
+      "<": ">"
+    }, this.reverseBracketPairs = {
+      ")": "(",
+      "]": "[",
+      "}": "{",
+      ">": "<"
+    }, this.currentMatch = null;
+  }
+  setup(e) {
+    this.editor = e, e.on("cursor", () => {
+      this.updateBracketMatching();
+    }), e.on("change", () => {
+      this.updateBracketMatching();
+    });
+  }
+  updateBracketMatching() {
+    if (!this.editor) return;
+    const e = this.editor.getCursor(), t = this.editor.getValue();
+    this.clearBracketHighlighting();
+    const n = this.getBracketAtPosition(t, e.position);
+    if (!n) return;
+    const i = this.findMatchingBracket(t, n);
+    i && (this.currentMatch = i, this.highlightBrackets(i));
+  }
+  getBracketAtPosition(e, t) {
+    const n = e.split(`
+`);
+    if (t.line >= n.length) return null;
+    const i = n[t.line];
+    if (t.column >= i.length) return null;
+    const s = i[t.column];
+    return this.bracketPairs[s] || this.reverseBracketPairs[s] ? { char: s, position: t } : null;
+  }
+  findMatchingBracket(e, t) {
+    const n = e.split(`
+`), i = t.position.line, s = t.position.column, o = t.char;
+    return this.bracketPairs[o] ? this.findClosingBracket(e, n, i, s, o) : this.reverseBracketPairs[o] ? this.findOpeningBracket(e, n, i, s, o) : null;
+  }
+  findClosingBracket(e, t, n, i, s) {
+    const o = this.bracketPairs[s];
+    let h = 0;
+    for (let r = n; r < t.length; r++) {
+      const l = t[r], c = r === n ? i : 0;
+      for (let a = c; a < l.length; a++) {
+        const u = l[a];
+        if (u === s)
+          h++;
+        else if (u === o && (h--, h === 0))
+          return {
+            open: { start: { line: n, column: i }, end: { line: n, column: i + 1 } },
+            close: { start: { line: r, column: a }, end: { line: r, column: a + 1 } },
+            type: s
+          };
+      }
+    }
+    return null;
+  }
+  findOpeningBracket(e, t, n, i, s) {
+    const o = this.reverseBracketPairs[s];
+    let h = 0;
+    for (let r = n; r >= 0; r--) {
+      const l = t[r], c = r === n ? i : l.length - 1;
+      for (let a = c; a >= 0; a--) {
+        const u = l[a];
+        if (u === s)
+          h++;
+        else if (u === o && (h--, h === 0))
+          return {
+            open: { start: { line: r, column: a }, end: { line: r, column: a + 1 } },
+            close: { start: { line: n, column: i }, end: { line: n, column: i + 1 } },
+            type: o
+          };
+      }
+    }
+    return null;
+  }
+  highlightBrackets(e) {
+    console.log("Bracket match found:", e);
+  }
+  clearBracketHighlighting() {
+    this.currentMatch = null;
+  }
+  getCurrentMatch() {
+    return this.currentMatch;
+  }
+  destroy() {
+    this.clearBracketHighlighting(), this.editor = null;
+  }
+}
+class C {
+  constructor() {
+    this.name = "code-folding", this.editor = null, this.foldIndicators = [], this.foldingUI = null;
+  }
+  setup(e) {
+    this.editor = e, e.registerCommand("fold", () => {
+      console.log("Fold command executed - folding not yet implemented"), this.foldAtCursor();
+    }), e.registerCommand("unfold", () => {
+      console.log("Unfold command executed - unfolding not yet implemented"), this.unfoldAtCursor();
+    }), e.registerCommand("foldAll", () => {
+      console.log("Fold all command executed - folding not yet implemented"), this.foldAll();
+    }), e.registerCommand("unfoldAll", () => {
+      console.log("Unfold all command executed - unfolding not yet implemented"), this.unfoldAll();
+    }), e.on("change", () => {
+      this.updateFoldIndicators();
+    }), this.createFoldingUI(), this.updateFoldIndicators();
+  }
+  createFoldingUI() {
+    if (!this.editor) return;
+    const e = document.querySelector(".rte-source-editor-modal");
+    e && (this.foldingUI = document.createElement("div"), this.foldingUI.style.cssText = `
+      position: absolute;
+      left: 40px;
+      top: 0;
+      bottom: 0;
+      width: 20px;
+      pointer-events: none;
+      z-index: 2;
+    `, e.appendChild(this.foldingUI));
+  }
+  updateFoldIndicators() {
+    if (!this.editor || !this.foldingUI) return;
+    this.foldingUI.innerHTML = "", this.foldIndicators = [];
+    const t = this.editor.getValue().split(`
+`);
+    this.findFoldableLines(t).forEach((i) => {
+      this.createFoldIndicator(i);
+    });
+  }
+  findFoldableLines(e) {
+    const t = [];
+    for (let n = 0; n < e.length; n++) {
+      const i = e[n].trim();
+      (i.startsWith("{") || i.startsWith("function") || i.startsWith("class") || i.startsWith("if") || i.includes("=>") || i.startsWith("for") || i.startsWith("while") || i.startsWith("try")) && t.push(n);
+    }
+    return t;
+  }
+  createFoldIndicator(e) {
+    if (!this.foldingUI) return;
+    const t = document.createElement("div");
+    t.style.cssText = `
+      position: absolute;
+      left: 0;
+      top: ${e * 21}px;
+      width: 20px;
+      height: 21px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      cursor: pointer;
+      pointer-events: auto;
+      color: var(--editor-gutter-foreground, #858585);
+      font-size: 10px;
+      user-select: none;
+    `, t.innerHTML = "▶", t.title = "Code folding not yet implemented - click shows fold indicators", t.addEventListener("click", () => {
+      console.log(`Fold toggle clicked at line ${e} - implementation pending`);
+    }), this.foldingUI.appendChild(t), this.foldIndicators.push(t);
+  }
+  foldAtCursor() {
+    console.log("foldAtCursor called - implementation pending");
+  }
+  unfoldAtCursor() {
+    console.log("unfoldAtCursor called - implementation pending");
+  }
+  foldAll() {
+    console.log("foldAll called - implementation pending");
+  }
+  unfoldAll() {
+    console.log("unfoldAll called - implementation pending");
+  }
+  destroy() {
+    this.foldingUI && this.foldingUI.parentNode && this.foldingUI.parentNode.removeChild(this.foldingUI), this.foldingUI = null, this.foldIndicators = [], this.editor = null;
+  }
+}
+class L {
+  constructor() {
+    this.name = "syntax-highlighting", this.editor = null, this.currentTheme = "dark";
+  }
+  setup(e) {
+    this.editor = e, console.log("SyntaxHighlightingExtension: Isolated extension loaded - ready for use");
+  }
+  // Extension provides methods that can be called by the editor
+  setTheme(e) {
+    this.currentTheme = e, console.log(`SyntaxHighlightingExtension: Theme changed to ${e}`);
+  }
+  // Method to get syntax highlighting colors for a given theme
+  getSyntaxColors() {
+    return this.currentTheme === "dark" ? {
+      tag: "#569cd6",
+      // Blue
+      comment: "#6a9955",
+      // Green
+      attrValue: "#ce9178",
+      // Orange
+      text: "#d4d4d4"
+      // Light gray
+    } : {
+      tag: "#0000ff",
+      // Blue
+      comment: "#008000",
+      // Green
+      attrValue: "#a31515",
+      // Red
+      text: "#000000"
+      // Black
+    };
+  }
+  // Method to parse and highlight HTML content (returns highlighted HTML string)
+  highlightHTML(e) {
+    const t = this.getSyntaxColors();
+    let n = e;
+    return n = n.replace(
+      /(<\/?[\w:-]+(?:\s[^>]*?)?\/?>)/g,
+      `<span style="color: ${t.tag};">$1</span>`
+    ), n = n.replace(
+      /(<!--[\s\S]*?-->)/g,
+      `<span style="color: ${t.comment};">$1</span>`
+    ), n = n.replace(
+      /("[^"]*"|'[^']*')/g,
+      `<span style="color: ${t.attrValue};">$1</span>`
+    ), n;
+  }
+  // Method to check if content contains syntax that should be highlighted
+  shouldHighlight(e) {
+    return /<\/?[\w:-]+|<!--/.test(e);
+  }
+  destroy() {
+    this.editor = null, console.log("SyntaxHighlightingExtension: Extension destroyed");
+  }
+}
+function T(d, e) {
+  const t = { ...e };
+  return t.extensions || (t.extensions = []), t.extensions.some((i) => i.name === "keymap") || t.extensions.unshift(new y(t.keymap)), new x(d, t);
+}
+export {
+  k as BracketMatchingExtension,
+  C as CodeFoldingExtension,
+  x as EditorCore,
+  y as KeymapExtension,
+  b as LineNumbersExtension,
+  E as ReadOnlyExtension,
+  w as SearchExtension,
+  L as SyntaxHighlightingExtension,
+  m as TextModel,
+  v as ThemeExtension,
+  p as View,
+  T as createEditor,
+  x as default
+};