groove-dev 0.15.1 → 0.16.1

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

@@ -0,0 +1,162 @@
+<!-- NOTE: README.md is generated from src/README.md -->
+
+# @codemirror/lang-markdown [![NPM version](https://img.shields.io/npm/v/@codemirror/lang-markdown.svg)](https://www.npmjs.org/package/@codemirror/lang-markdown)
+
+[ [**WEBSITE**](https://codemirror.net/) | [**ISSUES**](https://github.com/codemirror/dev/issues) | [**FORUM**](https://discuss.codemirror.net/c/next/) | [**CHANGELOG**](https://github.com/codemirror/lang-markdown/blob/main/CHANGELOG.md) ]
+
+This package implements Markdown 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-markdown/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 {markdown} from "@codemirror/lang-markdown"
+
+const view = new EditorView({
+  parent: document.body,
+  doc: `*CodeMirror* Markdown \`mode\``,
+  extensions: [basicSetup, markdown()]
+})
+```
+
+## API Reference
+
+<dl>
+<dt id="user-content-markdown">
+  <code><strong><a href="#user-content-markdown">markdown</a></strong>(<a id="user-content-markdown^config" href="#user-content-markdown^config">config</a>&#8288;?: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object">Object</a> = {}) → <a href="https://codemirror.net/docs/ref#language.LanguageSupport">LanguageSupport</a></code></dt>
+
+<dd><p>Markdown language support.</p>
+<dl><dt id="user-content-markdown^config">
+  <code><strong><a href="#user-content-markdown^config">config</a></strong></code></dt>
+
+<dd><dl><dt id="user-content-markdown^config.defaultcodelanguage">
+  <code><strong><a href="#user-content-markdown^config.defaultcodelanguage">defaultCodeLanguage</a></strong>&#8288;?: <a href="https://codemirror.net/docs/ref#language.Language">Language</a> | <a href="https://codemirror.net/docs/ref#language.LanguageSupport">LanguageSupport</a></code></dt>
+
+<dd><p>When given, this language will be used by default to parse code
+blocks.</p>
+</dd><dt id="user-content-markdown^config.codelanguages">
+  <code><strong><a href="#user-content-markdown^config.codelanguages">codeLanguages</a></strong>&#8288;?: readonly <a href="https://codemirror.net/docs/ref#language.LanguageDescription">LanguageDescription</a>[] | fn(<a id="user-content-markdown^config.codelanguages^info" href="#user-content-markdown^config.codelanguages^info">info</a>: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String">string</a>) → <a href="https://codemirror.net/docs/ref#language.Language">Language</a> | <a href="https://codemirror.net/docs/ref#language.LanguageDescription">LanguageDescription</a> | <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null">null</a></code></dt>
+
+<dd><p>A source of language support for highlighting fenced code
+blocks. When it is an array, the parser will use
+<a href="https://codemirror.net/docs/ref/#language.LanguageDescription%5EmatchLanguageName"><code>LanguageDescription.matchLanguageName</code></a>
+with the fenced code info to find a matching language. When it
+is a function, will be called with the info string and may
+return a language or <code>LanguageDescription</code> object.</p>
+</dd><dt id="user-content-markdown^config.addkeymap">
+  <code><strong><a href="#user-content-markdown^config.addkeymap">addKeymap</a></strong>&#8288;?: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">boolean</a></code></dt>
+
+<dd><p>Set this to false to disable installation of the Markdown
+<a href="#user-content-markdownkeymap">keymap</a>.</p>
+</dd><dt id="user-content-markdown^config.extensions">
+  <code><strong><a href="#user-content-markdown^config.extensions">extensions</a></strong>&#8288;?: <a href="https://github.com/lezer-parser/markdown#user-content-markdownextension">MarkdownExtension</a></code></dt>
+
+<dd><p>Markdown parser
+<a href="https://github.com/lezer-parser/markdown#user-content-markdownextension">extensions</a>
+to add to the parser.</p>
+</dd><dt id="user-content-markdown^config.base">
+  <code><strong><a href="#user-content-markdown^config.base">base</a></strong>&#8288;?: <a href="https://codemirror.net/docs/ref#language.Language">Language</a></code></dt>
+
+<dd><p>The base language to use. Defaults to
+<a href="#user-content-commonmarklanguage"><code>commonmarkLanguage</code></a>.</p>
+</dd><dt id="user-content-markdown^config.completehtmltags">
+  <code><strong><a href="#user-content-markdown^config.completehtmltags">completeHTMLTags</a></strong>&#8288;?: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">boolean</a></code></dt>
+
+<dd><p>By default, the extension installs an autocompletion source that
+completes HTML tags when a <code>&lt;</code> is typed. Set this to false to
+disable this.</p>
+</dd><dt id="user-content-markdown^config.pasteurlaslink">
+  <code><strong><a href="#user-content-markdown^config.pasteurlaslink">pasteURLAsLink</a></strong>&#8288;?: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">boolean</a></code></dt>
+
+<dd><p>The returned language contains
+<a href="#user-content-pasteurlaslink"><code>pasteURLAsLink</code></a> as a support
+extension unless you set this to false.</p>
+</dd><dt id="user-content-markdown^config.htmltaglanguage">
+  <code><strong><a href="#user-content-markdown^config.htmltaglanguage">htmlTagLanguage</a></strong>&#8288;?: <a href="https://codemirror.net/docs/ref#language.LanguageSupport">LanguageSupport</a></code></dt>
+
+<dd><p>By default, HTML tags in the document are handled by the <a href="https://github.com/codemirror/lang-html">HTML
+language</a> package with
+tag matching turned off. You can pass in an alternative language
+configuration here if you want.</p>
+</dd></dl></dd></dl></dd>
+<dt id="user-content-markdownlanguage">
+  <code><strong><a href="#user-content-markdownlanguage">markdownLanguage</a></strong>: <a href="https://codemirror.net/docs/ref#language.Language">Language</a></code></dt>
+
+<dd><p>Language support for <a href="https://github.github.com/gfm/">GFM</a> plus
+subscript, superscript, and emoji syntax.</p>
+</dd>
+<dt id="user-content-commonmarklanguage">
+  <code><strong><a href="#user-content-commonmarklanguage">commonmarkLanguage</a></strong>: <a href="https://codemirror.net/docs/ref#language.Language">Language</a></code></dt>
+
+<dd><p>Language support for strict CommonMark.</p>
+</dd>
+<dt id="user-content-insertnewlinecontinuemarkup">
+  <code><strong><a href="#user-content-insertnewlinecontinuemarkup">insertNewlineContinueMarkup</a></strong>: <a href="https://codemirror.net/docs/ref#state.StateCommand">StateCommand</a></code></dt>
+
+<dd><p>This command, when invoked in Markdown context with cursor
+selection(s), will create a new line with the markup for
+blockquotes and lists that were active on the old line. If the
+cursor was directly after the end of the markup for the old line,
+trailing whitespace and list markers are removed from that line.</p>
+<p>The command does nothing in non-Markdown context, so it should
+not be used as the only binding for Enter (even in a Markdown
+document, HTML and code regions might use a different language).</p>
+</dd>
+<dt id="user-content-insertnewlinecontinuemarkupcommand">
+  <code><strong><a href="#user-content-insertnewlinecontinuemarkupcommand">insertNewlineContinueMarkupCommand</a></strong>(<a id="user-content-insertnewlinecontinuemarkupcommand^config" href="#user-content-insertnewlinecontinuemarkupcommand^config">config</a>&#8288;?: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object">Object</a> = {}) → <a href="https://codemirror.net/docs/ref#state.StateCommand">StateCommand</a></code></dt>
+
+<dd><p>Returns a command like
+<a href="#user-content-insertnewlinecontinuemarkup"><code>insertNewlineContinueMarkup</code></a>,
+allowing further configuration.</p>
+<dl><dt id="user-content-insertnewlinecontinuemarkupcommand^config">
+  <code><strong><a href="#user-content-insertnewlinecontinuemarkupcommand^config">config</a></strong></code></dt>
+
+<dd><dl><dt id="user-content-insertnewlinecontinuemarkupcommand^config.nontightlists">
+  <code><strong><a href="#user-content-insertnewlinecontinuemarkupcommand^config.nontightlists">nonTightLists</a></strong>&#8288;?: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">boolean</a></code></dt>
+
+<dd><p>By default, when pressing enter in a blank second item in a
+tight (no blank lines between items) list, the command will
+insert a blank line above that item, starting a non-tight list.
+Set this to false to disable this behavior.</p>
+</dd></dl></dd></dl></dd>
+<dt id="user-content-deletemarkupbackward">
+  <code><strong><a href="#user-content-deletemarkupbackward">deleteMarkupBackward</a></strong>: <a href="https://codemirror.net/docs/ref#state.StateCommand">StateCommand</a></code></dt>
+
+<dd><p>This command will, when invoked in a Markdown context with the
+cursor directly after list or blockquote markup, delete one level
+of markup. When the markup is for a list, it will be replaced by
+spaces on the first invocation (a further invocation will delete
+the spaces), to make it easy to continue a list.</p>
+<p>When not after Markdown block markup, this command will return
+false, so it is intended to be bound alongside other deletion
+commands, with a higher precedence than the more generic commands.</p>
+</dd>
+<dt id="user-content-markdownkeymap">
+  <code><strong><a href="#user-content-markdownkeymap">markdownKeymap</a></strong>: readonly <a href="https://codemirror.net/docs/ref#view.KeyBinding">KeyBinding</a>[]</code></dt>
+
+<dd><p>A small keymap with Markdown-specific bindings. Binds Enter to
+<a href="#user-content-insertnewlinecontinuemarkup"><code>insertNewlineContinueMarkup</code></a>
+and Backspace to
+<a href="#user-content-deletemarkupbackward"><code>deleteMarkupBackward</code></a>.</p>
+</dd>
+<dt id="user-content-pasteurlaslink">
+  <code><strong><a href="#user-content-pasteurlaslink">pasteURLAsLink</a></strong>: <a href="https://codemirror.net/docs/ref#state.Extension">Extension</a></code></dt>
+
+<dd><p>An extension that intercepts pastes when the pasted content looks
+like a URL and the selection is non-empty and selects regular
+text, making the selection a link with the pasted URL as target.</p>
+</dd>
+</dl>

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

@@ -0,0 +1,501 @@
+'use strict';
+
+var state = require('@codemirror/state');
+var view = require('@codemirror/view');
+var language = require('@codemirror/language');
+var autocomplete = require('@codemirror/autocomplete');
+var markdown$1 = require('@lezer/markdown');
+var langHtml = require('@codemirror/lang-html');
+var common = require('@lezer/common');
+
+const data = language.defineLanguageFacet({ commentTokens: { block: { open: "<!--", close: "-->" } } });
+const headingProp = new common.NodeProp();
+const commonmark = markdown$1.parser.configure({
+    props: [
+        language.foldNodeProp.add(type => {
+            return !type.is("Block") || type.is("Document") || isHeading(type) != null || isList(type) ? undefined
+                : (tree, state) => ({ from: state.doc.lineAt(tree.from).to, to: tree.to });
+        }),
+        headingProp.add(isHeading),
+        language.indentNodeProp.add({
+            Document: () => null
+        }),
+        language.languageDataProp.add({
+            Document: data
+        })
+    ]
+});
+function isHeading(type) {
+    let match = /^(?:ATX|Setext)Heading(\d)$/.exec(type.name);
+    return match ? +match[1] : undefined;
+}
+function isList(type) {
+    return type.name == "OrderedList" || type.name == "BulletList";
+}
+function findSectionEnd(headerNode, level) {
+    let last = headerNode;
+    for (;;) {
+        let next = last.nextSibling, heading;
+        if (!next || (heading = isHeading(next.type)) != null && heading <= level)
+            break;
+        last = next;
+    }
+    return last.to;
+}
+const headerIndent = language.foldService.of((state, start, end) => {
+    for (let node = language.syntaxTree(state).resolveInner(end, -1); node; node = node.parent) {
+        if (node.from < start)
+            break;
+        let heading = node.type.prop(headingProp);
+        if (heading == null)
+            continue;
+        let upto = findSectionEnd(node, heading);
+        if (upto > end)
+            return { from: end, to: upto };
+    }
+    return null;
+});
+function mkLang(parser) {
+    return new language.Language(data, parser, [], "markdown");
+}
+/**
+Language support for strict CommonMark.
+*/
+const commonmarkLanguage = mkLang(commonmark);
+const extended = commonmark.configure([markdown$1.GFM, markdown$1.Subscript, markdown$1.Superscript, markdown$1.Emoji, {
+        props: [
+            language.foldNodeProp.add({
+                Table: (tree, state) => ({ from: state.doc.lineAt(tree.from).to, to: tree.to })
+            })
+        ]
+    }]);
+/**
+Language support for [GFM](https://github.github.com/gfm/) plus
+subscript, superscript, and emoji syntax.
+*/
+const markdownLanguage = mkLang(extended);
+function getCodeParser(languages, defaultLanguage) {
+    return (info) => {
+        if (info && languages) {
+            let found = null;
+            // Strip anything after whitespace
+            info = /\S*/.exec(info)[0];
+            if (typeof languages == "function")
+                found = languages(info);
+            else
+                found = language.LanguageDescription.matchLanguageName(languages, info, true);
+            if (found instanceof language.LanguageDescription)
+                return found.support ? found.support.language.parser : language.ParseContext.getSkippingParser(found.load());
+            else if (found)
+                return found.parser;
+        }
+        return defaultLanguage ? defaultLanguage.parser : null;
+    };
+}
+
+class Context {
+    constructor(node, from, to, spaceBefore, spaceAfter, type, item) {
+        this.node = node;
+        this.from = from;
+        this.to = to;
+        this.spaceBefore = spaceBefore;
+        this.spaceAfter = spaceAfter;
+        this.type = type;
+        this.item = item;
+    }
+    blank(maxWidth, trailing = true) {
+        let result = this.spaceBefore + (this.node.name == "Blockquote" ? ">" : "");
+        if (maxWidth != null) {
+            while (result.length < maxWidth)
+                result += " ";
+            return result;
+        }
+        else {
+            for (let i = this.to - this.from - result.length - this.spaceAfter.length; i > 0; i--)
+                result += " ";
+            return result + (trailing ? this.spaceAfter : "");
+        }
+    }
+    marker(doc, add) {
+        let number = this.node.name == "OrderedList" ? String((+itemNumber(this.item, doc)[2] + add)) : "";
+        return this.spaceBefore + number + this.type + this.spaceAfter;
+    }
+}
+function getContext(node, doc) {
+    let nodes = [], context = [];
+    for (let cur = node; cur; cur = cur.parent) {
+        if (cur.name == "FencedCode")
+            return context;
+        if (cur.name == "ListItem" || cur.name == "Blockquote")
+            nodes.push(cur);
+    }
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        let node = nodes[i], match;
+        let line = doc.lineAt(node.from), startPos = node.from - line.from;
+        if (node.name == "Blockquote" && (match = /^ *>( ?)/.exec(line.text.slice(startPos)))) {
+            context.push(new Context(node, startPos, startPos + match[0].length, "", match[1], ">", null));
+        }
+        else if (node.name == "ListItem" && node.parent.name == "OrderedList" &&
+            (match = /^( *)\d+([.)])( *)/.exec(line.text.slice(startPos)))) {
+            let after = match[3], len = match[0].length;
+            if (after.length >= 4) {
+                after = after.slice(0, after.length - 4);
+                len -= 4;
+            }
+            context.push(new Context(node.parent, startPos, startPos + len, match[1], after, match[2], node));
+        }
+        else if (node.name == "ListItem" && node.parent.name == "BulletList" &&
+            (match = /^( *)([-+*])( {1,4}\[[ xX]\])?( +)/.exec(line.text.slice(startPos)))) {
+            let after = match[4], len = match[0].length;
+            if (after.length > 4) {
+                after = after.slice(0, after.length - 4);
+                len -= 4;
+            }
+            let type = match[2];
+            if (match[3])
+                type += match[3].replace(/[xX]/, ' ');
+            context.push(new Context(node.parent, startPos, startPos + len, match[1], after, type, node));
+        }
+    }
+    return context;
+}
+function itemNumber(item, doc) {
+    return /^(\s*)(\d+)(?=[.)])/.exec(doc.sliceString(item.from, item.from + 10));
+}
+function renumberList(after, doc, changes, offset = 0) {
+    for (let prev = -1, node = after;;) {
+        if (node.name == "ListItem") {
+            let m = itemNumber(node, doc);
+            let number = +m[2];
+            if (prev >= 0) {
+                if (number != prev + 1)
+                    return;
+                changes.push({ from: node.from + m[1].length, to: node.from + m[0].length, insert: String(prev + 2 + offset) });
+            }
+            prev = number;
+        }
+        let next = node.nextSibling;
+        if (!next)
+            break;
+        node = next;
+    }
+}
+function normalizeIndent(content, state$1) {
+    let blank = /^[ \t]*/.exec(content)[0].length;
+    if (!blank || state$1.facet(language.indentUnit) != "\t")
+        return content;
+    let col = state.countColumn(content, 4, blank);
+    let space = "";
+    for (let i = col; i > 0;) {
+        if (i >= 4) {
+            space += "\t";
+            i -= 4;
+        }
+        else {
+            space += " ";
+            i--;
+        }
+    }
+    return space + content.slice(blank);
+}
+/**
+Returns a command like
+[`insertNewlineContinueMarkup`](https://codemirror.net/6/docs/ref/#lang-markdown.insertNewlineContinueMarkup),
+allowing further configuration.
+*/
+const insertNewlineContinueMarkupCommand = (config = {}) => ({ state: state$1, dispatch }) => {
+    let tree = language.syntaxTree(state$1), { doc } = state$1;
+    let dont = null, changes = state$1.changeByRange(range => {
+        if (!range.empty || !markdownLanguage.isActiveAt(state$1, range.from, -1) && !markdownLanguage.isActiveAt(state$1, range.from, 1))
+            return dont = { range };
+        let pos = range.from, line = doc.lineAt(pos);
+        let context = getContext(tree.resolveInner(pos, -1), doc);
+        while (context.length && context[context.length - 1].from > pos - line.from)
+            context.pop();
+        if (!context.length)
+            return dont = { range };
+        let inner = context[context.length - 1];
+        if (inner.to - inner.spaceAfter.length > pos - line.from)
+            return dont = { range };
+        let emptyLine = pos >= (inner.to - inner.spaceAfter.length) && !/\S/.test(line.text.slice(inner.to));
+        // Empty line in list
+        if (inner.item && emptyLine) {
+            let first = inner.node.firstChild, second = inner.node.getChild("ListItem", "ListItem");
+            // Not second item or blank line before: delete a level of markup
+            if (first.to >= pos || second && second.to < pos ||
+                line.from > 0 && !/[^\s>]/.test(doc.lineAt(line.from - 1).text) ||
+                config.nonTightLists === false) {
+                let next = context.length > 1 ? context[context.length - 2] : null;
+                let delTo, insert = "";
+                if (next && next.item) { // Re-add marker for the list at the next level
+                    delTo = line.from + next.from;
+                    insert = next.marker(doc, 1);
+                }
+                else {
+                    delTo = line.from + (next ? next.to : 0);
+                }
+                let changes = [{ from: delTo, to: pos, insert }];
+                if (inner.node.name == "OrderedList")
+                    renumberList(inner.item, doc, changes, -2);
+                if (next && next.node.name == "OrderedList")
+                    renumberList(next.item, doc, changes);
+                return { range: state.EditorSelection.cursor(delTo + insert.length), changes };
+            }
+            else { // Move second item down, making tight two-item list non-tight
+                let insert = blankLine(context, state$1, line);
+                return { range: state.EditorSelection.cursor(pos + insert.length + 1),
+                    changes: { from: line.from, insert: insert + state$1.lineBreak } };
+            }
+        }
+        if (inner.node.name == "Blockquote" && emptyLine && line.from) {
+            let prevLine = doc.lineAt(line.from - 1), quoted = />\s*$/.exec(prevLine.text);
+            // Two aligned empty quoted lines in a row
+            if (quoted && quoted.index == inner.from) {
+                let changes = state$1.changes([{ from: prevLine.from + quoted.index, to: prevLine.to },
+                    { from: line.from + inner.from, to: line.to }]);
+                return { range: range.map(changes), changes };
+            }
+        }
+        let changes = [];
+        if (inner.node.name == "OrderedList")
+            renumberList(inner.item, doc, changes);
+        let continued = inner.item && inner.item.from < line.from;
+        let insert = "";
+        // If not dedented
+        if (!continued || /^[\s\d.)\-+*>]*/.exec(line.text)[0].length >= inner.to) {
+            for (let i = 0, e = context.length - 1; i <= e; i++) {
+                insert += i == e && !continued ? context[i].marker(doc, 1)
+                    : context[i].blank(i < e ? state.countColumn(line.text, 4, context[i + 1].from) - insert.length : null);
+            }
+        }
+        let from = pos;
+        while (from > line.from && /\s/.test(line.text.charAt(from - line.from - 1)))
+            from--;
+        insert = normalizeIndent(insert, state$1);
+        if (nonTightList(inner.node, state$1.doc))
+            insert = blankLine(context, state$1, line) + state$1.lineBreak + insert;
+        changes.push({ from, to: pos, insert: state$1.lineBreak + insert });
+        return { range: state.EditorSelection.cursor(from + insert.length + 1), changes };
+    });
+    if (dont)
+        return false;
+    dispatch(state$1.update(changes, { scrollIntoView: true, userEvent: "input" }));
+    return true;
+};
+/**
+This command, when invoked in Markdown context with cursor
+selection(s), will create a new line with the markup for
+blockquotes and lists that were active on the old line. If the
+cursor was directly after the end of the markup for the old line,
+trailing whitespace and list markers are removed from that line.
+
+The command does nothing in non-Markdown context, so it should
+not be used as the only binding for Enter (even in a Markdown
+document, HTML and code regions might use a different language).
+*/
+const insertNewlineContinueMarkup = insertNewlineContinueMarkupCommand();
+function isMark(node) {
+    return node.name == "QuoteMark" || node.name == "ListMark";
+}
+function nonTightList(node, doc) {
+    if (node.name != "OrderedList" && node.name != "BulletList")
+        return false;
+    let first = node.firstChild, second = node.getChild("ListItem", "ListItem");
+    if (!second)
+        return false;
+    let line1 = doc.lineAt(first.to), line2 = doc.lineAt(second.from);
+    let empty = /^[\s>]*$/.test(line1.text);
+    return line1.number + (empty ? 0 : 1) < line2.number;
+}
+function blankLine(context, state$1, line) {
+    let insert = "";
+    for (let i = 0, e = context.length - 2; i <= e; i++) {
+        insert += context[i].blank(i < e
+            ? state.countColumn(line.text, 4, context[i + 1].from) - insert.length
+            : null, i < e);
+    }
+    return normalizeIndent(insert, state$1);
+}
+function contextNodeForDelete(tree, pos) {
+    let node = tree.resolveInner(pos, -1), scan = pos;
+    if (isMark(node)) {
+        scan = node.from;
+        node = node.parent;
+    }
+    for (let prev; prev = node.childBefore(scan);) {
+        if (isMark(prev)) {
+            scan = prev.from;
+        }
+        else if (prev.name == "OrderedList" || prev.name == "BulletList") {
+            node = prev.lastChild;
+            scan = node.to;
+        }
+        else {
+            break;
+        }
+    }
+    return node;
+}
+/**
+This command will, when invoked in a Markdown context with the
+cursor directly after list or blockquote markup, delete one level
+of markup. When the markup is for a list, it will be replaced by
+spaces on the first invocation (a further invocation will delete
+the spaces), to make it easy to continue a list.
+
+When not after Markdown block markup, this command will return
+false, so it is intended to be bound alongside other deletion
+commands, with a higher precedence than the more generic commands.
+*/
+const deleteMarkupBackward = ({ state: state$1, dispatch }) => {
+    let tree = language.syntaxTree(state$1);
+    let dont = null, changes = state$1.changeByRange(range => {
+        let pos = range.from, { doc } = state$1;
+        if (range.empty && markdownLanguage.isActiveAt(state$1, range.from)) {
+            let line = doc.lineAt(pos);
+            let context = getContext(contextNodeForDelete(tree, pos), doc);
+            if (context.length) {
+                let inner = context[context.length - 1];
+                let spaceEnd = inner.to - inner.spaceAfter.length + (inner.spaceAfter ? 1 : 0);
+                // Delete extra trailing space after markup
+                if (pos - line.from > spaceEnd && !/\S/.test(line.text.slice(spaceEnd, pos - line.from)))
+                    return { range: state.EditorSelection.cursor(line.from + spaceEnd),
+                        changes: { from: line.from + spaceEnd, to: pos } };
+                if (pos - line.from == spaceEnd &&
+                    // Only apply this if we're on the line that has the
+                    // construct's syntax, or there's only indentation in the
+                    // target range
+                    (!inner.item || line.from <= inner.item.from || !/\S/.test(line.text.slice(0, inner.to)))) {
+                    let start = line.from + inner.from;
+                    // Replace a list item marker with blank space
+                    if (inner.item && inner.node.from < inner.item.from && /\S/.test(line.text.slice(inner.from, inner.to))) {
+                        let insert = inner.blank(state.countColumn(line.text, 4, inner.to) - state.countColumn(line.text, 4, inner.from));
+                        if (start == line.from)
+                            insert = normalizeIndent(insert, state$1);
+                        return { range: state.EditorSelection.cursor(start + insert.length),
+                            changes: { from: start, to: line.from + inner.to, insert } };
+                    }
+                    // Delete one level of indentation
+                    if (start < pos)
+                        return { range: state.EditorSelection.cursor(start), changes: { from: start, to: pos } };
+                }
+            }
+        }
+        return dont = { range };
+    });
+    if (dont)
+        return false;
+    dispatch(state$1.update(changes, { scrollIntoView: true, userEvent: "delete" }));
+    return true;
+};
+
+/**
+A small keymap with Markdown-specific bindings. Binds Enter to
+[`insertNewlineContinueMarkup`](https://codemirror.net/6/docs/ref/#lang-markdown.insertNewlineContinueMarkup)
+and Backspace to
+[`deleteMarkupBackward`](https://codemirror.net/6/docs/ref/#lang-markdown.deleteMarkupBackward).
+*/
+const markdownKeymap = [
+    { key: "Enter", run: insertNewlineContinueMarkup },
+    { key: "Backspace", run: deleteMarkupBackward }
+];
+const htmlNoMatch = langHtml.html({ matchClosingTags: false });
+/**
+Markdown language support.
+*/
+function markdown(config = {}) {
+    let { codeLanguages, defaultCodeLanguage, addKeymap = true, base: { parser } = commonmarkLanguage, completeHTMLTags = true, pasteURLAsLink: pasteURL = true, htmlTagLanguage = htmlNoMatch } = config;
+    if (!(parser instanceof markdown$1.MarkdownParser))
+        throw new RangeError("Base parser provided to `markdown` should be a Markdown parser");
+    let extensions = config.extensions ? [config.extensions] : [];
+    let support = [htmlTagLanguage.support, headerIndent], defaultCode;
+    if (pasteURL)
+        support.push(pasteURLAsLink);
+    if (defaultCodeLanguage instanceof language.LanguageSupport) {
+        support.push(defaultCodeLanguage.support);
+        defaultCode = defaultCodeLanguage.language;
+    }
+    else if (defaultCodeLanguage) {
+        defaultCode = defaultCodeLanguage;
+    }
+    let codeParser = codeLanguages || defaultCode ? getCodeParser(codeLanguages, defaultCode) : undefined;
+    extensions.push(markdown$1.parseCode({ codeParser, htmlParser: htmlTagLanguage.language.parser }));
+    if (addKeymap)
+        support.push(state.Prec.high(view.keymap.of(markdownKeymap)));
+    let lang = mkLang(parser.configure(extensions));
+    if (completeHTMLTags)
+        support.push(lang.data.of({ autocomplete: htmlTagCompletion }));
+    return new language.LanguageSupport(lang, support);
+}
+function htmlTagCompletion(context) {
+    let { state, pos } = context, m = /<[:\-\.\w\u00b7-\uffff]*$/.exec(state.sliceDoc(pos - 25, pos));
+    if (!m)
+        return null;
+    let tree = language.syntaxTree(state).resolveInner(pos, -1);
+    while (tree && !tree.type.isTop) {
+        if (tree.name == "CodeBlock" || tree.name == "FencedCode" || tree.name == "ProcessingInstructionBlock" ||
+            tree.name == "CommentBlock" || tree.name == "Link" || tree.name == "Image")
+            return null;
+        tree = tree.parent;
+    }
+    return {
+        from: pos - m[0].length, to: pos,
+        options: htmlTagCompletions(),
+        validFor: /^<[:\-\.\w\u00b7-\uffff]*$/
+    };
+}
+let _tagCompletions = null;
+function htmlTagCompletions() {
+    if (_tagCompletions)
+        return _tagCompletions;
+    let result = langHtml.htmlCompletionSource(new autocomplete.CompletionContext(state.EditorState.create({ extensions: htmlNoMatch }), 0, true));
+    return _tagCompletions = result ? result.options : [];
+}
+const nonPlainText = /code|horizontalrule|html|link|comment|processing|escape|entity|image|mark|url/i;
+/**
+An extension that intercepts pastes when the pasted content looks
+like a URL and the selection is non-empty and selects regular
+text, making the selection a link with the pasted URL as target.
+*/
+const pasteURLAsLink = view.EditorView.domEventHandlers({
+    paste: (event, view) => {
+        var _a;
+        let { main } = view.state.selection;
+        if (main.empty)
+            return false;
+        let link = (_a = event.clipboardData) === null || _a === void 0 ? void 0 : _a.getData("text/plain");
+        if (!link || !/^(https?:\/\/|mailto:|xmpp:|www\.)/.test(link))
+            return false;
+        if (/^www\./.test(link))
+            link = "https://" + link;
+        if (!markdownLanguage.isActiveAt(view.state, main.from, 1))
+            return false;
+        let tree = language.syntaxTree(view.state), crossesNode = false;
+        // Verify that no nodes are started/ended between the selection
+        // points, and we're not inside any non-plain-text construct.
+        tree.iterate({
+            from: main.from, to: main.to,
+            enter: node => { if (node.from > main.from || nonPlainText.test(node.name))
+                crossesNode = true; },
+            leave: node => { if (node.to < main.to)
+                crossesNode = true; }
+        });
+        if (crossesNode)
+            return false;
+        view.dispatch({
+            changes: [{ from: main.from, insert: "[" }, { from: main.to, insert: `](${link})` }],
+            userEvent: "input.paste",
+            scrollIntoView: true
+        });
+        return true;
+    }
+});
+
+exports.commonmarkLanguage = commonmarkLanguage;
+exports.deleteMarkupBackward = deleteMarkupBackward;
+exports.insertNewlineContinueMarkup = insertNewlineContinueMarkup;
+exports.insertNewlineContinueMarkupCommand = insertNewlineContinueMarkupCommand;
+exports.markdown = markdown;
+exports.markdownKeymap = markdownKeymap;
+exports.markdownLanguage = markdownLanguage;
+exports.pasteURLAsLink = pasteURLAsLink;