@gsc-basic/components 1.0.1

package/dist/es/node_modules/@codemirror/lang-python/dist/index.js

@@ -0,0 +1,399 @@
+import { parser as h } from "../../../@lezer/python/dist/index.js";
+import { LanguageSupport as S, LRLanguage as I, indentNodeProp as v, foldNodeProp as C, delimitedIndent as m, foldInside as k, syntaxTree as $ } from "../../language/dist/index.js";
+import { NodeWeakMap as A, IterMode as F } from "../../../@lezer/common/dist/index.js";
+import { ifNotIn as w, completeFromList as N, snippetCompletion as l } from "../../autocomplete/dist/index.js";
+const c = /* @__PURE__ */ new A(), E = /* @__PURE__ */ new Set([
+  "Script",
+  "Body",
+  "FunctionDefinition",
+  "ClassDefinition",
+  "LambdaExpression",
+  "ForStatement",
+  "MatchClause"
+]);
+function p(e) {
+  return (r, t, n) => {
+    if (n)
+      return !1;
+    let o = r.node.getChild("VariableName");
+    return o && t(o, e), !0;
+  };
+}
+const B = {
+  FunctionDefinition: /* @__PURE__ */ p("function"),
+  ClassDefinition: /* @__PURE__ */ p("class"),
+  ForStatement(e, r, t) {
+    if (t) {
+      for (let n = e.node.firstChild; n; n = n.nextSibling)
+        if (n.name == "VariableName")
+          r(n, "variable");
+        else if (n.name == "in")
+          break;
+    }
+  },
+  ImportStatement(e, r) {
+    var t, n;
+    let { node: o } = e, a = ((t = o.firstChild) === null || t === void 0 ? void 0 : t.name) == "from";
+    for (let i = o.getChild("import"); i; i = i.nextSibling)
+      i.name == "VariableName" && ((n = i.nextSibling) === null || n === void 0 ? void 0 : n.name) != "as" && r(i, a ? "variable" : "namespace");
+  },
+  AssignStatement(e, r) {
+    for (let t = e.node.firstChild; t; t = t.nextSibling)
+      if (t.name == "VariableName")
+        r(t, "variable");
+      else if (t.name == ":" || t.name == "AssignOp")
+        break;
+  },
+  ParamList(e, r) {
+    for (let t = null, n = e.node.firstChild; n; n = n.nextSibling)
+      n.name == "VariableName" && (!t || !/\*|AssignOp/.test(t.name)) && r(n, "variable"), t = n;
+  },
+  CapturePattern: /* @__PURE__ */ p("variable"),
+  AsPattern: /* @__PURE__ */ p("variable"),
+  __proto__: null
+};
+function y(e, r) {
+  let t = c.get(r);
+  if (t)
+    return t;
+  let n = [], o = !0;
+  function a(i, s) {
+    let _ = e.sliceString(i.from, i.to);
+    n.push({ label: _, type: s });
+  }
+  return r.cursor(F.IncludeAnonymous).iterate((i) => {
+    if (i.name) {
+      let s = B[i.name];
+      if (s && s(i, a, o) || !o && E.has(i.name))
+        return !1;
+      o = !1;
+    } else if (i.to - i.from > 8192) {
+      for (let s of y(e, i.node))
+        n.push(s);
+      return !1;
+    }
+  }), c.set(r, n), n;
+}
+const b = /^[\w\xa1-\uffff][\w\d\xa1-\uffff]*$/, g = ["String", "FormatString", "Comment", "PropertyName"];
+function x(e) {
+  let r = $(e.state).resolveInner(e.pos, -1);
+  if (g.indexOf(r.name) > -1)
+    return null;
+  let t = r.name == "VariableName" || r.to - r.from < 20 && b.test(e.state.sliceDoc(r.from, r.to));
+  if (!t && !e.explicit)
+    return null;
+  let n = [];
+  for (let o = r; o; o = o.parent)
+    E.has(o.name) && (n = n.concat(y(e.state.doc, o)));
+  return {
+    options: n,
+    from: t ? r.from : e.pos,
+    validFor: b
+  };
+}
+const D = /* @__PURE__ */ [
+  "__annotations__",
+  "__builtins__",
+  "__debug__",
+  "__doc__",
+  "__import__",
+  "__name__",
+  "__loader__",
+  "__package__",
+  "__spec__",
+  "False",
+  "None",
+  "True"
+].map((e) => ({ label: e, type: "constant" })).concat(/* @__PURE__ */ [
+  "ArithmeticError",
+  "AssertionError",
+  "AttributeError",
+  "BaseException",
+  "BlockingIOError",
+  "BrokenPipeError",
+  "BufferError",
+  "BytesWarning",
+  "ChildProcessError",
+  "ConnectionAbortedError",
+  "ConnectionError",
+  "ConnectionRefusedError",
+  "ConnectionResetError",
+  "DeprecationWarning",
+  "EOFError",
+  "Ellipsis",
+  "EncodingWarning",
+  "EnvironmentError",
+  "Exception",
+  "FileExistsError",
+  "FileNotFoundError",
+  "FloatingPointError",
+  "FutureWarning",
+  "GeneratorExit",
+  "IOError",
+  "ImportError",
+  "ImportWarning",
+  "IndentationError",
+  "IndexError",
+  "InterruptedError",
+  "IsADirectoryError",
+  "KeyError",
+  "KeyboardInterrupt",
+  "LookupError",
+  "MemoryError",
+  "ModuleNotFoundError",
+  "NameError",
+  "NotADirectoryError",
+  "NotImplemented",
+  "NotImplementedError",
+  "OSError",
+  "OverflowError",
+  "PendingDeprecationWarning",
+  "PermissionError",
+  "ProcessLookupError",
+  "RecursionError",
+  "ReferenceError",
+  "ResourceWarning",
+  "RuntimeError",
+  "RuntimeWarning",
+  "StopAsyncIteration",
+  "StopIteration",
+  "SyntaxError",
+  "SyntaxWarning",
+  "SystemError",
+  "SystemExit",
+  "TabError",
+  "TimeoutError",
+  "TypeError",
+  "UnboundLocalError",
+  "UnicodeDecodeError",
+  "UnicodeEncodeError",
+  "UnicodeError",
+  "UnicodeTranslateError",
+  "UnicodeWarning",
+  "UserWarning",
+  "ValueError",
+  "Warning",
+  "ZeroDivisionError"
+].map((e) => ({ label: e, type: "type" }))).concat(/* @__PURE__ */ [
+  "bool",
+  "bytearray",
+  "bytes",
+  "classmethod",
+  "complex",
+  "float",
+  "frozenset",
+  "int",
+  "list",
+  "map",
+  "memoryview",
+  "object",
+  "range",
+  "set",
+  "staticmethod",
+  "str",
+  "super",
+  "tuple",
+  "type"
+].map((e) => ({ label: e, type: "class" }))).concat(/* @__PURE__ */ [
+  "abs",
+  "aiter",
+  "all",
+  "anext",
+  "any",
+  "ascii",
+  "bin",
+  "breakpoint",
+  "callable",
+  "chr",
+  "compile",
+  "delattr",
+  "dict",
+  "dir",
+  "divmod",
+  "enumerate",
+  "eval",
+  "exec",
+  "exit",
+  "filter",
+  "format",
+  "getattr",
+  "globals",
+  "hasattr",
+  "hash",
+  "help",
+  "hex",
+  "id",
+  "input",
+  "isinstance",
+  "issubclass",
+  "iter",
+  "len",
+  "license",
+  "locals",
+  "max",
+  "min",
+  "next",
+  "oct",
+  "open",
+  "ord",
+  "pow",
+  "print",
+  "property",
+  "quit",
+  "repr",
+  "reversed",
+  "round",
+  "setattr",
+  "slice",
+  "sorted",
+  "sum",
+  "vars",
+  "zip"
+].map((e) => ({ label: e, type: "function" }))), P = [
+  /* @__PURE__ */ l("def ${name}(${params}):\n	${}", {
+    label: "def",
+    detail: "function",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("for ${name} in ${collection}:\n	${}", {
+    label: "for",
+    detail: "loop",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("while ${}:\n	${}", {
+    label: "while",
+    detail: "loop",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("try:\n	${}\nexcept ${error}:\n	${}", {
+    label: "try",
+    detail: "/ except block",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l(`if \${}:
+	
+`, {
+    label: "if",
+    detail: "block",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("if ${}:\n	${}\nelse:\n	${}", {
+    label: "if",
+    detail: "/ else block",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("class ${name}:\n	def __init__(self, ${params}):\n			${}", {
+    label: "class",
+    detail: "definition",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("import ${module}", {
+    label: "import",
+    detail: "statement",
+    type: "keyword"
+  }),
+  /* @__PURE__ */ l("from ${module} import ${names}", {
+    label: "from",
+    detail: "import",
+    type: "keyword"
+  })
+], W = /* @__PURE__ */ w(g, /* @__PURE__ */ N(/* @__PURE__ */ D.concat(P)));
+function d(e) {
+  let { node: r, pos: t } = e, n = e.lineIndent(t, -1), o = null;
+  for (; ; ) {
+    let a = r.childBefore(t);
+    if (a)
+      if (a.name == "Comment")
+        t = a.from;
+      else if (a.name == "Body" || a.name == "MatchBody")
+        e.baseIndentFor(a) + e.unit <= n && (o = a), r = a;
+      else if (a.name == "MatchClause")
+        r = a;
+      else if (a.type.is("Statement"))
+        r = a;
+      else
+        break;
+    else break;
+  }
+  return o;
+}
+function f(e, r) {
+  let t = e.baseIndentFor(r), n = e.lineAt(e.pos, -1), o = n.from + n.text.length;
+  return /^\s*($|#)/.test(n.text) && e.node.to < o + 100 && !/\S/.test(e.state.sliceDoc(o, e.node.to)) && e.lineIndent(e.pos, -1) <= t || /^\s*(else:|elif |except |finally:|case\s+[^=:]+:)/.test(e.textAfter) && e.lineIndent(e.pos, -1) > t ? null : t + e.unit;
+}
+const u = /* @__PURE__ */ I.define({
+  name: "python",
+  parser: /* @__PURE__ */ h.configure({
+    props: [
+      /* @__PURE__ */ v.add({
+        Body: (e) => {
+          var r;
+          let t = /^\s*(#|$)/.test(e.textAfter) && d(e) || e.node;
+          return (r = f(e, t)) !== null && r !== void 0 ? r : e.continue();
+        },
+        MatchBody: (e) => {
+          var r;
+          let t = d(e);
+          return (r = f(e, t || e.node)) !== null && r !== void 0 ? r : e.continue();
+        },
+        IfStatement: (e) => /^\s*(else:|elif )/.test(e.textAfter) ? e.baseIndent : e.continue(),
+        "ForStatement WhileStatement": (e) => /^\s*else:/.test(e.textAfter) ? e.baseIndent : e.continue(),
+        TryStatement: (e) => /^\s*(except[ :]|finally:|else:)/.test(e.textAfter) ? e.baseIndent : e.continue(),
+        MatchStatement: (e) => /^\s*case /.test(e.textAfter) ? e.baseIndent + e.unit : e.continue(),
+        "TupleExpression ComprehensionExpression ParamList ArgList ParenthesizedExpression": /* @__PURE__ */ m({ closing: ")" }),
+        "DictionaryExpression DictionaryComprehensionExpression SetExpression SetComprehensionExpression": /* @__PURE__ */ m({ closing: "}" }),
+        "ArrayExpression ArrayComprehensionExpression": /* @__PURE__ */ m({ closing: "]" }),
+        MemberExpression: (e) => e.baseIndent + e.unit,
+        "String FormatString": () => null,
+        Script: (e) => {
+          var r;
+          let t = d(e);
+          return (r = t && f(e, t)) !== null && r !== void 0 ? r : e.continue();
+        }
+      }),
+      /* @__PURE__ */ C.add({
+        "ArrayExpression DictionaryExpression SetExpression TupleExpression": k,
+        Body: (e, r) => ({ from: e.from + 1, to: e.to - (e.to == r.doc.length ? 0 : 1) }),
+        "String FormatString": (e, r) => ({ from: r.doc.lineAt(e.from).to, to: e.to })
+      })
+    ]
+  }),
+  languageData: {
+    closeBrackets: {
+      brackets: ["(", "[", "{", "'", '"', "'''", '"""'],
+      stringPrefixes: [
+        "f",
+        "fr",
+        "rf",
+        "r",
+        "u",
+        "b",
+        "br",
+        "rb",
+        "F",
+        "FR",
+        "RF",
+        "R",
+        "U",
+        "B",
+        "BR",
+        "RB"
+      ]
+    },
+    commentTokens: { line: "#" },
+    // Indent logic logic are triggered upon below input patterns
+    indentOnInput: /^\s*([\}\]\)]|else:|elif |except |finally:|case\s+[^:]*:?)$/
+  }
+});
+function O() {
+  return new S(u, [
+    u.data.of({ autocomplete: x }),
+    u.data.of({ autocomplete: W })
+  ]);
+}
+export {
+  W as globalCompletion,
+  x as localCompletionSource,
+  O as python,
+  u as pythonLanguage
+};