@m4l/components 9.10.1 → 9.10.2-beta-feature-731-m4l-components-code-editor.0

package/components/extended/ReactSimpleCodeEditor/helpers/highlighting.js

@@ -0,0 +1,1073 @@
+import { jsx as d, Fragment as ot } from "@emotion/react/jsx-runtime";
+import { typescriptLanguage as St, tsxLanguage as vt, jsxLanguage as Ot, javascriptLanguage as At } from "../../../../node_modules/@codemirror/lang-javascript/dist/index.js";
+import { pythonLanguage as Lt } from "../../../../node_modules/@codemirror/lang-python/dist/index.js";
+import { StandardSQL as bt } from "../../../../node_modules/@codemirror/lang-sql/dist/index.js";
+import { yamlLanguage as _t } from "../../../../node_modules/@codemirror/lang-yaml/dist/index.js";
+import it from "prismjs";
+import "prismjs/components/prism-bash";
+import "prismjs/components/prism-clike";
+import "prismjs/components/prism-javascript";
+import "prismjs/components/prism-json";
+import "prismjs/components/prism-jsx";
+import "prismjs/components/prism-python";
+import "prismjs/components/prism-sql";
+import "prismjs/components/prism-tsx";
+import "prismjs/components/prism-typescript";
+import "prismjs/components/prism-yaml";
+import { Highlight as kt } from "prism-react-renderer";
+import { CODE_EDITOR_AT_TEMPLATE_TOKENS as S, CODE_EDITOR_AT_LANGUAGE as B, CODE_EDITOR_AT_TEMPLATE_NAME as Nt, CODE_EDITOR_AT_TEMPLATE_LANGUAGE_LABEL as Dt, CODE_EDITOR_DEFAULT_LANGUAGE as ct, CODE_EDITOR_LANGUAGE_ALIASES as It, getCodeEditorVSCodeModernPalette as X } from "../constants.js";
+const F = it.languages, Y = {}, Rt = /* @__PURE__ */ new Set(["(", ")", "[", "]", "{", "}"]), Pt = /* @__PURE__ */ new Set([
+  "javascript",
+  "jsx",
+  "typescript",
+  "tsx"
+]), wt = /* @__PURE__ */ new Set([
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  ".",
+  ",",
+  ":",
+  ";",
+  "=",
+  "=>",
+  "as",
+  "await",
+  "case",
+  "const",
+  "default",
+  "export",
+  "from",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "of",
+  "return",
+  "throw",
+  "typeof",
+  "var",
+  "yield"
+]), Mt = /* @__PURE__ */ new Set([
+  "(",
+  ":",
+  "=>",
+  "as",
+  "case",
+  "class",
+  "enum",
+  "extends",
+  "implements",
+  "instanceof",
+  "interface",
+  "new",
+  "type",
+  "typeof"
+]), $t = /^[+\-*/%!?&|^~]+$/, C = {
+  isValid: !0
+}, st = {
+  javascript: {
+    label: "JavaScript",
+    parser: At.parser
+  },
+  jsx: {
+    label: "JSX",
+    parser: Ot.parser
+  },
+  python: {
+    label: "Python",
+    parser: Lt.parser
+  },
+  sql: {
+    label: "SQL",
+    parser: bt.language.parser
+  },
+  tsx: {
+    label: "TSX",
+    parser: vt.parser
+  },
+  typescript: {
+    label: "TypeScript",
+    parser: St.parser
+  },
+  yaml: {
+    label: "YAML",
+    parser: _t.parser
+  }
+}, lt = {
+  languageLabel: Dt,
+  languageText: B,
+  templateName: Nt,
+  templateType: B,
+  tokens: {
+    argumentSeparators: [...S.argumentSeparators],
+    commandPrefixes: [...S.commandPrefixes],
+    concatenationSeparators: [...S.concatenationSeparators],
+    reservedWords: [...S.reservedWords]
+  }
+};
+function zt(t) {
+  return [...X(t).bracketPalette];
+}
+function Gt(t) {
+  const e = X(t);
+  return {
+    constant: e.syntax.constant,
+    type: e.syntax.type,
+    variable: e.syntax.variable
+  };
+}
+function Ut(t) {
+  return Pt.has(t);
+}
+function Bt(t) {
+  const e = [], n = Array.from(t.matchAll(/[A-Za-z_$][\w$]*/g));
+  let r = 0;
+  return n.forEach((s) => {
+    const o = s[0], a = s.index ?? 0;
+    a > r && e.push({
+      content: t.slice(r, a),
+      isIdentifier: !1
+    }), e.push({
+      content: o,
+      isIdentifier: !0
+    }), r = a + o.length;
+  }), r < t.length && e.push({
+    content: t.slice(r),
+    isIdentifier: !1
+  }), e.length ? e : [{ content: t, isIdentifier: !1 }];
+}
+function H(t) {
+  const e = t.trimStart();
+  if (!e)
+    return;
+  if (e.startsWith("=>"))
+    return "=>";
+  const n = e.match(/^[A-Za-z_$][\w$]*/);
+  if (n)
+    return n[0];
+  const r = e.match(/^[+\-*/%!?&|^~]+/);
+  return r ? r[0] : e[0];
+}
+function Ft(t, e, n = "") {
+  const r = H(
+    n
+  );
+  if (r)
+    return r;
+  for (let s = e + 1; s < t.length; s += 1) {
+    const o = H(
+      t[s].content
+    );
+    if (o)
+      return o;
+  }
+}
+function Zt(t) {
+  return t.length > 1 && t === t.toUpperCase() && /[A-Z]/.test(t);
+}
+function jt(t) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(t) && t !== t.toUpperCase();
+}
+function Vt(t, e) {
+  return t === ">" && e === "<" ? !1 : [t, e].some(
+    (n) => !!n && (wt.has(n) || $t.test(n))
+  );
+}
+function Wt(t) {
+  if (t.some((e) => ["constant", "symbol"].includes(e)))
+    return "constant";
+  if (t.some((e) => [
+    "builtin",
+    "class-name",
+    "known-class-name",
+    "maybe-class-name",
+    "namespace"
+  ].includes(e)))
+    return "type";
+  if (t.some((e) => [
+    "alias",
+    "imports",
+    "literal-property",
+    "parameter",
+    "property",
+    "variable"
+  ].includes(e)))
+    return "variable";
+}
+function Ht({
+  identifier: t,
+  nextSignificantText: e,
+  previousIdentifierGroup: n,
+  previousSignificantText: r
+}) {
+  if (Vt(
+    r,
+    e
+  ))
+    return r === "." && n === "type" || Zt(t) ? "constant" : jt(t) && (e === "." || e === "(" || r && Mt.has(r)) ? "type" : "variable";
+}
+function I(t, e, n) {
+  const r = H(e);
+  if (r) {
+    if (t.previousSignificantText = r, n) {
+      t.previousIdentifierGroup = n;
+      return;
+    }
+    r !== "." && (t.previousIdentifierGroup = void 0);
+  }
+}
+function Jt(t) {
+  return Rt.has(t);
+}
+function Xt(t, e) {
+  if ("([{".includes(t))
+    return {
+      renderedBracketDepth: e,
+      nextBracketDepth: e + 1
+    };
+  const n = Math.max(e - 1, 0);
+  return {
+    renderedBracketDepth: n,
+    nextBracketDepth: n
+  };
+}
+function Yt(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function W(t) {
+  const e = t?.map((n) => n.trim()).filter(Boolean);
+  if (e?.length)
+    return e.map(Yt).join("|");
+}
+function Kt(t) {
+  const e = W(t.tokens?.commandPrefixes) || "AT\\+", n = W(
+    t.tokens?.reservedWords
+  ), r = W([
+    ...t.tokens?.argumentSeparators || [],
+    ...t.tokens?.concatenationSeparators || []
+  ]);
+  return {
+    comment: {
+      pattern: /(^|\s)(?:#|\/\/).*$/m,
+      lookbehind: !0,
+      alias: "comment"
+    },
+    "at-command": {
+      pattern: new RegExp(
+        `(?:${e})[A-Z][A-Z0-9_:-]*`,
+        "i"
+      ),
+      inside: {
+        operator: new RegExp(`^(?:${e})`, "i"),
+        ...n ? {
+          keyword: new RegExp(`\\b(?:${n})\\b`, "i")
+        } : {},
+        function: /\b[A-Z][A-Z0-9_:-]*\b/
+      }
+    },
+    ...n ? {
+      keyword: new RegExp(`\\b(?:${n})\\b`, "i")
+    } : {},
+    property: /\b[A-Z_][A-Z0-9_]*(?=\s*=)/,
+    string: {
+      pattern: /"(?:\\.|[^"\\])*"/,
+      greedy: !0
+    },
+    boolean: /\b(?:ON|OFF|TRUE|FALSE)\b/i,
+    number: /\b\d+(?:\.\d+)?\b/,
+    constant: /\b(?:OK|ERROR|CONNECT|READY|BUSY)\b/i,
+    punctuation: r ? new RegExp(`(?:${r})|[()[\\]{}.:=]`) : /[()[\]{}.,:;=]/,
+    operator: /[+\-*/<>]/
+  };
+}
+function ut(t) {
+  return t.templateType === B ? Kt(t) : {};
+}
+function Qt(t) {
+  const e = t.templateName.trim();
+  if (!e)
+    return;
+  Y[e] = t;
+  const n = K(t.languageText);
+  F[n] || (F[n] = ut(t));
+}
+Qt(lt);
+function ft(t, e) {
+  t.trim() && (F[t] = e);
+}
+function qt(t) {
+  const e = t.templateName.trim();
+  e && (Y[e] = t, ft(
+    t.languageText,
+    ut(t)
+  ));
+}
+function dt(t) {
+  if (t)
+    return typeof t == "string" ? Y[t] : t;
+}
+function te(t) {
+  const e = dt(t);
+  if (e)
+    return qt(e), e;
+}
+function ee(t) {
+  t && Object.entries(t).forEach(([e, n]) => {
+    ft(e, n);
+  });
+}
+function K(t) {
+  const e = t?.trim().toLowerCase() || ct;
+  return It[e] || e;
+}
+function P(t, e) {
+  return Math.max(0, Math.min(e, t.length));
+}
+function m(t, e) {
+  const n = P(t, e), s = t.slice(0, n).split(`
+`);
+  return {
+    column: (s[s.length - 1] || "").length + 1,
+    line: s.length,
+    offset: n
+  };
+}
+function mt(t, e, n) {
+  const r = t.split(`
+`), s = Math.min(Math.max(e, 1), Math.max(r.length, 1)), o = r.slice(0, s - 1).join(`
+`), a = s === 1 ? 0 : o.length + 1, c = r[s - 1] || "";
+  return P(
+    t,
+    a + Math.max(Math.min(n - 1, c.length), 0)
+  );
+}
+function at(t, e) {
+  return typeof e.offset == "number" ? m(t, e.offset) : m(
+    t,
+    mt(t, e.line, e.column)
+  );
+}
+function R(t, e, n) {
+  const r = P(t, e), s = Math.max(
+    r + 1,
+    P(t, n)
+  );
+  return {
+    end: m(
+      t,
+      s - 1
+    ),
+    start: m(t, r)
+  };
+}
+function ne(t, e) {
+  if (!e)
+    return;
+  const n = at(
+    t,
+    e.start
+  ), r = at(
+    t,
+    e.end ?? e.start
+  ), s = Math.min(
+    n.offset,
+    r.offset
+  ), o = Math.max(
+    n.offset,
+    r.offset
+  ) + 1;
+  return {
+    start: m(
+      t,
+      s
+    ),
+    end: m(
+      t,
+      o
+    )
+  };
+}
+function Q(t) {
+  const e = [];
+  let n = 0;
+  return t.forEach((r) => {
+    e.push(n), n += r.length + 1;
+  }), e;
+}
+function v(t, e) {
+  const n = t.split(`
+`), r = n[e];
+  if (r === void 0)
+    return;
+  const s = Q(n)[e] || 0, o = r.length - r.trimStart().length, a = r.trimEnd().length, c = s + o, i = s + Math.max(a, o + 1);
+  return R(t, c, i);
+}
+function J(t, e) {
+  for (let n = e; n >= 0; n -= 1)
+    if (!/\s/.test(t[n]))
+      return n;
+}
+function re(t, e) {
+  const n = e.match(/\bposition\s+(\d+)\b/i);
+  if (n)
+    return P(t, Number(n[1]));
+  const r = e.match(/\bline\s+(\d+)\s+column\s+(\d+)\b/i);
+  if (r)
+    return mt(
+      t,
+      Number(r[1]),
+      Number(r[2])
+    );
+}
+function oe(t, e) {
+  const n = re(t, e);
+  if (typeof n != "number") {
+    const l = J(
+      t,
+      t.length - 1
+    );
+    return typeof l != "number" ? void 0 : v(
+      t,
+      m(t, l).line - 1
+    );
+  }
+  const s = m(
+    t,
+    n
+  ).line - 1, o = t.split(`
+`), a = o[s] || "", c = t[n], i = J(
+    t,
+    Math.min(n - 1, t.length - 1)
+  );
+  if ((c === "}" || c === "]") && typeof i == "number" && t[i] === ",")
+    return v(
+      t,
+      m(
+        t,
+        i
+      ).line - 1
+    );
+  if (a.trim()) {
+    const l = Q(o)[s] || 0, w = a.length - a.trimStart().length;
+    return R(
+      t,
+      l + w,
+      n + 1
+    );
+  }
+  return typeof i == "number" ? v(
+    t,
+    m(
+      t,
+      i
+    ).line - 1
+  ) : v(t, s);
+}
+function E(t, e) {
+  return {
+    errorRange: e,
+    isValid: !1,
+    message: t
+  };
+}
+function se(t, e, n) {
+  if (e < n)
+    return R(t, e, n);
+  const r = m(
+    t,
+    e
+  ), s = v(
+    t,
+    r.line - 1
+  );
+  if (s)
+    return s;
+  const o = J(
+    t,
+    Math.min(e - 1, t.length - 1)
+  );
+  return typeof o == "number" ? R(
+    t,
+    o,
+    o + 1
+  ) : R(t, e, e + 1);
+}
+function ae(t, e) {
+  const n = e.parse(t).cursor();
+  for (; ; ) {
+    if (n.type.isError)
+      return se(
+        t,
+        n.from,
+        n.to
+      );
+    if (!n.firstChild()) {
+      for (; !n.nextSibling(); )
+        if (!n.parent())
+          return;
+    }
+  }
+}
+function ie(t, e) {
+  if (!t.trim())
+    return C;
+  const n = ae(
+    t,
+    e.parser
+  );
+  return n ? E(
+    `Invalid ${e.label} syntax.`,
+    n
+  ) : C;
+}
+function Z(t, e, n) {
+  return e.find((r) => t.slice(n, n + r.length).toUpperCase() === r.toUpperCase());
+}
+function q(t, e) {
+  let n = 0;
+  for (let r = e - 1; r >= 0 && t[r] === "\\"; r -= 1)
+    n += 1;
+  return n % 2 === 1;
+}
+function ce(t) {
+  let e = !1;
+  for (let n = 0; n < t.length; n += 1) {
+    const r = t[n];
+    if (r === '"' && !q(t, n)) {
+      e = !e;
+      continue;
+    }
+    if (e)
+      continue;
+    const s = n > 0 ? t[n - 1] : void 0, o = r === "#" && (n === 0 || /\s/.test(s || "")), a = t.slice(n, n + 2) === "//" && (n === 0 || /\s/.test(s || ""));
+    if (o || a)
+      return t.slice(0, n).trimEnd();
+  }
+  return t.trimEnd();
+}
+function le(t, e) {
+  if (!e.length)
+    return [t];
+  const n = [];
+  let r = !1, s = 0;
+  for (let o = 0; o < t.length; ) {
+    if (t[o] === '"' && !q(t, o)) {
+      r = !r, o += 1;
+      continue;
+    }
+    if (!r) {
+      const c = Z(
+        t,
+        e,
+        o
+      );
+      if (c) {
+        n.push(t.slice(s, o)), o += c.length, s = o;
+        continue;
+      }
+    }
+    o += 1;
+  }
+  return n.push(t.slice(s)), n;
+}
+function ue(t, e, n) {
+  let r = e;
+  for (; r < t.length && /\s/.test(t[r]); )
+    r += 1;
+  if (r >= t.length)
+    return;
+  if (t[r] === '"') {
+    for (r += 1; r < t.length; ) {
+      if (t[r] === '"' && !q(t, r))
+        return {
+          nextIndex: r + 1
+        };
+      r += 1;
+    }
+    return;
+  }
+  const s = r;
+  for (; r < t.length && !Z(
+    t,
+    n,
+    r
+  ); )
+    r += 1;
+  if (t.slice(s, r).trim())
+    return {
+      nextIndex: r
+    };
+}
+function fe(t, e) {
+  const n = t.trim(), r = [
+    ...e.tokens?.commandPrefixes || S.commandPrefixes
+  ].sort((i, l) => l.length - i.length), s = [
+    ...e.tokens?.argumentSeparators || S.argumentSeparators
+  ].sort((i, l) => l.length - i.length);
+  let o = 0;
+  if (!n)
+    return E("AT command segments cannot be empty.");
+  const a = Z(
+    n,
+    r,
+    o
+  );
+  if (!a)
+    return E("AT commands must start with a configured prefix.");
+  o += a.length;
+  const c = n.slice(o).match(/^[A-Z][A-Z0-9_:-]*/i);
+  if (!c)
+    return E("AT commands must include a command name.");
+  for (o += c[0].length; o < n.length; ) {
+    for (; o < n.length && /\s/.test(n[o]); )
+      o += 1;
+    if (o >= n.length)
+      return C;
+    const i = n[o] === "=" ? "=" : Z(n, s, o);
+    if (!i)
+      return E("AT commands can only continue with assignments or arguments.");
+    o += i.length;
+    const l = ue(
+      n,
+      o,
+      s
+    );
+    if (!l)
+      return E("AT command arguments must provide a value.");
+    o = l.nextIndex;
+  }
+  return C;
+}
+function de(t, e) {
+  const n = e || lt, r = [
+    ...n.tokens?.concatenationSeparators || S.concatenationSeparators
+  ].sort((o, a) => a.length - o.length), s = t.split(`
+`);
+  for (let o = 0; o < s.length; o += 1) {
+    const a = ce(s[o]).trim();
+    if (!a)
+      continue;
+    const c = le(a, r);
+    if (c.some((i) => !i.trim()))
+      return E(
+        `Invalid AT commands syntax on line ${o + 1}.`,
+        v(t, o)
+      );
+    for (const i of c)
+      if (!fe(
+        i,
+        n
+      ).isValid)
+        return E(
+          `Invalid AT commands syntax on line ${o + 1}.`,
+          v(t, o)
+        );
+  }
+  return C;
+}
+function me(t) {
+  if (!t.trim())
+    return C;
+  try {
+    return JSON.parse(t), C;
+  } catch (e) {
+    return E(
+      "Invalid JSON syntax.",
+      oe(
+        t,
+        e instanceof Error ? e.message : "Invalid JSON syntax."
+      )
+    );
+  }
+}
+function Re({
+  code: t,
+  languageTemplate: e,
+  languageText: n
+}) {
+  const r = dt(e), s = K(
+    n ?? r?.languageText
+  );
+  switch (s) {
+    case B:
+      return de(t, r);
+    case "json":
+      return me(t);
+    default:
+      return st[s] ? ie(
+        t,
+        st[s]
+      ) : C;
+  }
+}
+function Pe(t) {
+  return t.split(`
+`).length;
+}
+function A(t, e, n) {
+  if (!t)
+    return !1;
+  const r = Math.max(e + 1, n);
+  return e < t.end.offset && t.start.offset < r;
+}
+function pe(t, e, n) {
+  const r = e + t.length, s = Math.max(n.start.offset, e), o = Math.min(n.end.offset, r);
+  if (s >= o)
+    return [{ text: t || " ", hasError: !1 }];
+  const a = s - e, c = o - e, i = [];
+  return a > 0 && i.push({
+    hasError: !1,
+    text: t.slice(0, a)
+  }), i.push({
+    hasError: !0,
+    text: t.slice(a, c)
+  }), c < t.length && i.push({
+    hasError: !1,
+    text: t.slice(c)
+  }), i.filter((l) => l.text.length > 0);
+}
+function we(t) {
+  const e = X(t), n = Gt(t);
+  return {
+    plain: {
+      backgroundColor: "transparent",
+      color: e.surface.editorForeground
+    },
+    bracketPalette: zt(t),
+    semanticPalette: n,
+    styles: [
+      {
+        types: ["comment", "prolog", "doctype", "cdata"],
+        style: {
+          color: e.syntax.comment,
+          fontStyle: "italic"
+        }
+      },
+      {
+        types: ["punctuation"],
+        style: {
+          color: e.surface.editorForeground
+        }
+      },
+      {
+        types: ["operator"],
+        style: {
+          color: e.syntax.operator
+        }
+      },
+      {
+        types: ["property", "literal-property", "selector"],
+        style: {
+          color: n.variable
+        }
+      },
+      {
+        types: ["attr-name"],
+        style: {
+          color: e.syntax.attributeName
+        }
+      },
+      {
+        types: ["tag"],
+        style: {
+          color: e.syntax.tag
+        }
+      },
+      {
+        types: ["boolean"],
+        style: {
+          color: e.syntax.boolean
+        }
+      },
+      {
+        types: ["number"],
+        style: {
+          color: e.syntax.number
+        }
+      },
+      {
+        types: ["symbol"],
+        style: {
+          color: e.syntax.constant
+        }
+      },
+      {
+        types: ["atrule"],
+        style: {
+          color: e.syntax.keyword
+        }
+      },
+      {
+        types: ["constant"],
+        style: {
+          color: n.constant
+        }
+      },
+      {
+        types: ["string", "char", "inserted"],
+        style: {
+          color: e.syntax.string
+        }
+      },
+      {
+        types: ["regex"],
+        style: {
+          color: e.syntax.regex
+        }
+      },
+      {
+        types: ["constant.character.escape"],
+        style: {
+          color: e.syntax.escape
+        }
+      },
+      {
+        types: ["keyword"],
+        style: {
+          color: e.syntax.keyword
+        }
+      },
+      {
+        types: ["function", "function-variable", "method", "method-variable"],
+        style: {
+          color: e.syntax.function
+        }
+      },
+      {
+        types: ["builtin", "class-name", "known-class-name", "maybe-class-name"],
+        style: {
+          color: n.type
+        }
+      },
+      {
+        types: ["alias", "imports", "parameter", "variable"],
+        style: {
+          color: n.variable
+        }
+      },
+      {
+        types: ["deleted"],
+        style: {
+          color: e.surface.errorBorderColor
+        }
+      }
+    ]
+  };
+}
+function Me({
+  code: t,
+  customLanguages: e,
+  languageTemplate: n,
+  languageText: r,
+  prismTheme: s,
+  syntaxErrorRange: o
+}) {
+  const a = te(n);
+  ee(e);
+  const c = K(
+    r ?? a?.languageText
+  ), i = F[c], l = t.split(`
+`), w = Q(l), y = ne(
+    t,
+    o
+  );
+  return !i || c === ct ? /* @__PURE__ */ d(ot, { children: l.map((L, b) => {
+    const _ = w[b] || 0, k = A(
+      y,
+      _,
+      _ + L.length
+    ), N = y ? pe(
+      L,
+      _,
+      y
+    ) : [{ hasError: !1, text: L || " " }];
+    return /* @__PURE__ */ d(
+      "div",
+      {
+        className: "token-line",
+        "data-code-editor-error-line": k || void 0,
+        children: N.map((M, $) => /* @__PURE__ */ d(
+          "span",
+          {
+            className: "token plain",
+            "data-code-editor-error-token": M.hasError || void 0,
+            children: M.text || " "
+          },
+          `plain-line-${b}-segment-${$}`
+        ))
+      },
+      `plain-line-${b}`
+    );
+  }) }) : /* @__PURE__ */ d(
+    kt,
+    {
+      code: t || " ",
+      language: c,
+      prism: it,
+      theme: s,
+      children: ({ tokens: L, getLineProps: b, getTokenProps: _ }) => {
+        const k = s.bracketPalette, N = s.semanticPalette, M = !!N && Ut(c);
+        let $ = 0;
+        const x = {};
+        return /* @__PURE__ */ d(ot, { children: L.map((j, O) => {
+          const V = w[O] || 0, pt = l[O] || "", gt = A(
+            y,
+            V,
+            V + pt.length
+          );
+          let tt = 0;
+          const ht = b({ line: j });
+          return /* @__PURE__ */ d(
+            "div",
+            {
+              ...ht,
+              "data-code-editor-error-line": gt || void 0,
+              children: j.map((u, z) => {
+                const T = V + tt, Et = T + u.content.length, yt = A(
+                  y,
+                  T,
+                  Et
+                );
+                tt += u.content.length;
+                const p = _({ token: u }), et = Wt(
+                  u.types
+                );
+                if (M && u.types.includes("plain") && u.content.trim()) {
+                  const g = Bt(u.content);
+                  if (g.some((h) => h.isIdentifier)) {
+                    let h = 0;
+                    return g.map((f, G) => {
+                      const D = `token-${O}-${z}-${G}`, nt = T + h, Ct = nt + f.content.length, rt = A(
+                        y,
+                        nt,
+                        Ct
+                      );
+                      if (h += f.content.length, !f.isIdentifier || !N)
+                        return I(
+                          x,
+                          f.content
+                        ), /* @__PURE__ */ d(
+                          "span",
+                          {
+                            className: p.className,
+                            style: p.style,
+                            "data-code-editor-error-token": rt || void 0,
+                            children: f.content
+                          },
+                          D
+                        );
+                      const xt = g.slice(G + 1).map((Tt) => Tt.content).join(""), U = Ht({
+                        identifier: f.content,
+                        nextSignificantText: Ft(
+                          j,
+                          z,
+                          xt
+                        ),
+                        previousIdentifierGroup: x.previousIdentifierGroup,
+                        previousSignificantText: x.previousSignificantText
+                      });
+                      return I(
+                        x,
+                        f.content,
+                        U
+                      ), /* @__PURE__ */ d(
+                        "span",
+                        {
+                          className: p.className,
+                          style: U ? {
+                            ...p.style,
+                            color: N[U]
+                          } : p.style,
+                          "data-code-editor-error-token": rt || void 0,
+                          "data-code-editor-token-group": U,
+                          children: f.content
+                        },
+                        D
+                      );
+                    });
+                  }
+                }
+                return !k?.length || !u.types.includes("punctuation") || !/[()[\]{}]/.test(u.content) ? (I(
+                  x,
+                  u.content,
+                  et
+                ), /* @__PURE__ */ d(
+                  "span",
+                  {
+                    ...p,
+                    "data-code-editor-error-token": yt || void 0,
+                    "data-code-editor-token-group": et
+                  },
+                  `token-${O}-${z}`
+                )) : Array.from(u.content).map((g, h) => {
+                  const f = `token-${O}-${z}-${h}`;
+                  if (!Jt(g))
+                    return I(x, g), /* @__PURE__ */ d(
+                      "span",
+                      {
+                        className: p.className,
+                        style: p.style,
+                        "data-code-editor-error-token": A(
+                          y,
+                          T + h,
+                          T + h + 1
+                        ) || void 0,
+                        children: g
+                      },
+                      f
+                    );
+                  const {
+                    nextBracketDepth: G,
+                    renderedBracketDepth: D
+                  } = Xt(g, $);
+                  return $ = G, I(x, g), /* @__PURE__ */ d(
+                    "span",
+                    {
+                      className: p.className,
+                      style: {
+                        ...p.style,
+                        color: k[D % k.length]
+                      },
+                      "data-code-editor-error-token": A(
+                        y,
+                        T + h,
+                        T + h + 1
+                      ) || void 0,
+                      "data-code-editor-bracket-depth": D,
+                      children: g
+                    },
+                    f
+                  );
+                });
+              })
+            },
+            `token-line-${O}`
+          );
+        }) });
+      }
+    }
+  );
+}
+export {
+  lt as DEFAULT_CODE_EDITOR_AT_LANGUAGE_TEMPLATE,
+  Kt as buildAtCommandGrammar,
+  ut as createCodeEditorLanguageGrammar,
+  we as createCodeEditorPrismTheme,
+  W as createTokenAlternation,
+  te as ensureCodeEditorLanguageTemplate,
+  ee as ensureCodeEditorLanguages,
+  Yt as escapeRegExpToken,
+  Pe as getCodeEditorLineCount,
+  Me as highlightCode,
+  ft as registerCodeEditorLanguage,
+  qt as registerCodeEditorLanguageTemplate,
+  K as resolveCodeEditorLanguage,
+  dt as resolveCodeEditorLanguageTemplate,
+  Qt as seedCodeEditorLanguageTemplate,
+  Re as validateCodeEditorSyntax
+};