groove-dev 0.15.0 → 0.16.0

package/node_modules/@codemirror/lang-python/CHANGELOG.md

@@ -0,0 +1,174 @@
+## 6.2.1 (2025-05-14)
+
+### Bug fixes
+
+Fix an issue where the indentation logic would too eagerly align lines to the body directly above them.
+
+## 6.2.0 (2025-04-25)
+
+### Bug fixes
+
+Add an indentation rule for member expressions.
+
+### New features
+
+Allow multi-line strings to be code-folded.
+
+## 6.1.7 (2025-01-18)
+
+### Bug fixes
+
+Properly indent match/case statements.
+
+## 6.1.6 (2024-04-29)
+
+### Bug fixes
+
+Improve the way indentation for the current body is preserved when inenting new lines.
+
+## 6.1.5 (2024-03-28)
+
+### Bug fixes
+
+Properly indent `else:` when attached to a `for` or `while` statement.
+
+## 6.1.4 (2024-02-02)
+
+### Bug fixes
+
+Explicitly declare dependencies on @lezer/common and @codemirror/state
+
+## 6.1.3 (2023-06-12)
+
+### Bug fixes
+
+Fix a bug where blocks started after a wrapped argument list or similar construct were indented too far.
+
+## 6.1.2 (2023-03-01)
+
+### Bug fixes
+
+Don't indent lines after a dedented comment line.
+
+## 6.1.1 (2022-12-24)
+
+### Bug fixes
+
+Remove leftover log statements.
+
+## 6.1.0 (2022-11-18)
+
+### New features
+
+The `globalCompletion` completion source (included in the language support returned from `python()`) completes standard Python globals and keywords.
+
+Export a `localCompletionSource` function that completes locally defined variables. Included in the support extensions returned from `python()`.
+
+## 6.0.4 (2022-10-24)
+
+### Bug fixes
+
+Make sure the language object has a name.
+
+## 6.0.3 (2022-10-19)
+
+### Bug fixes
+
+Add proper indentation handling of `else` clauses in `try` statements.
+
+## 6.0.2 (2022-09-22)
+
+### Bug fixes
+
+Allow prefixed strings to be closed by `closeBrackets`.
+
+## 6.0.1 (2022-07-21)
+
+### Bug fixes
+
+Fix (non-)auto indentation in template strings and comments.
+
+## 6.0.0 (2022-06-08)
+
+### Breaking changes
+
+Update dependencies to 6.0.0
+
+## 0.20.0 (2022-04-20)
+
+### Bug fixes
+
+Add folding information for set and tuple expressions.
+
+## 0.19.5 (2022-04-06)
+
+### Bug fixes
+
+Make sure * and ** modifiers are highlighted as such, add modifier tag for FormatSpec nodes.
+
+## 0.19.4 (2022-01-26)
+
+### Bug fixes
+
+Fix issue where folding body nodes folded away the newline after the body.
+
+## 0.19.3 (2022-01-20)
+
+### Bug fixes
+
+Fix the way block bodies are folded.
+
+## 0.19.2 (2021-08-11)
+
+### Bug fixes
+
+Make sure that indenting an else/elif/except/finally that's indented too deep moves it back up.
+
+## 0.19.1 (2021-08-11)
+
+### Bug fixes
+
+Fix incorrect versions for @lezer dependencies.
+
+## 0.19.0 (2021-08-11)
+
+### Bug fixes
+
+Improve indentation for dictionaries, arrays, and tuples. Fix delimitedIndent calls
+
+Indentation on deindented blank lines after a block will no longer return to the block's indentation level.
+
+## 0.18.1 (2021-07-20)
+
+### Bug fixes
+
+Fix highlighting of property names. Improve indentation support
+
+Don't deindent when pressing enter at the end of the document.
+
+Properly indent else/elif/except syntax.
+
+## 0.18.0 (2021-03-03)
+
+### Breaking changes
+
+Update dependencies to 0.18.
+
+## 0.17.2 (2021-01-12)
+
+### Bug fixes
+
+Improves the highlighting specificity for names of function and class definitions.
+
+## 0.17.1 (2021-01-06)
+
+### New features
+
+The package now also exports a CommonJS module.
+
+## 0.17.0 (2020-12-29)
+
+### Breaking changes
+
+First numbered release.
+

