@hosanna/chordpro 1.1.0

package/dist/chunk-QZY7KJWK.mjs

@@ -0,0 +1,749 @@
+// src/editor/Editor.tsx
+import React, { Suspense, useCallback, useEffect, useRef, useState } from "react";
+
+// src/editor/ChordFinder.ts
+var ChordFinder = class {
+  static {
+    this.CHORD_REGEX = /\[(.*?)\]/gi;
+  }
+  /**
+   * Extracts chords from text and returns them formatted for Ace Autocomplete
+   */
+  static getChords(text) {
+    const matches = String(text).match(this.CHORD_REGEX);
+    if (!matches || matches.length === 0) {
+      return [];
+    }
+    const chordCounts = matches.reduce(
+      (acc, chord) => {
+        acc[chord] = (acc[chord] || 0) + 1;
+        return acc;
+      },
+      {}
+    );
+    return Object.entries(chordCounts).map(([chord, count]) => ({
+      value: chord,
+      meta: `${count} occurrence${count > 1 ? "s" : ""}`,
+      score: count
+      // Ace uses score to rank autocomplete suggestions
+    })).sort((a, b) => b.score - a.score);
+  }
+};
+
+// src/editor/mode-chordpro.ts
+async function registerChordproMode(aceInstance) {
+  let ace = aceInstance;
+  if (!ace) {
+    try {
+      const mod = await import("ace-builds");
+      ace = mod.default || mod;
+    } catch {
+      return;
+    }
+  }
+  if (!ace || typeof ace.define !== "function" || ace._chordproModeRegistered) {
+    return;
+  }
+  ace.define(
+    "ace/mode/chordpro_highlight_rules",
+    [
+      "require",
+      "exports",
+      "module",
+      "ace/lib/oop",
+      "ace/mode/text_highlight_rules"
+    ],
+    (require2, exports) => {
+      const oop = require2("ace/lib/oop");
+      const TextHighlightRules = require2("ace/mode/text_highlight_rules").TextHighlightRules;
+      const ChordproHighlightRules = function() {
+        const rStart = "(\\{\\s*)";
+        const rEnd = "(\\s*\\})";
+        const rSep = "(\\s*:\\s*)";
+        this.$rules = {
+          start: [
+            // Comments
+            { token: "comment.line.number-sign", regex: "^#.*$" },
+            // Tab Block Start -> moves to tabBlock state
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(start_of_tab|sot)" + rEnd,
+              caseInsensitive: true,
+              next: "tabBlock"
+            },
+            // Grid Block Start -> moves to gridBlock state
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(start_of_grid|sog)" + rEnd,
+              caseInsensitive: true,
+              next: "gridBlock"
+            },
+            // Generic Block Starts (Chorus, Verse, Bridge, Custom) with optional labels
+            {
+              token: [
+                "punctuation.tag",
+                "markup.bold",
+                "punctuation.separator",
+                "string",
+                "punctuation.tag"
+              ],
+              regex: rStart + "(start_of_[a-z_]+|so[a-z])" + rSep + "(.*?)" + rEnd,
+              caseInsensitive: true
+            },
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(start_of_[a-z_]+|so[a-z])" + rEnd,
+              caseInsensitive: true
+            },
+            // Generic Block Ends
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(end_of_[a-z_]+|eo[a-z])" + rEnd,
+              caseInsensitive: true
+            },
+            // Formatting & Styling Directives (e.g. textfont, chordsize)
+            {
+              token: [
+                "punctuation.tag",
+                "support.type",
+                "punctuation.separator",
+                "constant.numeric",
+                "punctuation.tag"
+              ],
+              regex: rStart + "(textfont|textsize|chordfont|chordsize|tabfont|tabsize|gridfont|gridsize)" + rSep + "(.*?)" + rEnd,
+              caseInsensitive: true
+            },
+            // Meta Directives (e.g. title, key, tempo)
+            {
+              token: [
+                "punctuation.tag",
+                "keyword.control",
+                "punctuation.separator",
+                "string",
+                "punctuation.tag"
+              ],
+              regex: rStart + "(title|t|subtitle|st|artist|a|composer|lyricist|ccli|translator|youtube|chorus|copyright|album|year|key|k|time|tempo|duration|capo|meta|c|comment|chord|define|song_number|x_[a-zA-Z0-9_]+)" + rSep + "(.*?)" + rEnd,
+              caseInsensitive: true
+            },
+            // Standalone Directives (e.g. column_break, new_page)
+            {
+              token: ["punctuation.tag", "keyword.operator", "punctuation.tag"],
+              regex: rStart + "(column_break|cb|new_page|np|new_song|ns|chorus)" + rEnd,
+              caseInsensitive: true
+            },
+            // Chord Section barlines (||, |:, :|, |)
+            {
+              token: "constant.character.barline",
+              regex: "\\|\\||:\\||\\|:|\\|"
+            },
+            // Inline Annotations e.g. [* Bass fill]
+            {
+              token: ["punctuation.tag", "comment.line", "punctuation.tag"],
+              regex: "(\\[\\s*\\*)(.*?)(\\])"
+            },
+            // Chord with timing annotation e.g. [Em@2x] or [C@0.5x]
+            {
+              token: [
+                "punctuation.tag",
+                "constant.language.bold",
+                "keyword.operator.timing",
+                "punctuation.tag"
+              ],
+              regex: "(\\[)([^\\]@]+)(@[0-9]*\\.?[0-9]+x)(\\])"
+            },
+            // Chords e.g. [C#maj7/F]
+            {
+              token: [
+                "punctuation.tag",
+                "constant.language.bold",
+                "punctuation.tag"
+              ],
+              regex: "(\\[)([^\\]]+)(\\])"
+            },
+            // Invalid/Unknown braces catch-all
+            {
+              token: ["punctuation.tag", "invalid", "punctuation.tag"],
+              regex: rStart + "(.+?)" + rEnd
+            }
+          ],
+          // Advanced State for Tablature blocks
+          tabBlock: [
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(end_of_tab|eot)" + rEnd,
+              caseInsensitive: true,
+              next: "start"
+            },
+            { token: "comment.line", regex: "-+" },
+            // Tab lines
+            { token: "constant.character", regex: "\\|+" },
+            // Measure bars
+            { token: "string.regexp", regex: "^[a-gA-G][b#]?\\s*\\|" },
+            // Tuning strings at start of line
+            { token: "constant.numeric", regex: "\\b[0-9]+\\b" },
+            // Fret numbers
+            { token: "support.function", regex: "[hpsbrv~t]" },
+            // Articulations (hammer-on, pull-off, bend)
+            { defaultToken: "comment" }
+            // Fallback to comment color for tab lines
+          ],
+          // Advanced State for Grid blocks (Jazz grids / Chord progression boxes)
+          gridBlock: [
+            {
+              token: ["punctuation.tag", "markup.bold", "punctuation.tag"],
+              regex: rStart + "(end_of_grid|eog)" + rEnd,
+              caseInsensitive: true,
+              next: "start"
+            },
+            { token: "constant.character", regex: "\\|\\||\\|\\.|\\.\\||\\|" },
+            // Grid barlines
+            { token: "keyword.operator", regex: "%" },
+            // Grid repeat markers
+            {
+              token: "constant.language.bold",
+              regex: "[A-G][b#]?(?:m|maj|dim|aug|sus|[0-9])*(?:\\/[A-G][b#]?)?"
+            },
+            // Grid Chords (raw text)
+            { defaultToken: "text" }
+          ]
+        };
+      };
+      oop.inherits(ChordproHighlightRules, TextHighlightRules);
+      exports.ChordproHighlightRules = ChordproHighlightRules;
+    }
+  );
+  ace.define(
+    "ace/mode/folding/chordpro",
+    [
+      "require",
+      "exports",
+      "module",
+      "ace/lib/oop",
+      "ace/range",
+      "ace/mode/folding/fold_mode"
+    ],
+    (require2, exports) => {
+      const oop = require2("ace/lib/oop");
+      const Range = require2("ace/range").Range;
+      const BaseFoldMode = require2("ace/mode/folding/fold_mode").FoldMode;
+      const FoldMode = exports.FoldMode = function() {
+      };
+      oop.inherits(FoldMode, BaseFoldMode);
+      (function() {
+        this.foldingStartMarker = /\{\s*(so(?<short>[a-z_]+)|start_of_(?<long>[a-z_]+))(:.*?)?\s*\}/i;
+        this.foldingStopMarker = /\{\s*(eo(?<short>[a-z_]+)|end_of_(?<long>[a-z_]+))\s*\}/i;
+        const mapBlockName = (name) => {
+          const map = {
+            c: "chorus",
+            v: "verse",
+            b: "bridge",
+            t: "tab",
+            g: "grid"
+          };
+          return map[name.toLowerCase()] || name.toLowerCase();
+        };
+        this.getFoldWidgetRange = function(session, _, row) {
+          const line = session.getLine(row);
+          const match = line.match(this.foldingStartMarker);
+          if (match && match.groups) {
+            const rawName = match.groups["short"] || match.groups["long"];
+            if (!rawName) return;
+            return this.getRegionBlock(
+              session,
+              line,
+              row,
+              mapBlockName(rawName)
+            );
+          }
+        };
+        this.getRegionBlock = function(session, line, row, normalizedStartName) {
+          const startColumn = line.search(/\s*$/);
+          const maxRow = session.getLength();
+          const startRow = row;
+          let hasMatch = false;
+          while (++row < maxRow) {
+            line = session.getLine(row);
+            const m = this.foldingStopMarker.exec(line);
+            if (m && m.groups) {
+              const rawEndName = m.groups["short"] || m.groups["long"];
+              if (rawEndName && mapBlockName(rawEndName) === normalizedStartName) {
+                hasMatch = true;
+                break;
+              }
+            }
+          }
+          if (hasMatch)
+            return new Range(startRow, startColumn, row, line.length);
+        };
+      }).call(FoldMode.prototype);
+    }
+  );
+  ace.define(
+    "ace/mode/chordpro",
+    [
+      "require",
+      "exports",
+      "module",
+      "ace/lib/oop",
+      "ace/mode/text",
+      "ace/mode/chordpro_highlight_rules",
+      "ace/mode/folding/chordpro"
+    ],
+    (require2, exports) => {
+      const oop = require2("ace/lib/oop");
+      const TextMode = require2("ace/mode/text").Mode;
+      const ChordproHighlightRules = require2("ace/mode/chordpro_highlight_rules").ChordproHighlightRules;
+      const FoldMode = require2("ace/mode/folding/chordpro").FoldMode;
+      const Mode = function() {
+        this.HighlightRules = ChordproHighlightRules;
+        this.foldingRules = new FoldMode();
+      };
+      oop.inherits(Mode, TextMode);
+      (function() {
+        this.$id = "ace/mode/chordpro";
+        this.snippetFileId = "ace/snippets/chordpro";
+      }).call(Mode.prototype);
+      exports.Mode = Mode;
+    }
+  );
+  ace._chordproModeRegistered = true;
+}
+
+// src/editor/snippets-chordpro.ts
+async function registerChordproSnippets(aceInstance) {
+  let ace = aceInstance;
+  if (!ace) {
+    try {
+      const mod = await import("ace-builds");
+      ace = mod.default || mod;
+    } catch {
+      return;
+    }
+  }
+  if (!ace || typeof ace.define !== "function" || ace._chordproSnippetsRegistered) {
+    return;
+  }
+  ace.define(
+    "ace/snippets/chordpro",
+    ["require", "exports", "module"],
+    (_, exports) => {
+      exports.snippetText = [
+        // album tag
+        "snippet album",
+        "	{album: ${1:value}}",
+        "snippet youtube",
+        "	{youtube: ${1:url}}",
+        "snippet number",
+        "	{song_number: ${1:number}}",
+        "snippet cc",
+        "	{chorus}",
+        // arranger tag
+        "snippet arranger",
+        "	{arranger: ${1:value}}",
+        // artist tag
+        "snippet a",
+        "	{artist: ${1:value}}",
+        "snippet artist",
+        "	{artist: ${1:value}}",
+        // capo tag
+        "snippet capo",
+        "	{capo: ${1:5}}",
+        // composer tag
+        "snippet composer",
+        "	{composer: ${1:value}}",
+        // copyright tag
+        "snippet copyright",
+        "	{copyright: ${1:value}}",
+        // duration tag
+        "snippet duration",
+        "	{duration: ${1:4}:${2:00}}",
+        // key tag
+        "snippet k",
+        "	{key: ${1:Am}}",
+        "snippet key",
+        "	{key: ${1:Am}}",
+        // lyricist tag
+        "snippet lyricist",
+        "	{lyricist: ${1:value}}",
+        // tempo tag
+        "snippet tempo",
+        "	{tempo: ${1:120}}",
+        // time tag
+        "snippet time",
+        "	{time: ${1:4}/${2:4}}",
+        // title tag
+        "snippet t",
+        "	{title: ${1:value}}",
+        "snippet title",
+        "	{title: ${1:value}}",
+        // subtitle tag
+        "snippet st",
+        "	{subtitle: ${1:value}}",
+        "snippet subtitle",
+        "	{subtitle: ${1:value}}",
+        // year tag
+        "snippet year",
+        "	{year: ${1:2020}}",
+        // meta tag
+        "snippet meta",
+        "	{meta: ${1:label} ${2:value}}",
+        // comment tag
+        "snippet c",
+        "	{comment: ${1:value}}",
+        "snippet comment",
+        "	{comment: ${1:value}}",
+        // chorus block
+        "snippet soc",
+        "	{start_of_chorus}",
+        "snippet eoc",
+        "	{end_of_chorus}",
+        "snippet chorus",
+        "	{start_of_chorus: ${1:Refr\xE3o}}",
+        "	${2:lyrics}",
+        "	{end_of_chorus}",
+        // verse block
+        "snippet sov",
+        "	{start_of_verse}",
+        "snippet eov",
+        "	{end_of_verse}",
+        "snippet verse",
+        "	{start_of_verse: ${1:Verso} ${2:1}}",
+        "	${3:lyrics}",
+        "	{end_of_verse}",
+        // bridge block
+        "snippet sob",
+        "	{start_of_bridge}",
+        "snippet eob",
+        "	{end_of_bridge}",
+        "snippet bridge",
+        "	{start_of_bridge: ${1:Ponte}}",
+        "	${2:lyrics}",
+        "	{end_of_bridge}",
+        // tabs block
+        "snippet sot",
+        "	{start_of_tab}",
+        "snippet eot",
+        "	{end_of_tab}",
+        "snippet tab",
+        "	{start_of_tab}",
+        "	e|-${1:-}--------------------------------|",
+        "	B|----------------------------------|",
+        "	G|----------------------------------|",
+        "	D|----------------------------------|",
+        "	A|----------------------------------|",
+        "	E|----------------------------------|",
+        "	{end_of_tab}",
+        // define tag
+        "snippet d",
+        "	{define: ${1:Am} base-fret ${2:1} frets ${3:0 0 0 0 0 0} fingers ${4:0 0 0 0 0 0}}",
+        "snippet define",
+        "	{define: ${1:Am} base-fret ${2:1} frets ${3:0 0 0 0 0 0} fingers ${4:0 0 0 0 0 0}}",
+        // single-liners
+        "snippet cb",
+        "	{column_break}",
+        "snippet column",
+        "	{column_break}",
+        // that's all folks!
+        // chord usage
+        "snippet [",
+        "	[${1:Am}]",
+        // chord section / grid notation
+        "snippet ||",
+        "	||[${1:Am}]|[${2:C}]|[${3:G}]|[${4:F}]||",
+        "snippet grid",
+        "	{start_of_grid}",
+        "	||[${1:Em}]|[${2:C}]|[${3:D}]||",
+        "	{end_of_grid}",
+        "snippet !",
+        "	{title: ${1:value}}",
+        "	{artist: ${2:value}}",
+        "	{duration: ${3:4:00}}",
+        "	{key: ${4:C}}",
+        "	",
+        "	${5:lyrics}",
+        "	{start_of_chorus}",
+        "	${6:lyrics}",
+        "	{end_of_chorus}"
+      ].join("\n");
+      exports.scope = "chordpro";
+    }
+  );
+  ace._chordproSnippetsRegistered = true;
+}
+
+// src/editor/Editor.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var aceLoaderPromise = null;
+function preloadEditor() {
+  if (!aceLoaderPromise) {
+    aceLoaderPromise = (async () => {
+      try {
+        const aceModule = await import("ace-builds");
+        const ace = aceModule?.default || aceModule;
+        if (typeof window !== "undefined" && ace) {
+          window.ace = ace;
+        }
+        const [reactAceModule] = await Promise.all([
+          import("react-ace"),
+          import("ace-builds/src-noconflict/ext-language_tools"),
+          import("ace-builds/src-noconflict/theme-dracula"),
+          import("ace-builds/src-noconflict/theme-github"),
+          import("ace-builds/src-noconflict/theme-monokai"),
+          import("ace-builds/src-noconflict/theme-solarized_dark"),
+          import("ace-builds/src-noconflict/theme-solarized_light"),
+          import("ace-builds/src-noconflict/theme-textmate"),
+          import("ace-builds/src-noconflict/theme-tomorrow"),
+          import("ace-builds/src-noconflict/theme-tomorrow_night")
+        ]);
+        const AceEditor = reactAceModule?.default || reactAceModule;
+        if (ace) {
+          await registerChordproMode(ace);
+          await registerChordproSnippets(ace);
+          if (typeof ace.require === "function") {
+            try {
+              const langTools = ace.require("ace/ext/language_tools");
+              if (langTools && typeof langTools.addCompleter === "function" && typeof window !== "undefined" && !window._chordproCompleterRegistered) {
+                const chordCompleter = {
+                  getCompletions: (editor, _session, _pos, _prefix, callback) => {
+                    if (!editor || typeof editor.getValue !== "function") {
+                      callback(null, []);
+                      return;
+                    }
+                    const text = editor.getValue();
+                    const chords = ChordFinder.getChords(text);
+                    callback(null, chords);
+                  }
+                };
+                langTools.addCompleter(chordCompleter);
+                window._chordproCompleterRegistered = true;
+              }
+            } catch {
+            }
+          }
+        }
+        if (!AceEditor) {
+          throw new Error("Failed to resolve AceEditor component");
+        }
+        return AceEditor;
+      } catch (error) {
+        console.error("Failed to load Ace editor:", error);
+        aceLoaderPromise = null;
+        const ErrorFallback = () => /* @__PURE__ */ jsx("div", { className: "w-full h-full flex items-center justify-center p-4 text-center text-sm text-red-500 bg-red-50/50 dark:bg-red-950/20 rounded-lg border border-red-200 dark:border-red-900/30", children: "Failed to load code editor. Please ensure 'ace-builds' and 'react-ace' are installed." });
+        return ErrorFallback;
+      }
+    })();
+  }
+  return aceLoaderPromise;
+}
+var LazyAce = React.lazy(async () => {
+  const Component = await preloadEditor();
+  return { default: Component };
+});
+var SECTION_LABELS = {
+  verse: {
+    start: "start_of_verse",
+    end: "end_of_verse",
+    defaultLabel: "Verso"
+  },
+  chorus: {
+    start: "start_of_chorus",
+    end: "end_of_chorus",
+    defaultLabel: "Refr\xE3o"
+  },
+  bridge: {
+    start: "start_of_bridge",
+    end: "end_of_bridge",
+    defaultLabel: "Ponte"
+  }
+};
+function wrapSelectionInSection(editor, sectionType) {
+  if (!editor || !editor.getSelection || !editor.session) return;
+  if (typeof editor.session.getTextRange !== "function" || typeof editor.session.replace !== "function") {
+    return;
+  }
+  const selection = editor.getSelection();
+  if (!selection || typeof selection.getRange !== "function") return;
+  const range = selection.getRange();
+  if (!range) return;
+  const selectedText = editor.session.getTextRange(range);
+  if (!selectedText || !selectedText.trim()) return;
+  const info = SECTION_LABELS[sectionType];
+  const wrapped = `{${info.start}: ${info.defaultLabel}}
+${selectedText}
+{${info.end}}`;
+  editor.session.replace(range, wrapped);
+}
+var MENU_ITEMS = [
+  { type: "verse", label: "Envolver em Verso", shortcut: "Alt+V" },
+  { type: "chorus", label: "Envolver em Refr\xE3o", shortcut: "Alt+R" },
+  { type: "bridge", label: "Envolver em Ponte", shortcut: "Alt+B" }
+];
+function EditorContextMenu({
+  state,
+  onAction,
+  onClose
+}) {
+  const menuRef = useRef(null);
+  useEffect(() => {
+    const handleClickOutside = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        onClose();
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    if (state.visible) {
+      document.addEventListener("mousedown", handleClickOutside);
+      document.addEventListener("keydown", handleEscape);
+    }
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [state.visible, onClose]);
+  if (!state.visible) return null;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: menuRef,
+      className: "fixed z-[9999] min-w-[240px] bg-white dark:bg-zinc-900 border border-zinc-200 dark:border-zinc-700 rounded-xl shadow-2xl py-1.5 animate-in fade-in zoom-in-95 duration-100",
+      style: { left: state.x, top: state.y },
+      children: [
+        /* @__PURE__ */ jsx("div", { className: "px-3 py-1.5 text-[10px] font-bold text-zinc-400 dark:text-zinc-500 uppercase tracking-wider select-none border-b border-zinc-100 dark:border-zinc-800 mb-1", children: "Envolver sele\xE7\xE3o em" }),
+        MENU_ITEMS.map((item) => /* @__PURE__ */ jsxs(
+          "button",
+          {
+            className: "w-full flex items-center gap-2.5 px-3 py-2 text-left text-sm text-zinc-700 dark:text-zinc-200 hover:bg-indigo-50 dark:hover:bg-indigo-950/40 hover:text-indigo-700 dark:hover:text-indigo-300 transition-colors",
+            onClick: () => {
+              onAction(item.type);
+              onClose();
+            },
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "flex-1 font-medium", children: item.label }),
+              /* @__PURE__ */ jsx("span", { className: "text-[10px] font-mono text-zinc-400 dark:text-zinc-500 bg-zinc-100 dark:bg-zinc-800 px-1.5 py-0.5 rounded", children: item.shortcut })
+            ]
+          },
+          item.type
+        ))
+      ]
+    }
+  );
+}
+var DEFAULT_EDITOR_SETTINGS = {
+  theme: "textmate",
+  fontSize: 14,
+  wordWrap: true,
+  showLineNumbers: true
+};
+function Editor({
+  value,
+  onChange,
+  onSave,
+  settings,
+  mode = "chordpro",
+  readOnly = false,
+  fallback = null
+}) {
+  const activeSettings = {
+    ...DEFAULT_EDITOR_SETTINGS,
+    ...settings
+  };
+  const editorRef = useRef(null);
+  const [contextMenu, setContextMenu] = useState({
+    x: 0,
+    y: 0,
+    visible: false
+  });
+  const handleContextMenuAction = useCallback((type) => {
+    if (editorRef.current) {
+      wrapSelectionInSection(editorRef.current, type);
+    }
+  }, []);
+  const handleLoad = useCallback((editor) => {
+    if (!editor) return;
+    editorRef.current = editor;
+    if (editor.commands && typeof editor.commands.addCommand === "function") {
+      editor.commands.addCommand({
+        name: "save",
+        bindKey: { win: "Ctrl-S", mac: "Cmd-S" },
+        exec: (ed) => {
+          if (ed && typeof ed.getValue === "function") {
+            onSave?.(ed.getValue());
+          }
+        }
+      });
+      editor.commands.addCommand({
+        name: "wrapInVerse",
+        bindKey: { win: "Alt-V", mac: "Alt-V" },
+        exec: (ed) => wrapSelectionInSection(ed, "verse")
+      });
+      editor.commands.addCommand({
+        name: "wrapInChorus",
+        bindKey: { win: "Alt-R", mac: "Alt-R" },
+        exec: (ed) => wrapSelectionInSection(ed, "chorus")
+      });
+      editor.commands.addCommand({
+        name: "wrapInBridge",
+        bindKey: { win: "Alt-B", mac: "Alt-B" },
+        exec: (ed) => wrapSelectionInSection(ed, "bridge")
+      });
+    }
+    if (editor.container && typeof editor.container.addEventListener === "function") {
+      const handleContextMenu = (e) => {
+        if (!editor || typeof editor.getSelectedText !== "function") return;
+        const selectedText = editor.getSelectedText();
+        if (selectedText && selectedText.trim()) {
+          e.preventDefault();
+          e.stopPropagation();
+          setContextMenu({ x: e.clientX, y: e.clientY, visible: true });
+        }
+      };
+      editor.container.addEventListener("contextmenu", handleContextMenu);
+    }
+  }, [onSave]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Suspense, { fallback, children: /* @__PURE__ */ jsx(
+      LazyAce,
+      {
+        mode,
+        theme: activeSettings.theme,
+        width: "100%",
+        height: "100%",
+        value,
+        onChange,
+        onLoad: handleLoad,
+        readOnly,
+        fontSize: activeSettings.fontSize,
+        wrapEnabled: activeSettings.wordWrap,
+        showGutter: activeSettings.showLineNumbers,
+        setOptions: {
+          enableLiveAutocompletion: true,
+          enableBasicAutocompletion: true,
+          enableSnippets: true,
+          showLineNumbers: activeSettings.showLineNumbers,
+          tabSize: 2,
+          useWorker: false
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsx(
+      EditorContextMenu,
+      {
+        state: contextMenu,
+        onAction: handleContextMenuAction,
+        onClose: () => setContextMenu((s) => ({ ...s, visible: false }))
+      }
+    )
+  ] });
+}
+var Editor_default = Editor;
+
+export {
+  ChordFinder,
+  registerChordproMode,
+  registerChordproSnippets,
+  preloadEditor,
+  Editor,
+  Editor_default
+};