@m4l/components 9.16.0 → 9.17.1-beta-feature-731-m4l-components-code-editor.0

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

@@ -0,0 +1,1063 @@
+import { jsx as f, Fragment as st } from "@emotion/react/jsx-runtime";
+import K from "prismjs";
+import { Highlight as Tt } from "prism-react-renderer";
+import { CODE_EDITOR_AT_TEMPLATE_TOKENS as S, CODE_EDITOR_AT_LANGUAGE as B, CODE_EDITOR_AT_TEMPLATE_NAME as St, CODE_EDITOR_AT_TEMPLATE_LANGUAGE_LABEL as vt, CODE_EDITOR_DEFAULT_LANGUAGE as at, CODE_EDITOR_LANGUAGE_ALIASES as Ot, getCodeEditorVSCodeModernPalette as Q } from "../constants.js";
+const V = K.languages, ct = {}, lt = {}, j = /* @__PURE__ */ new WeakMap(), At = /* @__PURE__ */ new Set(["(", ")", "[", "]", "{", "}"]), bt = /* @__PURE__ */ new Set([
+  "javascript",
+  "jsx",
+  "typescript",
+  "tsx"
+]), Lt = /* @__PURE__ */ new Set([
+  "(",
+  ")",
+  "[",
+  "]",
+  "{",
+  "}",
+  ".",
+  ",",
+  ":",
+  ";",
+  "=",
+  "=>",
+  "as",
+  "await",
+  "case",
+  "const",
+  "default",
+  "export",
+  "from",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "of",
+  "return",
+  "throw",
+  "typeof",
+  "var",
+  "yield"
+]), _t = /* @__PURE__ */ new Set([
+  "(",
+  ":",
+  "=>",
+  "as",
+  "case",
+  "class",
+  "enum",
+  "extends",
+  "implements",
+  "instanceof",
+  "interface",
+  "new",
+  "type",
+  "typeof"
+]), kt = /^[+\-*/%!?&|^~]+$/, y = {
+  isValid: !0
+}, pe = {
+  languageLabel: vt,
+  languageText: B,
+  templateName: St,
+  templateType: B,
+  tokens: {
+    argumentSeparators: [...S.argumentSeparators],
+    commandPrefixes: [...S.commandPrefixes],
+    concatenationSeparators: [...S.concatenationSeparators],
+    reservedWords: [...S.reservedWords]
+  }
+};
+function Nt(t) {
+  return [...Q(t).bracketPalette];
+}
+function Rt(t) {
+  const e = Q(t);
+  return {
+    constant: e.syntax.constant,
+    type: e.syntax.type,
+    variable: e.syntax.variable
+  };
+}
+function Pt(t) {
+  return bt.has(t);
+}
+function It(t) {
+  const e = [], n = Array.from(t.matchAll(/[A-Za-z_$][\w$]*/g));
+  let r = 0;
+  return n.forEach((s) => {
+    const o = s[0], i = s.index ?? 0;
+    i > r && e.push({
+      content: t.slice(r, i),
+      isIdentifier: !1
+    }), e.push({
+      content: o,
+      isIdentifier: !0
+    }), r = i + o.length;
+  }), r < t.length && e.push({
+    content: t.slice(r),
+    isIdentifier: !1
+  }), e.length ? e : [{ content: t, isIdentifier: !1 }];
+}
+function X(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 wt(t, e, n = "") {
+  const r = X(
+    n
+  );
+  if (r)
+    return r;
+  for (let s = e + 1; s < t.length; s += 1) {
+    const o = X(
+      t[s].content
+    );
+    if (o)
+      return o;
+  }
+}
+function Dt(t) {
+  return t.length > 1 && t === t.toUpperCase() && /[A-Z]/.test(t);
+}
+function Mt(t) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(t) && t !== t.toUpperCase();
+}
+function $t(t, e) {
+  return t === ">" && e === "<" ? !1 : [t, e].some(
+    (n) => !!n && (Lt.has(n) || kt.test(n))
+  );
+}
+function zt(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 Gt({
+  identifier: t,
+  nextSignificantText: e,
+  previousIdentifierGroup: n,
+  previousSignificantText: r
+}) {
+  if ($t(
+    r,
+    e
+  ))
+    return r === "." && n === "type" || Dt(t) ? "constant" : Mt(t) && (e === "." || e === "(" || r && _t.has(r)) ? "type" : "variable";
+}
+function I(t, e, n) {
+  const r = X(e);
+  if (r) {
+    if (t.previousSignificantText = r, n) {
+      t.previousIdentifierGroup = n;
+      return;
+    }
+    r !== "." && (t.previousIdentifierGroup = void 0);
+  }
+}
+function Ft(t) {
+  return At.has(t);
+}
+function Ut(t, e) {
+  if ("([{".includes(t))
+    return {
+      renderedBracketDepth: e,
+      nextBracketDepth: e + 1
+    };
+  const n = Math.max(e - 1, 0);
+  return {
+    renderedBracketDepth: n,
+    nextBracketDepth: n
+  };
+}
+function Bt(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function J(t) {
+  const e = t?.map((n) => n.trim()).filter(Boolean);
+  if (e?.length)
+    return e.map(Bt).join("|");
+}
+function Vt(t) {
+  const e = J(t.tokens?.commandPrefixes) || "AT\\+", n = J(
+    t.tokens?.reservedWords
+  ), r = J([
+    ...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 Zt(t) {
+  return t.templateType === B ? Vt(t) : {};
+}
+function ge(t, e) {
+  t.trim() && (V[b(t)] = e);
+}
+function he(t) {
+  const e = t.templateName.trim();
+  e && (ct[e] = t);
+}
+function ut(t) {
+  if (t)
+    return typeof t == "string" ? ct[t] : t;
+}
+function Wt(t) {
+  return ut(t);
+}
+function Ee(t, e) {
+  t.trim() && (lt[b(t)] = e);
+}
+function ye(t) {
+  return ({ code: e }) => Qt(e, t);
+}
+function Ht(t) {
+  return t ? Array.isArray(t) ? t : [t] : [];
+}
+async function Ce(t) {
+  await Promise.all(
+    Ht(t).map((e) => {
+      const n = j.get(e);
+      if (n)
+        return n;
+      const r = Promise.resolve().then(() => e()).then(() => {
+      }).catch((s) => {
+        throw j.delete(e), s;
+      });
+      return j.set(e, r), r;
+    })
+  );
+}
+function b(t) {
+  const e = t?.trim().toLowerCase() || at;
+  return Ot[e] || e;
+}
+function D(t, e) {
+  return Math.max(0, Math.min(e, t.length));
+}
+function m(t, e) {
+  const n = D(t, e), s = t.slice(0, n).split(`
+`);
+  return {
+    column: (s[s.length - 1] || "").length + 1,
+    line: s.length,
+    offset: n
+  };
+}
+function dt(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(`
+`), i = s === 1 ? 0 : o.length + 1, c = r[s - 1] || "";
+  return D(
+    t,
+    i + Math.max(Math.min(n - 1, c.length), 0)
+  );
+}
+function it(t, e) {
+  return typeof e.offset == "number" ? m(t, e.offset) : m(
+    t,
+    dt(t, e.line, e.column)
+  );
+}
+function w(t, e, n) {
+  const r = D(t, e), s = Math.max(
+    r + 1,
+    D(t, n)
+  );
+  return {
+    end: m(
+      t,
+      s - 1
+    ),
+    start: m(t, r)
+  };
+}
+function jt(t, e) {
+  if (!e)
+    return;
+  const n = it(
+    t,
+    e.start
+  ), r = it(
+    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, i = r.trimEnd().length, c = s + o, a = s + Math.max(i, o + 1);
+  return w(t, c, a);
+}
+function Y(t, e) {
+  for (let n = e; n >= 0; n -= 1)
+    if (!/\s/.test(t[n]))
+      return n;
+}
+function Jt(t, e) {
+  const n = e.match(/\bposition\s+(\d+)\b/i);
+  if (n)
+    return D(t, Number(n[1]));
+  const r = e.match(/\bline\s+(\d+)\s+column\s+(\d+)\b/i);
+  if (r)
+    return dt(
+      t,
+      Number(r[1]),
+      Number(r[2])
+    );
+}
+function Kt(t, e) {
+  const n = Jt(t, e);
+  if (typeof n != "number") {
+    const l = Y(
+      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(`
+`), i = o[s] || "", c = t[n], a = Y(
+    t,
+    Math.min(n - 1, t.length - 1)
+  );
+  if ((c === "}" || c === "]") && typeof a == "number" && t[a] === ",")
+    return v(
+      t,
+      m(
+        t,
+        a
+      ).line - 1
+    );
+  if (i.trim()) {
+    const l = q(o)[s] || 0, M = i.length - i.trimStart().length;
+    return w(
+      t,
+      l + M,
+      n + 1
+    );
+  }
+  return typeof a == "number" ? v(
+    t,
+    m(
+      t,
+      a
+    ).line - 1
+  ) : v(t, s);
+}
+function E(t, e) {
+  return {
+    errorRange: e,
+    isValid: !1,
+    message: t
+  };
+}
+function Xt(t, e, n) {
+  if (e < n)
+    return w(t, e, n);
+  const r = m(
+    t,
+    e
+  ), s = v(
+    t,
+    r.line - 1
+  );
+  if (s)
+    return s;
+  const o = Y(
+    t,
+    Math.min(e - 1, t.length - 1)
+  );
+  return typeof o == "number" ? w(
+    t,
+    o,
+    o + 1
+  ) : w(t, e, e + 1);
+}
+function Yt(t, e) {
+  const n = e.parse(t).cursor();
+  for (; ; ) {
+    if (n.type.isError)
+      return Xt(
+        t,
+        n.from,
+        n.to
+      );
+    if (!n.firstChild()) {
+      for (; !n.nextSibling(); )
+        if (!n.parent())
+          return;
+    }
+  }
+}
+function Qt(t, e) {
+  if (!t.trim())
+    return y;
+  const n = Yt(
+    t,
+    e.parser
+  );
+  return n ? E(
+    `Invalid ${e.label} syntax.`,
+    n
+  ) : y;
+}
+function Z(t, e, n) {
+  return e.find((r) => t.slice(n, n + r.length).toUpperCase() === r.toUpperCase());
+}
+function tt(t, e) {
+  let n = 0;
+  for (let r = e - 1; r >= 0 && t[r] === "\\"; r -= 1)
+    n += 1;
+  return n % 2 === 1;
+}
+function qt(t) {
+  let e = !1;
+  for (let n = 0; n < t.length; n += 1) {
+    const r = t[n];
+    if (r === '"' && !tt(t, n)) {
+      e = !e;
+      continue;
+    }
+    if (e)
+      continue;
+    const s = n > 0 ? t[n - 1] : void 0, o = r === "#" && (n === 0 || /\s/.test(s || "")), i = t.slice(n, n + 2) === "//" && (n === 0 || /\s/.test(s || ""));
+    if (o || i)
+      return t.slice(0, n).trimEnd();
+  }
+  return t.trimEnd();
+}
+function te(t, e) {
+  if (!e.length)
+    return [t];
+  const n = [];
+  let r = !1, s = 0;
+  for (let o = 0; o < t.length; ) {
+    if (t[o] === '"' && !tt(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 ee(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] === '"' && !tt(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 ne(t, e) {
+  const n = t.trim(), r = [
+    ...e.tokens?.commandPrefixes || S.commandPrefixes
+  ].sort((a, l) => l.length - a.length), s = [
+    ...e.tokens?.argumentSeparators || S.argumentSeparators
+  ].sort((a, l) => l.length - a.length);
+  let o = 0;
+  if (!n)
+    return E("AT command segments cannot be empty.");
+  const i = Z(
+    n,
+    r,
+    o
+  );
+  if (!i)
+    return E("AT commands must start with a configured prefix.");
+  o += i.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 y;
+    const a = n[o] === "=" ? "=" : Z(n, s, o);
+    if (!a)
+      return E("AT commands can only continue with assignments or arguments.");
+    o += a.length;
+    const l = ee(
+      n,
+      o,
+      s
+    );
+    if (!l)
+      return E("AT command arguments must provide a value.");
+    o = l.nextIndex;
+  }
+  return y;
+}
+function re(t, e) {
+  if (!e)
+    return y;
+  const n = e, r = [
+    ...n.tokens?.concatenationSeparators || S.concatenationSeparators
+  ].sort((o, i) => i.length - o.length), s = t.split(`
+`);
+  for (let o = 0; o < s.length; o += 1) {
+    const i = qt(s[o]).trim();
+    if (!i)
+      continue;
+    const c = te(i, r);
+    if (c.some((a) => !a.trim()))
+      return E(
+        `Invalid AT commands syntax on line ${o + 1}.`,
+        v(t, o)
+      );
+    for (const a of c)
+      if (!ne(
+        a,
+        n
+      ).isValid)
+        return E(
+          `Invalid AT commands syntax on line ${o + 1}.`,
+          v(t, o)
+        );
+  }
+  return y;
+}
+function oe(t) {
+  if (!t.trim())
+    return y;
+  try {
+    return JSON.parse(t), y;
+  } catch (e) {
+    return E(
+      "Invalid JSON syntax.",
+      Kt(
+        t,
+        e instanceof Error ? e.message : "Invalid JSON syntax."
+      )
+    );
+  }
+}
+function se(t) {
+  return lt[t];
+}
+function xe({
+  code: t,
+  languageTemplate: e,
+  languageText: n
+}) {
+  const r = ut(e), s = b(
+    n ?? r?.languageText
+  );
+  switch (s) {
+    case B:
+      return re(t, r);
+    case "json":
+      return oe(t);
+    default:
+      return se(s)?.({
+        code: t,
+        languageTemplate: e,
+        languageText: s
+      }) ?? y;
+  }
+}
+function Te(t) {
+  return t.split(`
+`).length;
+}
+function ie(t, e) {
+  return e ? Object.entries(e).find(
+    ([r]) => b(r) === t
+  )?.[1] : void 0;
+}
+function ae(t, e) {
+  const n = ie(
+    t,
+    e.customLanguages
+  );
+  return n || (e.languageTemplate && b(e.languageTemplate.languageText) === t ? Zt(e.languageTemplate) : V[t]);
+}
+function ce(t, e) {
+  return !e || V[t] === e ? K : {
+    ...K,
+    languages: {
+      ...V,
+      [t]: e
+    }
+  };
+}
+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 le(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 i = s - e, c = o - e, a = [];
+  return i > 0 && a.push({
+    hasError: !1,
+    text: t.slice(0, i)
+  }), a.push({
+    hasError: !0,
+    text: t.slice(i, c)
+  }), c < t.length && a.push({
+    hasError: !1,
+    text: t.slice(c)
+  }), a.filter((l) => l.text.length > 0);
+}
+function Se(t) {
+  const e = Q(t), n = Rt(t);
+  return {
+    plain: {
+      backgroundColor: "transparent",
+      color: e.surface.editorForeground
+    },
+    bracketPalette: Nt(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 ve({
+  code: t,
+  customLanguages: e,
+  languageTemplate: n,
+  languageText: r,
+  prismTheme: s,
+  syntaxErrorRange: o
+}) {
+  const i = Wt(n), c = b(
+    r ?? i?.languageText
+  ), a = ae(c, {
+    customLanguages: e,
+    languageTemplate: i
+  }), l = t.split(`
+`), M = q(l), C = jt(
+    t,
+    o
+  ), ft = ce(c, a);
+  return !a || c === at ? /* @__PURE__ */ f(st, { children: l.map((L, _) => {
+    const k = M[_] || 0, N = A(
+      C,
+      k,
+      k + L.length
+    ), R = C ? le(
+      L,
+      k,
+      C
+    ) : [{ hasError: !1, text: L || " " }];
+    return /* @__PURE__ */ f(
+      "div",
+      {
+        className: "token-line",
+        "data-code-editor-error-line": N || void 0,
+        children: R.map(($, z) => /* @__PURE__ */ f(
+          "span",
+          {
+            className: "token plain",
+            "data-code-editor-error-token": $.hasError || void 0,
+            children: $.text || " "
+          },
+          `plain-line-${_}-segment-${z}`
+        ))
+      },
+      `plain-line-${_}`
+    );
+  }) }) : /* @__PURE__ */ f(
+    Tt,
+    {
+      code: t || " ",
+      language: c,
+      prism: ft,
+      theme: s,
+      children: ({ tokens: L, getLineProps: _, getTokenProps: k }) => {
+        const N = s.bracketPalette, R = s.semanticPalette, $ = !!R && Pt(c);
+        let z = 0;
+        const x = {};
+        return /* @__PURE__ */ f(st, { children: L.map((W, O) => {
+          const H = M[O] || 0, mt = l[O] || "", pt = A(
+            C,
+            H,
+            H + mt.length
+          );
+          let et = 0;
+          const gt = _({ line: W });
+          return /* @__PURE__ */ f(
+            "div",
+            {
+              ...gt,
+              "data-code-editor-error-line": pt || void 0,
+              children: W.map((u, G) => {
+                const T = H + et, ht = T + u.content.length, Et = A(
+                  C,
+                  T,
+                  ht
+                );
+                et += u.content.length;
+                const p = k({ token: u }), nt = zt(
+                  u.types
+                );
+                if ($ && u.types.includes("plain") && u.content.trim()) {
+                  const g = It(u.content);
+                  if (g.some((h) => h.isIdentifier)) {
+                    let h = 0;
+                    return g.map((d, F) => {
+                      const P = `token-${O}-${G}-${F}`, rt = T + h, yt = rt + d.content.length, ot = A(
+                        C,
+                        rt,
+                        yt
+                      );
+                      if (h += d.content.length, !d.isIdentifier || !R)
+                        return I(
+                          x,
+                          d.content
+                        ), /* @__PURE__ */ f(
+                          "span",
+                          {
+                            className: p.className,
+                            style: p.style,
+                            "data-code-editor-error-token": ot || void 0,
+                            children: d.content
+                          },
+                          P
+                        );
+                      const Ct = g.slice(F + 1).map((xt) => xt.content).join(""), U = Gt({
+                        identifier: d.content,
+                        nextSignificantText: wt(
+                          W,
+                          G,
+                          Ct
+                        ),
+                        previousIdentifierGroup: x.previousIdentifierGroup,
+                        previousSignificantText: x.previousSignificantText
+                      });
+                      return I(
+                        x,
+                        d.content,
+                        U
+                      ), /* @__PURE__ */ f(
+                        "span",
+                        {
+                          className: p.className,
+                          style: U ? {
+                            ...p.style,
+                            color: R[U]
+                          } : p.style,
+                          "data-code-editor-error-token": ot || void 0,
+                          "data-code-editor-token-group": U,
+                          children: d.content
+                        },
+                        P
+                      );
+                    });
+                  }
+                }
+                return !N?.length || !u.types.includes("punctuation") || !/[()[\]{}]/.test(u.content) ? (I(
+                  x,
+                  u.content,
+                  nt
+                ), /* @__PURE__ */ f(
+                  "span",
+                  {
+                    ...p,
+                    "data-code-editor-error-token": Et || void 0,
+                    "data-code-editor-token-group": nt
+                  },
+                  `token-${O}-${G}`
+                )) : Array.from(u.content).map((g, h) => {
+                  const d = `token-${O}-${G}-${h}`;
+                  if (!Ft(g))
+                    return I(x, g), /* @__PURE__ */ f(
+                      "span",
+                      {
+                        className: p.className,
+                        style: p.style,
+                        "data-code-editor-error-token": A(
+                          C,
+                          T + h,
+                          T + h + 1
+                        ) || void 0,
+                        children: g
+                      },
+                      d
+                    );
+                  const {
+                    nextBracketDepth: F,
+                    renderedBracketDepth: P
+                  } = Ut(g, z);
+                  return z = F, I(x, g), /* @__PURE__ */ f(
+                    "span",
+                    {
+                      className: p.className,
+                      style: {
+                        ...p.style,
+                        color: N[P % N.length]
+                      },
+                      "data-code-editor-error-token": A(
+                        C,
+                        T + h,
+                        T + h + 1
+                      ) || void 0,
+                      "data-code-editor-bracket-depth": P,
+                      children: g
+                    },
+                    d
+                  );
+                });
+              })
+            },
+            `token-line-${O}`
+          );
+        }) });
+      }
+    }
+  );
+}
+export {
+  pe as DEFAULT_CODE_EDITOR_AT_LANGUAGE_TEMPLATE,
+  Vt as buildAtCommandGrammar,
+  Zt as createCodeEditorLanguageGrammar,
+  ye as createCodeEditorLezerSyntaxValidator,
+  Se as createCodeEditorPrismTheme,
+  J as createTokenAlternation,
+  Wt as ensureCodeEditorLanguageTemplate,
+  Ce as ensureCodeEditorRuntimeDependencies,
+  Bt as escapeRegExpToken,
+  Te as getCodeEditorLineCount,
+  ve as highlightCode,
+  ge as registerCodeEditorLanguage,
+  he as registerCodeEditorLanguageTemplate,
+  Ee as registerCodeEditorSyntaxValidator,
+  b as resolveCodeEditorLanguage,
+  ut as resolveCodeEditorLanguageTemplate,
+  xe as validateCodeEditorSyntax
+};