package/node_modules/@codemirror/lang-python/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2018-2021 by Marijn Haverbeke <marijn@haverbeke.berlin> and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/node_modules/@codemirror/lang-python/README.md

@@ -0,0 +1,61 @@
+<!-- NOTE: README.md is generated from src/README.md -->
+
+# @codemirror/lang-python [![NPM version](https://img.shields.io/npm/v/@codemirror/lang-python.svg)](https://www.npmjs.org/package/@codemirror/lang-python)
+
+[ [**WEBSITE**](https://codemirror.net/) | [**ISSUES**](https://github.com/codemirror/dev/issues) | [**FORUM**](https://discuss.codemirror.net/c/next/) | [**CHANGELOG**](https://github.com/codemirror/lang-python/blob/main/CHANGELOG.md) ]
+
+This package implements Python language support for the
+[CodeMirror](https://codemirror.net/) code editor.
+
+The [project page](https://codemirror.net/) has more information, a
+number of [examples](https://codemirror.net/examples/) and the
+[documentation](https://codemirror.net/docs/).
+
+This code is released under an
+[MIT license](https://github.com/codemirror/lang-python/tree/main/LICENSE).
+
+We aim to be an inclusive, welcoming community. To make that explicit,
+we have a [code of
+conduct](http://contributor-covenant.org/version/1/1/0/) that applies
+to communication around the project.
+
+## Usage
+
+```javascript
+import {EditorView, basicSetup} from "codemirror"
+import {python} from "@codemirror/lang-python"
+
+const view = new EditorView({
+  parent: document.body,
+  doc: `print("Hello world")`,
+  extensions: [basicSetup, python()]
+})
+```
+
+# API Reference
+
+<dl>
+<dt id="user-content-python">
+  <code><strong><a href="#user-content-python">python</a></strong>() → <a href="https://codemirror.net/docs/ref#language.LanguageSupport">LanguageSupport</a></code></dt>
+
+<dd><p>Python language support.</p>
+</dd>
+<dt id="user-content-pythonlanguage">
+  <code><strong><a href="#user-content-pythonlanguage">pythonLanguage</a></strong>: <a href="https://codemirror.net/docs/ref#language.LRLanguage">LRLanguage</a></code></dt>
+
+<dd><p>A language provider based on the <a href="https://github.com/lezer-parser/python">Lezer Python
+parser</a>, extended with
+highlighting and indentation information.</p>
+</dd>
+<dt id="user-content-globalcompletion">
+  <code><strong><a href="#user-content-globalcompletion">globalCompletion</a></strong>: <a href="https://codemirror.net/docs/ref#autocomplete.CompletionSource">CompletionSource</a></code></dt>
+
+<dd><p>Autocompletion for built-in Python globals and keywords.</p>
+</dd>
+<dt id="user-content-localcompletionsource">
+  <code><strong><a href="#user-content-localcompletionsource">localCompletionSource</a></strong>(<a id="user-content-localcompletionsource^context" href="#user-content-localcompletionsource^context">context</a>: <a href="https://codemirror.net/docs/ref#autocomplete.CompletionContext">CompletionContext</a>) → <a href="https://codemirror.net/docs/ref#autocomplete.CompletionResult">CompletionResult</a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code></dt>
+
+<dd><p>Completion source that looks up locally defined names in
+Python code.</p>
+</dd>
+</dl>

package/node_modules/@codemirror/lang-python/dist/index.cjs

@@ -0,0 +1,313 @@
+'use strict';
+
+var python$1 = require('@lezer/python');
+var language = require('@codemirror/language');
+var common = require('@lezer/common');
+var autocomplete = require('@codemirror/autocomplete');
+
+const cache = new common.NodeWeakMap();
+const ScopeNodes = new Set([
+    "Script", "Body",
+    "FunctionDefinition", "ClassDefinition", "LambdaExpression",
+    "ForStatement", "MatchClause"
+]);
+function defID(type) {
+    return (node, def, outer) => {
+        if (outer)
+            return false;
+        let id = node.node.getChild("VariableName");
+        if (id)
+            def(id, type);
+        return true;
+    };
+}
+const gatherCompletions = {
+    FunctionDefinition: defID("function"),
+    ClassDefinition: defID("class"),
+    ForStatement(node, def, outer) {
+        if (outer)
+            for (let child = node.node.firstChild; child; child = child.nextSibling) {
+                if (child.name == "VariableName")
+                    def(child, "variable");
+                else if (child.name == "in")
+                    break;
+            }
+    },
+    ImportStatement(_node, def) {
+        var _a, _b;
+        let { node } = _node;
+        let isFrom = ((_a = node.firstChild) === null || _a === void 0 ? void 0 : _a.name) == "from";
+        for (let ch = node.getChild("import"); ch; ch = ch.nextSibling) {
+            if (ch.name == "VariableName" && ((_b = ch.nextSibling) === null || _b === void 0 ? void 0 : _b.name) != "as")
+                def(ch, isFrom ? "variable" : "namespace");
+        }
+    },
+    AssignStatement(node, def) {
+        for (let child = node.node.firstChild; child; child = child.nextSibling) {
+            if (child.name == "VariableName")
+                def(child, "variable");
+            else if (child.name == ":" || child.name == "AssignOp")
+                break;
+        }
+    },
+    ParamList(node, def) {
+        for (let prev = null, child = node.node.firstChild; child; child = child.nextSibling) {
+            if (child.name == "VariableName" && (!prev || !/\*|AssignOp/.test(prev.name)))
+                def(child, "variable");
+            prev = child;
+        }
+    },
+    CapturePattern: defID("variable"),
+    AsPattern: defID("variable"),
+    __proto__: null
+};
+function getScope(doc, node) {
+    let cached = cache.get(node);
+    if (cached)
+        return cached;
+    let completions = [], top = true;
+    function def(node, type) {
+        let name = doc.sliceString(node.from, node.to);
+        completions.push({ label: name, type });
+    }
+    node.cursor(common.IterMode.IncludeAnonymous).iterate(node => {
+        if (node.name) {
+            let gather = gatherCompletions[node.name];
+            if (gather && gather(node, def, top) || !top && ScopeNodes.has(node.name))
+                return false;
+            top = false;
+        }
+        else if (node.to - node.from > 8192) {
+            // Allow caching for bigger internal nodes
+            for (let c of getScope(doc, node.node))
+                completions.push(c);
+            return false;
+        }
+    });
+    cache.set(node, completions);
+    return completions;
+}
+const Identifier = /^[\w\xa1-\uffff][\w\d\xa1-\uffff]*$/;
+const dontComplete = ["String", "FormatString", "Comment", "PropertyName"];
+/**
+Completion source that looks up locally defined names in
+Python code.
+*/
+function localCompletionSource(context) {
+    let inner = language.syntaxTree(context.state).resolveInner(context.pos, -1);
+    if (dontComplete.indexOf(inner.name) > -1)
+        return null;
+    let isWord = inner.name == "VariableName" ||
+        inner.to - inner.from < 20 && Identifier.test(context.state.sliceDoc(inner.from, inner.to));
+    if (!isWord && !context.explicit)
+        return null;
+    let options = [];
+    for (let pos = inner; pos; pos = pos.parent) {
+        if (ScopeNodes.has(pos.name))
+            options = options.concat(getScope(context.state.doc, pos));
+    }
+    return {
+        options,
+        from: isWord ? inner.from : context.pos,
+        validFor: Identifier
+    };
+}
+const globals = [
+    "__annotations__", "__builtins__", "__debug__", "__doc__", "__import__", "__name__",
+    "__loader__", "__package__", "__spec__",
+    "False", "None", "True"
+].map(n => ({ label: n, type: "constant" })).concat([
+    "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(n => ({ label: n, type: "type" }))).concat([
+    "bool", "bytearray", "bytes", "classmethod", "complex", "float", "frozenset", "int", "list",
+    "map", "memoryview", "object", "range", "set", "staticmethod", "str", "super", "tuple", "type"
+].map(n => ({ label: n, type: "class" }))).concat([
+    "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(n => ({ label: n, type: "function" })));
+const snippets = [
+    autocomplete.snippetCompletion("def ${name}(${params}):\n\t${}", {
+        label: "def",
+        detail: "function",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("for ${name} in ${collection}:\n\t${}", {
+        label: "for",
+        detail: "loop",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("while ${}:\n\t${}", {
+        label: "while",
+        detail: "loop",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("try:\n\t${}\nexcept ${error}:\n\t${}", {
+        label: "try",
+        detail: "/ except block",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("if ${}:\n\t\n", {
+        label: "if",
+        detail: "block",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("if ${}:\n\t${}\nelse:\n\t${}", {
+        label: "if",
+        detail: "/ else block",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("class ${name}:\n\tdef __init__(self, ${params}):\n\t\t\t${}", {
+        label: "class",
+        detail: "definition",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("import ${module}", {
+        label: "import",
+        detail: "statement",
+        type: "keyword"
+    }),
+    autocomplete.snippetCompletion("from ${module} import ${names}", {
+        label: "from",
+        detail: "import",
+        type: "keyword"
+    })
+];
+/**
+Autocompletion for built-in Python globals and keywords.
+*/
+const globalCompletion = autocomplete.ifNotIn(dontComplete, autocomplete.completeFromList(globals.concat(snippets)));
+
+function innerBody(context) {
+    let { node, pos } = context;
+    let lineIndent = context.lineIndent(pos, -1);
+    let found = null;
+    for (;;) {
+        let before = node.childBefore(pos);
+        if (!before) {
+            break;
+        }
+        else if (before.name == "Comment") {
+            pos = before.from;
+        }
+        else if (before.name == "Body" || before.name == "MatchBody") {
+            if (context.baseIndentFor(before) + context.unit <= lineIndent)
+                found = before;
+            node = before;
+        }
+        else if (before.name == "MatchClause") {
+            node = before;
+        }
+        else if (before.type.is("Statement")) {
+            node = before;
+        }
+        else {
+            break;
+        }
+    }
+    return found;
+}
+function indentBody(context, node) {
+    let base = context.baseIndentFor(node);
+    let line = context.lineAt(context.pos, -1), to = line.from + line.text.length;
+    // Don't consider blank, deindented lines at the end of the
+    // block part of the block
+    if (/^\s*($|#)/.test(line.text) &&
+        context.node.to < to + 100 &&
+        !/\S/.test(context.state.sliceDoc(to, context.node.to)) &&
+        context.lineIndent(context.pos, -1) <= base)
+        return null;
+    // A normally deindenting keyword that appears at a higher
+    // indentation than the block should probably be handled by the next
+    // level
+    if (/^\s*(else:|elif |except |finally:|case\s+[^=:]+:)/.test(context.textAfter) && context.lineIndent(context.pos, -1) > base)
+        return null;
+    return base + context.unit;
+}
+/**
+A language provider based on the [Lezer Python
+parser](https://github.com/lezer-parser/python), extended with
+highlighting and indentation information.
+*/
+const pythonLanguage = language.LRLanguage.define({
+    name: "python",
+    parser: python$1.parser.configure({
+        props: [
+            language.indentNodeProp.add({
+                Body: context => {
+                    var _a;
+                    let body = /^\s*(#|$)/.test(context.textAfter) && innerBody(context) || context.node;
+                    return (_a = indentBody(context, body)) !== null && _a !== void 0 ? _a : context.continue();
+                },
+                MatchBody: context => {
+                    var _a;
+                    let inner = innerBody(context);
+                    return (_a = indentBody(context, inner || context.node)) !== null && _a !== void 0 ? _a : context.continue();
+                },
+                IfStatement: cx => /^\s*(else:|elif )/.test(cx.textAfter) ? cx.baseIndent : cx.continue(),
+                "ForStatement WhileStatement": cx => /^\s*else:/.test(cx.textAfter) ? cx.baseIndent : cx.continue(),
+                TryStatement: cx => /^\s*(except[ :]|finally:|else:)/.test(cx.textAfter) ? cx.baseIndent : cx.continue(),
+                MatchStatement: cx => {
+                    if (/^\s*case /.test(cx.textAfter))
+                        return cx.baseIndent + cx.unit;
+                    return cx.continue();
+                },
+                "TupleExpression ComprehensionExpression ParamList ArgList ParenthesizedExpression": language.delimitedIndent({ closing: ")" }),
+                "DictionaryExpression DictionaryComprehensionExpression SetExpression SetComprehensionExpression": language.delimitedIndent({ closing: "}" }),
+                "ArrayExpression ArrayComprehensionExpression": language.delimitedIndent({ closing: "]" }),
+                MemberExpression: cx => cx.baseIndent + cx.unit,
+                "String FormatString": () => null,
+                Script: context => {
+                    var _a;
+                    let inner = innerBody(context);
+                    return (_a = (inner && indentBody(context, inner))) !== null && _a !== void 0 ? _a : context.continue();
+                },
+            }),
+            language.foldNodeProp.add({
+                "ArrayExpression DictionaryExpression SetExpression TupleExpression": language.foldInside,
+                Body: (node, state) => ({ from: node.from + 1, to: node.to - (node.to == state.doc.length ? 0 : 1) }),
+                "String FormatString": (node, state) => ({ from: state.doc.lineAt(node.from).to, to: node.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+[^:]*:?)$/,
+    }
+});
+/**
+Python language support.
+*/
+function python() {
+    return new language.LanguageSupport(pythonLanguage, [
+        pythonLanguage.data.of({ autocomplete: localCompletionSource }),
+        pythonLanguage.data.of({ autocomplete: globalCompletion }),
+    ]);
+}
+
+exports.globalCompletion = globalCompletion;
+exports.localCompletionSource = localCompletionSource;
+exports.python = python;
+exports.pythonLanguage = pythonLanguage;

package/node_modules/@codemirror/lang-python/dist/index.d.cts

@@ -0,0 +1,26 @@
+import { LRLanguage, LanguageSupport } from '@codemirror/language';
+import * as _codemirror_autocomplete from '@codemirror/autocomplete';
+import { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+
+/**
+Completion source that looks up locally defined names in
+Python code.
+*/
+declare function localCompletionSource(context: CompletionContext): CompletionResult | null;
+/**
+Autocompletion for built-in Python globals and keywords.
+*/
+declare const globalCompletion: _codemirror_autocomplete.CompletionSource;
+
+/**
+A language provider based on the [Lezer Python
+parser](https://github.com/lezer-parser/python), extended with
+highlighting and indentation information.
+*/
+declare const pythonLanguage: LRLanguage;
+/**
+Python language support.
+*/
+declare function python(): LanguageSupport;
+
+export { globalCompletion, localCompletionSource, python, pythonLanguage };

package/node_modules/@codemirror/lang-python/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { LRLanguage, LanguageSupport } from '@codemirror/language';
+import * as _codemirror_autocomplete from '@codemirror/autocomplete';
+import { CompletionContext, CompletionResult } from '@codemirror/autocomplete';
+
+/**
+Completion source that looks up locally defined names in
+Python code.
+*/
+declare function localCompletionSource(context: CompletionContext): CompletionResult | null;
+/**
+Autocompletion for built-in Python globals and keywords.
+*/
+declare const globalCompletion: _codemirror_autocomplete.CompletionSource;
+
+/**
+A language provider based on the [Lezer Python
+parser](https://github.com/lezer-parser/python), extended with
+highlighting and indentation information.
+*/
+declare const pythonLanguage: LRLanguage;
+/**
+Python language support.
+*/
+declare function python(): LanguageSupport;
+
+export { globalCompletion, localCompletionSource, python, pythonLanguage };