@scalar/agent-chat 0.2.0 → 0.2.2

package/dist/node_modules/.pnpm/@codemirror_lang-javascript@6.2.4/node_modules/@codemirror/lang-javascript/dist/index.js

@@ -0,0 +1,300 @@
+import { parser as x } from "../../../../../@lezer_javascript@1.5.4/node_modules/@lezer/javascript/dist/index.js";
+import { LRLanguage as B, indentNodeProp as F, foldNodeProp as j, continuedIndent as b, delimitedIndent as L, flatIndent as N, foldInside as O, sublanguageProp as T, defineLanguageFacet as P, LanguageSupport as V, syntaxTree as C } from "../../../../../@codemirror_language@6.11.3/node_modules/@codemirror/language/dist/index.js";
+import { EditorSelection as M } from "../../../../../@codemirror_state@6.5.2/node_modules/@codemirror/state/dist/index.js";
+import { EditorView as _ } from "../../../../../@codemirror_view@6.38.6/node_modules/@codemirror/view/dist/index.js";
+import { snippetCompletion as r, ifNotIn as R, completeFromList as W } from "../../../../../@codemirror_autocomplete@6.19.1/node_modules/@codemirror/autocomplete/dist/index.js";
+import { NodeWeakMap as H, IterMode as K } from "../../../../../@lezer_common@1.3.0/node_modules/@lezer/common/dist/index.js";
+const J = [
+  /* @__PURE__ */ r("function ${name}(${params}) {\n	${}\n}", {
+    label: "function",
+    detail: "definition",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("for (let ${index} = 0; ${index} < ${bound}; ${index}++) {\n	${}\n}", {
+    label: "for",
+    detail: "loop",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("for (let ${name} of ${collection}) {\n	${}\n}", {
+    label: "for",
+    detail: "of loop",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("do {\n	${}\n} while (${})", {
+    label: "do",
+    detail: "loop",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("while (${}) {\n	${}\n}", {
+    label: "while",
+    detail: "loop",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r(`try {
+	\${}
+} catch (\${error}) {
+	\${}
+}`, {
+    label: "try",
+    detail: "/ catch block",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("if (${}) {\n	${}\n}", {
+    label: "if",
+    detail: "block",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r(`if (\${}) {
+	\${}
+} else {
+	\${}
+}`, {
+    label: "if",
+    detail: "/ else block",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r(`class \${name} {
+	constructor(\${params}) {
+		\${}
+	}
+}`, {
+    label: "class",
+    detail: "definition",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r('import {${names}} from "${module}"\n${}', {
+    label: "import",
+    detail: "named",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r('import ${name} from "${module}"\n${}', {
+    label: "import",
+    detail: "default",
+    type: "keyword"
+  })
+], q = /* @__PURE__ */ J.concat([
+  /* @__PURE__ */ r("interface ${name} {\n	${}\n}", {
+    label: "interface",
+    detail: "definition",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("type ${name} = ${type}", {
+    label: "type",
+    detail: "definition",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ r("enum ${name} {\n	${}\n}", {
+    label: "enum",
+    detail: "definition",
+    type: "keyword"
+  })
+]), h = /* @__PURE__ */ new H(), X = /* @__PURE__ */ new Set([
+  "Script",
+  "Block",
+  "FunctionExpression",
+  "FunctionDeclaration",
+  "ArrowFunction",
+  "MethodDeclaration",
+  "ForStatement"
+]);
+function d(e) {
+  return (t, o) => {
+    let n = t.node.getChild("VariableDefinition");
+    return n && o(n, e), !0;
+  };
+}
+const z = ["FunctionDeclaration"], G = {
+  FunctionDeclaration: /* @__PURE__ */ d("function"),
+  ClassDeclaration: /* @__PURE__ */ d("class"),
+  ClassExpression: () => !0,
+  EnumDeclaration: /* @__PURE__ */ d("constant"),
+  TypeAliasDeclaration: /* @__PURE__ */ d("type"),
+  NamespaceDeclaration: /* @__PURE__ */ d("namespace"),
+  VariableDefinition(e, t) {
+    e.matchContext(z) || t(e, "variable");
+  },
+  TypeDefinition(e, t) {
+    t(e, "type");
+  },
+  __proto__: null
+};
+function I(e, t) {
+  let o = h.get(t);
+  if (o)
+    return o;
+  let n = [], l = !0;
+  function u(a, s) {
+    let f = e.sliceString(a.from, a.to);
+    n.push({ label: f, type: s });
+  }
+  return t.cursor(K.IncludeAnonymous).iterate((a) => {
+    if (l)
+      l = !1;
+    else if (a.name) {
+      let s = G[a.name];
+      if (s && s(a, u) || X.has(a.name))
+        return !1;
+    } else if (a.to - a.from > 8192) {
+      for (let s of I(e, a.node))
+        n.push(s);
+      return !1;
+    }
+  }), h.set(t, n), n;
+}
+const k = /^[\w$\xa1-\uffff][\w$\d\xa1-\uffff]*$/, D = [
+  "TemplateString",
+  "String",
+  "RegExp",
+  "LineComment",
+  "BlockComment",
+  "VariableDefinition",
+  "TypeDefinition",
+  "Label",
+  "PropertyDefinition",
+  "PropertyName",
+  "PrivatePropertyDefinition",
+  "PrivatePropertyName",
+  "JSXText",
+  "JSXAttributeValue",
+  "JSXOpenTag",
+  "JSXCloseTag",
+  "JSXSelfClosingTag",
+  ".",
+  "?."
+];
+function Q(e) {
+  let t = C(e.state).resolveInner(e.pos, -1);
+  if (D.indexOf(t.name) > -1)
+    return null;
+  let o = t.name == "VariableName" || t.to - t.from < 20 && k.test(e.state.sliceDoc(t.from, t.to));
+  if (!o && !e.explicit)
+    return null;
+  let n = [];
+  for (let l = t; l; l = l.parent)
+    X.has(l.name) && (n = n.concat(I(e.state.doc, l)));
+  return {
+    options: n,
+    from: o ? t.from : e.pos,
+    validFor: k
+  };
+}
+const c = /* @__PURE__ */ B.define({
+  name: "javascript",
+  parser: /* @__PURE__ */ x.configure({
+    props: [
+      /* @__PURE__ */ F.add({
+        IfStatement: /* @__PURE__ */ b({ except: /^\s*({|else\b)/ }),
+        TryStatement: /* @__PURE__ */ b({ except: /^\s*({|catch\b|finally\b)/ }),
+        LabeledStatement: N,
+        SwitchBody: (e) => {
+          let t = e.textAfter, o = /^\s*\}/.test(t), n = /^\s*(case|default)\b/.test(t);
+          return e.baseIndent + (o ? 0 : n ? 1 : 2) * e.unit;
+        },
+        Block: /* @__PURE__ */ L({ closing: "}" }),
+        ArrowFunction: (e) => e.baseIndent + e.unit,
+        "TemplateString BlockComment": () => null,
+        "Statement Property": /* @__PURE__ */ b({ except: /^\s*{/ }),
+        JSXElement(e) {
+          let t = /^\s*<\//.test(e.textAfter);
+          return e.lineIndent(e.node.from) + (t ? 0 : e.unit);
+        },
+        JSXEscape(e) {
+          let t = /\s*\}/.test(e.textAfter);
+          return e.lineIndent(e.node.from) + (t ? 0 : e.unit);
+        },
+        "JSXOpenTag JSXSelfClosingTag"(e) {
+          return e.column(e.node.from) + e.unit;
+        }
+      }),
+      /* @__PURE__ */ j.add({
+        "Block ClassBody SwitchBody EnumBody ObjectExpression ArrayExpression ObjectType": O,
+        BlockComment(e) {
+          return { from: e.from + 2, to: e.to - 2 };
+        }
+      })
+    ]
+  }),
+  languageData: {
+    closeBrackets: { brackets: ["(", "[", "{", "'", '"', "`"] },
+    commentTokens: { line: "//", block: { open: "/*", close: "*/" } },
+    indentOnInput: /^\s*(?:case |default:|\{|\}|<\/)$/,
+    wordChars: "$"
+  }
+}), v = {
+  test: (e) => /^JSX/.test(e.name),
+  facet: /* @__PURE__ */ P({ commentTokens: { block: { open: "{/*", close: "*/}" } } })
+}, U = /* @__PURE__ */ c.configure({ dialect: "ts" }, "typescript"), Y = /* @__PURE__ */ c.configure({
+  dialect: "jsx",
+  props: [/* @__PURE__ */ T.add((e) => e.isTop ? [v] : void 0)]
+}), Z = /* @__PURE__ */ c.configure({
+  dialect: "jsx ts",
+  props: [/* @__PURE__ */ T.add((e) => e.isTop ? [v] : void 0)]
+}, "typescript");
+let A = (e) => ({ label: e, type: "keyword" });
+const E = /* @__PURE__ */ "break case const continue default delete export extends false finally in instanceof let new return static super switch this throw true typeof var yield".split(" ").map(A), ee = /* @__PURE__ */ E.concat(/* @__PURE__ */ ["declare", "implements", "private", "protected", "public"].map(A));
+function ce(e = {}) {
+  let t = e.jsx ? e.typescript ? Z : Y : e.typescript ? U : c, o = e.typescript ? q.concat(ee) : J.concat(E);
+  return new V(t, [
+    c.data.of({
+      autocomplete: R(D, W(o))
+    }),
+    c.data.of({
+      autocomplete: Q
+    }),
+    e.jsx ? ae : []
+  ]);
+}
+function te(e) {
+  for (; ; ) {
+    if (e.name == "JSXOpenTag" || e.name == "JSXSelfClosingTag" || e.name == "JSXFragmentTag")
+      return e;
+    if (e.name == "JSXEscape" || !e.parent)
+      return null;
+    e = e.parent;
+  }
+}
+function w(e, t, o = e.length) {
+  for (let n = t?.firstChild; n; n = n.nextSibling)
+    if (n.name == "JSXIdentifier" || n.name == "JSXBuiltin" || n.name == "JSXNamespacedName" || n.name == "JSXMemberExpression")
+      return e.sliceString(n.from, Math.min(n.to, o));
+  return "";
+}
+const ne = typeof navigator == "object" && /* @__PURE__ */ /Android\b/.test(navigator.userAgent), ae = /* @__PURE__ */ _.inputHandler.of((e, t, o, n, l) => {
+  if ((ne ? e.composing : e.compositionStarted) || e.state.readOnly || t != o || n != ">" && n != "/" || !c.isActiveAt(e.state, t, -1))
+    return !1;
+  let u = l(), { state: a } = u, s = a.changeByRange((f) => {
+    var g;
+    let { head: i } = f, p = C(a).resolveInner(i - 1, -1), y;
+    if (p.name == "JSXStartTag" && (p = p.parent), !(a.doc.sliceString(i - 1, i) != n || p.name == "JSXAttributeValue" && p.to > i)) {
+      if (n == ">" && p.name == "JSXFragmentTag")
+        return { range: f, changes: { from: i, insert: "</>" } };
+      if (n == "/" && p.name == "JSXStartCloseTag") {
+        let m = p.parent, S = m.parent;
+        if (S && m.from == i - 2 && ((y = w(a.doc, S.firstChild, i)) || ((g = S.firstChild) === null || g === void 0 ? void 0 : g.name) == "JSXFragmentTag")) {
+          let $ = `${y}>`;
+          return { range: M.cursor(i + $.length, -1), changes: { from: i, insert: $ } };
+        }
+      } else if (n == ">") {
+        let m = te(p);
+        if (m && m.name == "JSXOpenTag" && !/^\/?>|^<\//.test(a.doc.sliceString(i, i + 2)) && (y = w(a.doc, m, i)))
+          return { range: f, changes: { from: i, insert: `</${y}>` } };
+      }
+    }
+    return { range: f };
+  });
+  return s.changes.empty ? !1 : (e.dispatch([
+    u,
+    a.update(s, { userEvent: "input.complete", scrollIntoView: !0 })
+  ]), !0);
+});
+export {
+  ae as autoCloseTags,
+  ce as javascript,
+  c as javascriptLanguage,
+  Y as jsxLanguage,
+  Q as localCompletionSource,
+  J as snippets,
+  Z as tsxLanguage,
+  U as typescriptLanguage,
+  q as typescriptSnippets
+};

package/dist/node_modules/.pnpm/@codemirror_lang-json@6.0.2/node_modules/@codemirror/lang-json/dist/index.js

@@ -0,0 +1,27 @@
+import { parser as n } from "../../../../../@lezer_json@1.0.3/node_modules/@lezer/json/dist/index.js";
+import { LanguageSupport as r, LRLanguage as o, indentNodeProp as a, foldNodeProp as t, continuedIndent as e, foldInside as d } from "../../../../../@codemirror_language@6.11.3/node_modules/@codemirror/language/dist/index.js";
+const p = /* @__PURE__ */ o.define({
+  name: "json",
+  parser: /* @__PURE__ */ n.configure({
+    props: [
+      /* @__PURE__ */ a.add({
+        Object: /* @__PURE__ */ e({ except: /^\s*\}/ }),
+        Array: /* @__PURE__ */ e({ except: /^\s*\]/ })
+      }),
+      /* @__PURE__ */ t.add({
+        "Object Array": d
+      })
+    ]
+  }),
+  languageData: {
+    closeBrackets: { brackets: ["[", "{", '"'] },
+    indentOnInput: /^\s*[\}\]]$/
+  }
+});
+function u() {
+  return new r(p);
+}
+export {
+  u as json,
+  p as jsonLanguage
+};

package/dist/node_modules/.pnpm/@codemirror_lang-xml@6.1.0/node_modules/@codemirror/lang-xml/dist/index.js

@@ -0,0 +1,216 @@
+import { parser as I } from "../../../../../@lezer_xml@1.0.6/node_modules/@lezer/xml/dist/index.js";
+import { LRLanguage as F, LanguageSupport as L, indentNodeProp as _, foldNodeProp as w, bracketMatchingHandle as x, syntaxTree as $ } from "../../../../../@codemirror_language@6.11.3/node_modules/@codemirror/language/dist/index.js";
+import { EditorSelection as M } from "../../../../../@codemirror_state@6.5.2/node_modules/@codemirror/state/dist/index.js";
+import { EditorView as k } from "../../../../../@codemirror_view@6.38.6/node_modules/@codemirror/view/dist/index.js";
+function v(e, t) {
+  let i = t && t.getChild("TagName");
+  return i ? e.sliceString(i.from, i.to) : "";
+}
+function O(e, t) {
+  let i = t && t.firstChild;
+  return !i || i.name != "OpenTag" ? "" : v(e, i);
+}
+function D(e, t, i) {
+  let n = t && t.getChildren("Attribute").find((o) => o.from <= i && o.to >= i), a = n && n.getChild("AttributeName");
+  return a ? e.sliceString(a.from, a.to) : "";
+}
+function N(e) {
+  for (let t = e && e.parent; t; t = t.parent)
+    if (t.name == "Element")
+      return t;
+  return null;
+}
+function P(e, t) {
+  var i;
+  let n = $(e).resolveInner(t, -1), a = null;
+  for (let o = n; !a && o.parent; o = o.parent)
+    (o.name == "OpenTag" || o.name == "CloseTag" || o.name == "SelfClosingTag" || o.name == "MismatchedCloseTag") && (a = o);
+  if (a && (a.to > t || a.lastChild.type.isError)) {
+    let o = a.parent;
+    if (n.name == "TagName")
+      return a.name == "CloseTag" || a.name == "MismatchedCloseTag" ? { type: "closeTag", from: n.from, context: o } : { type: "openTag", from: n.from, context: N(o) };
+    if (n.name == "AttributeName")
+      return { type: "attrName", from: n.from, context: a };
+    if (n.name == "AttributeValue")
+      return { type: "attrValue", from: n.from, context: a };
+    let s = n == a || n.name == "Attribute" ? n.childBefore(t) : n;
+    return s?.name == "StartTag" ? { type: "openTag", from: t, context: N(o) } : s?.name == "StartCloseTag" && s.to <= t ? { type: "closeTag", from: t, context: o } : s?.name == "Is" ? { type: "attrValue", from: t, context: a } : s ? { type: "attrName", from: t, context: a } : null;
+  } else if (n.name == "StartCloseTag")
+    return { type: "closeTag", from: t, context: n.parent };
+  for (; n.parent && n.to == t && !(!((i = n.lastChild) === null || i === void 0) && i.type.isError); )
+    n = n.parent;
+  return n.name == "Element" || n.name == "Text" || n.name == "Document" ? { type: "tag", from: t, context: n.name == "Element" ? n : N(n) } : null;
+}
+class B {
+  constructor(t, i, n) {
+    this.attrs = i, this.attrValues = n, this.children = [], this.name = t.name, this.completion = Object.assign(Object.assign({ type: "type" }, t.completion || {}), { label: this.name }), this.openCompletion = Object.assign(Object.assign({}, this.completion), { label: "<" + this.name }), this.closeCompletion = Object.assign(Object.assign({}, this.completion), { label: "</" + this.name + ">", boost: 2 }), this.closeNameCompletion = Object.assign(Object.assign({}, this.completion), { label: this.name + ">" }), this.text = t.textContent ? t.textContent.map((a) => ({ label: a, type: "text" })) : [];
+  }
+}
+const S = /^[:\-\.\w\u00b7-\uffff]*$/;
+function E(e) {
+  return Object.assign(Object.assign({ type: "property" }, e.completion || {}), { label: e.name });
+}
+function A(e) {
+  return typeof e == "string" ? { label: `"${e}"`, type: "constant" } : /^"/.test(e.label) ? e : Object.assign(Object.assign({}, e), { label: `"${e.label}"` });
+}
+function H(e, t) {
+  let i = [], n = [], a = /* @__PURE__ */ Object.create(null);
+  for (let l of t) {
+    let p = E(l);
+    i.push(p), l.global && n.push(p), l.values && (a[l.name] = l.values.map(A));
+  }
+  let o = [], s = [], h = /* @__PURE__ */ Object.create(null);
+  for (let l of e) {
+    let p = n, u = a;
+    l.attributes && (p = p.concat(l.attributes.map((r) => typeof r == "string" ? i.find((b) => b.label == r) || { label: r, type: "property" } : (r.values && (u == a && (u = Object.create(u)), u[r.name] = r.values.map(A)), E(r)))));
+    let d = new B(l, p, u);
+    h[d.name] = d, o.push(d), l.top && s.push(d);
+  }
+  s.length || (s = o);
+  for (let l = 0; l < o.length; l++) {
+    let p = e[l], u = o[l];
+    if (p.children)
+      for (let d of p.children)
+        h[d] && u.children.push(h[d]);
+    else
+      u.children = o;
+  }
+  return (l) => {
+    var p;
+    let { doc: u } = l.state, d = P(l.state, l.pos);
+    if (!d || d.type == "tag" && !l.explicit)
+      return null;
+    let { type: r, from: b, context: c } = d;
+    if (r == "openTag") {
+      let m = s, f = O(u, c);
+      if (f) {
+        let g = h[f];
+        m = g?.children || o;
+      }
+      return {
+        from: b,
+        options: m.map((g) => g.completion),
+        validFor: S
+      };
+    } else if (r == "closeTag") {
+      let m = O(u, c);
+      return m ? {
+        from: b,
+        to: l.pos + (u.sliceString(l.pos, l.pos + 1) == ">" ? 1 : 0),
+        options: [((p = h[m]) === null || p === void 0 ? void 0 : p.closeNameCompletion) || { label: m + ">", type: "type" }],
+        validFor: S
+      } : null;
+    } else if (r == "attrName") {
+      let m = h[v(u, c)];
+      return {
+        from: b,
+        options: m?.attrs || n,
+        validFor: S
+      };
+    } else if (r == "attrValue") {
+      let m = D(u, c, b);
+      if (!m)
+        return null;
+      let f = h[v(u, c)], g = (f?.attrValues || a)[m];
+      return !g || !g.length ? null : {
+        from: b,
+        to: l.pos + (u.sliceString(l.pos, l.pos + 1) == '"' ? 1 : 0),
+        options: g,
+        validFor: /^"[^"]*"?$/
+      };
+    } else if (r == "tag") {
+      let m = O(u, c), f = h[m], g = [], C = c && c.lastChild;
+      m && (!C || C.name != "CloseTag" || v(u, C) != m) && g.push(f ? f.closeCompletion : { label: "</" + m + ">", type: "type", boost: 2 });
+      let y = g.concat((f?.children || (c ? o : s)).map((T) => T.openCompletion));
+      if (c && f?.text.length) {
+        let T = c.firstChild;
+        T.to > l.pos - 20 && !/\S/.test(l.state.sliceDoc(T.to, l.pos)) && (y = y.concat(f.text));
+      }
+      return {
+        from: b,
+        options: y,
+        validFor: /^<\/?[:\-\.\w\u00b7-\uffff]*$/
+      };
+    } else
+      return null;
+  };
+}
+const j = /* @__PURE__ */ F.define({
+  name: "xml",
+  parser: /* @__PURE__ */ I.configure({
+    props: [
+      /* @__PURE__ */ _.add({
+        Element(e) {
+          let t = /^\s*<\//.test(e.textAfter);
+          return e.lineIndent(e.node.from) + (t ? 0 : e.unit);
+        },
+        "OpenTag CloseTag SelfClosingTag"(e) {
+          return e.column(e.node.from) + e.unit;
+        }
+      }),
+      /* @__PURE__ */ w.add({
+        Element(e) {
+          let t = e.firstChild, i = e.lastChild;
+          return !t || t.name != "OpenTag" ? null : { from: t.to, to: i.name == "CloseTag" ? i.from : e.to };
+        }
+      }),
+      /* @__PURE__ */ x.add({
+        "OpenTag CloseTag": (e) => e.getChild("TagName")
+      })
+    ]
+  }),
+  languageData: {
+    commentTokens: { block: { open: "<!--", close: "-->" } },
+    indentOnInput: /^\s*<\/$/
+  }
+});
+function K(e = {}) {
+  let t = [j.data.of({
+    autocomplete: H(e.elements || [], e.attributes || [])
+  })];
+  return e.autoCloseTags !== !1 && t.push(R), new L(j, t);
+}
+function V(e, t, i = e.length) {
+  if (!t)
+    return "";
+  let n = t.firstChild, a = n && n.getChild("TagName");
+  return a ? e.sliceString(a.from, Math.min(a.to, i)) : "";
+}
+const R = /* @__PURE__ */ k.inputHandler.of((e, t, i, n, a) => {
+  if (e.composing || e.state.readOnly || t != i || n != ">" && n != "/" || !j.isActiveAt(e.state, t, -1))
+    return !1;
+  let o = a(), { state: s } = o, h = s.changeByRange((l) => {
+    var p, u, d;
+    let { head: r } = l, b = s.doc.sliceString(r - 1, r) == n, c = $(s).resolveInner(r, -1), m;
+    if (b && n == ">" && c.name == "EndTag") {
+      let f = c.parent;
+      if (((u = (p = f.parent) === null || p === void 0 ? void 0 : p.lastChild) === null || u === void 0 ? void 0 : u.name) != "CloseTag" && (m = V(s.doc, f.parent, r))) {
+        let g = r + (s.doc.sliceString(r, r + 1) === ">" ? 1 : 0), C = `</${m}>`;
+        return { range: l, changes: { from: r, to: g, insert: C } };
+      }
+    } else if (b && n == "/" && c.name == "StartCloseTag") {
+      let f = c.parent;
+      if (c.from == r - 2 && ((d = f.lastChild) === null || d === void 0 ? void 0 : d.name) != "CloseTag" && (m = V(s.doc, f, r))) {
+        let g = r + (s.doc.sliceString(r, r + 1) === ">" ? 1 : 0), C = `${m}>`;
+        return {
+          range: M.cursor(r + C.length, -1),
+          changes: { from: r, to: g, insert: C }
+        };
+      }
+    }
+    return { range: l };
+  });
+  return h.changes.empty ? !1 : (e.dispatch([
+    o,
+    s.update(h, {
+      userEvent: "input.complete",
+      scrollIntoView: !0
+    })
+  ]), !0);
+});
+export {
+  R as autoCloseTags,
+  H as completeFromSchema,
+  K as xml,
+  j as xmlLanguage
+};

package/dist/node_modules/.pnpm/@codemirror_lang-yaml@6.1.2/node_modules/@codemirror/lang-yaml/dist/index.js

@@ -0,0 +1,48 @@
+import { parser as t } from "../../../../../@lezer_yaml@1.0.3/node_modules/@lezer/yaml/dist/index.js";
+import { LanguageSupport as l, LRLanguage as a, indentNodeProp as i, foldNodeProp as m, delimitedIndent as r, foldInside as u } from "../../../../../@codemirror_language@6.11.3/node_modules/@codemirror/language/dist/index.js";
+const f = /* @__PURE__ */ a.define({
+  name: "yaml",
+  parser: /* @__PURE__ */ t.configure({
+    props: [
+      /* @__PURE__ */ i.add({
+        Stream: (n) => {
+          for (let e = n.node.resolve(n.pos, -1); e && e.to >= n.pos; e = e.parent) {
+            if (e.name == "BlockLiteralContent" && e.from < e.to)
+              return n.baseIndentFor(e);
+            if (e.name == "BlockLiteral")
+              return n.baseIndentFor(e) + n.unit;
+            if (e.name == "BlockSequence" || e.name == "BlockMapping")
+              return n.column(e.from, 1);
+            if (e.name == "QuotedLiteral")
+              return null;
+            if (e.name == "Literal") {
+              let o = n.column(e.from, 1);
+              if (o == n.lineIndent(e.from, 1))
+                return o;
+              if (e.to > n.pos)
+                return null;
+            }
+          }
+          return null;
+        },
+        FlowMapping: /* @__PURE__ */ r({ closing: "}" }),
+        FlowSequence: /* @__PURE__ */ r({ closing: "]" })
+      }),
+      /* @__PURE__ */ m.add({
+        "FlowMapping FlowSequence": u,
+        "Item Pair BlockLiteral": (n, e) => ({ from: e.doc.lineAt(n.from).to, to: n.to })
+      })
+    ]
+  }),
+  languageData: {
+    commentTokens: { line: "#" },
+    indentOnInput: /^\s*[\]\}]$/
+  }
+});
+function s() {
+  return new l(f);
+}
+export {
+  s as yaml,
+  f as yamlLanguage
+};