@maketribe/ms-app 3.0.36 → 3.0.38

package/dist/cjs/node_modules/.pnpm/@codemirror_language@6.9.3/node_modules/@codemirror/language/dist/index.js

@@ -4,7 +4,6 @@ var index$2 = require('../../../../../@lezer_common@1.1.1/node_modules/@lezer/co
 var index = require('../../../../../@codemirror_state@6.3.2/node_modules/@codemirror/state/dist/index.js');
 var index$3 = require('../../../../../@codemirror_view@6.22.1/node_modules/@codemirror/view/dist/index.js');
 var index$1 = require('../../../../../@lezer_highlight@1.2.0/node_modules/@lezer/highlight/dist/index.js');
-var styleMod = require('../../../../../style-mod@4.1.0/node_modules/style-mod/src/style-mod.js');
 
 var _a;
 /**
@@ -641,17 +640,6 @@ class LanguageSupport {
         this.extension = [language, support];
     }
 }
-
-/**
-Facet that defines a way to provide a function that computes the
-appropriate indentation depth, as a column number (see
-[`indentString`](https://codemirror.net/6/docs/ref/#language.indentString)), at the start of a given
-line. A return value of `null` indicates no indentation can be
-determined, and the line should inherit the indentation of the one
-above it. A return value of `undefined` defers to the next indent
-service.
-*/
-const indentService = /*@__PURE__*/index.Facet.define();
 /**
 Facet for overriding the unit by which indentation happens. Should
 be a string consisting either entirely of the same whitespace
@@ -697,120 +685,6 @@ function indentString(state, cols) {
     return result;
 }
 /**
-Get the indentation, as a column number, at the given position.
-Will first consult any [indent services](https://codemirror.net/6/docs/ref/#language.indentService)
-that are registered, and if none of those return an indentation,
-this will check the syntax tree for the [indent node
-prop](https://codemirror.net/6/docs/ref/#language.indentNodeProp) and use that if found. Returns a
-number when an indentation could be determined, and null
-otherwise.
-*/
-function getIndentation(context, pos) {
-    if (context instanceof index.EditorState)
-        context = new IndentContext(context);
-    for (let service of context.state.facet(indentService)) {
-        let result = service(context, pos);
-        if (result !== undefined)
-            return result;
-    }
-    let tree = syntaxTree(context.state);
-    return tree.length >= pos ? syntaxIndentation(context, tree, pos) : null;
-}
-/**
-Indentation contexts are used when calling [indentation
-services](https://codemirror.net/6/docs/ref/#language.indentService). They provide helper utilities
-useful in indentation logic, and can selectively override the
-indentation reported for some lines.
-*/
-class IndentContext {
-    /**
-    Create an indent context.
-    */
-    constructor(
-    /**
-    The editor state.
-    */
-    state, 
-    /**
-    @internal
-    */
-    options = {}) {
-        this.state = state;
-        this.options = options;
-        this.unit = getIndentUnit(state);
-    }
-    /**
-    Get a description of the line at the given position, taking
-    [simulated line
-    breaks](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
-    into account. If there is such a break at `pos`, the `bias`
-    argument determines whether the part of the line line before or
-    after the break is used.
-    */
-    lineAt(pos, bias = 1) {
-        let line = this.state.doc.lineAt(pos);
-        let { simulateBreak, simulateDoubleBreak } = this.options;
-        if (simulateBreak != null && simulateBreak >= line.from && simulateBreak <= line.to) {
-            if (simulateDoubleBreak && simulateBreak == pos)
-                return { text: "", from: pos };
-            else if (bias < 0 ? simulateBreak < pos : simulateBreak <= pos)
-                return { text: line.text.slice(simulateBreak - line.from), from: simulateBreak };
-            else
-                return { text: line.text.slice(0, simulateBreak - line.from), from: line.from };
-        }
-        return line;
-    }
-    /**
-    Get the text directly after `pos`, either the entire line
-    or the next 100 characters, whichever is shorter.
-    */
-    textAfterPos(pos, bias = 1) {
-        if (this.options.simulateDoubleBreak && pos == this.options.simulateBreak)
-            return "";
-        let { text, from } = this.lineAt(pos, bias);
-        return text.slice(pos - from, Math.min(text.length, pos + 100 - from));
-    }
-    /**
-    Find the column for the given position.
-    */
-    column(pos, bias = 1) {
-        let { text, from } = this.lineAt(pos, bias);
-        let result = this.countColumn(text, pos - from);
-        let override = this.options.overrideIndentation ? this.options.overrideIndentation(from) : -1;
-        if (override > -1)
-            result += override - this.countColumn(text, text.search(/\S|$/));
-        return result;
-    }
-    /**
-    Find the column position (taking tabs into account) of the given
-    position in the given string.
-    */
-    countColumn(line, pos = line.length) {
-        return index.countColumn(line, this.state.tabSize, pos);
-    }
-    /**
-    Find the indentation column of the line at the given point.
-    */
-    lineIndent(pos, bias = 1) {
-        let { text, from } = this.lineAt(pos, bias);
-        let override = this.options.overrideIndentation;
-        if (override) {
-            let overriden = override(from);
-            if (overriden > -1)
-                return overriden;
-        }
-        return this.countColumn(text, text.search(/\S|$/));
-    }
-    /**
-    Returns the [simulated line
-    break](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
-    for this context, if any.
-    */
-    get simulatedBreak() {
-        return this.options.simulateBreak || null;
-    }
-}
-/**
 A syntax tree node prop used to associate indentation strategies
 with node types. Such a strategy is a function from an indentation
 context to a column number (see also
@@ -818,148 +692,6 @@ context to a column number (see also
 indicates that no definitive indentation can be determined.
 */
 const indentNodeProp = /*@__PURE__*/new index$2.NodeProp();
-// Compute the indentation for a given position from the syntax tree.
-function syntaxIndentation(cx, ast, pos) {
-    let stack = ast.resolveStack(pos);
-    let inner = stack.node.enterUnfinishedNodesBefore(pos);
-    if (inner != stack.node) {
-        let add = [];
-        for (let cur = inner; cur != stack.node; cur = cur.parent)
-            add.push(cur);
-        for (let i = add.length - 1; i >= 0; i--)
-            stack = { node: add[i], next: stack };
-    }
-    return indentFor(stack, cx, pos);
-}
-function indentFor(stack, cx, pos) {
-    for (let cur = stack; cur; cur = cur.next) {
-        let strategy = indentStrategy(cur.node);
-        if (strategy)
-            return strategy(TreeIndentContext.create(cx, pos, cur));
-    }
-    return 0;
-}
-function ignoreClosed(cx) {
-    return cx.pos == cx.options.simulateBreak && cx.options.simulateDoubleBreak;
-}
-function indentStrategy(tree) {
-    let strategy = tree.type.prop(indentNodeProp);
-    if (strategy)
-        return strategy;
-    let first = tree.firstChild, close;
-    if (first && (close = first.type.prop(index$2.NodeProp.closedBy))) {
-        let last = tree.lastChild, closed = last && close.indexOf(last.name) > -1;
-        return cx => delimitedStrategy(cx, true, 1, undefined, closed && !ignoreClosed(cx) ? last.from : undefined);
-    }
-    return tree.parent == null ? topIndent : null;
-}
-function topIndent() { return 0; }
-/**
-Objects of this type provide context information and helper
-methods to indentation functions registered on syntax nodes.
-*/
-class TreeIndentContext extends IndentContext {
-    constructor(base, 
-    /**
-    The position at which indentation is being computed.
-    */
-    pos, 
-    /**
-    @internal
-    */
-    context) {
-        super(base.state, base.options);
-        this.base = base;
-        this.pos = pos;
-        this.context = context;
-    }
-    /**
-    The syntax tree node to which the indentation strategy
-    applies.
-    */
-    get node() { return this.context.node; }
-    /**
-    @internal
-    */
-    static create(base, pos, context) {
-        return new TreeIndentContext(base, pos, context);
-    }
-    /**
-    Get the text directly after `this.pos`, either the entire line
-    or the next 100 characters, whichever is shorter.
-    */
-    get textAfter() {
-        return this.textAfterPos(this.pos);
-    }
-    /**
-    Get the indentation at the reference line for `this.node`, which
-    is the line on which it starts, unless there is a node that is
-    _not_ a parent of this node covering the start of that line. If
-    so, the line at the start of that node is tried, again skipping
-    on if it is covered by another such node.
-    */
-    get baseIndent() {
-        return this.baseIndentFor(this.node);
-    }
-    /**
-    Get the indentation for the reference line of the given node
-    (see [`baseIndent`](https://codemirror.net/6/docs/ref/#language.TreeIndentContext.baseIndent)).
-    */
-    baseIndentFor(node) {
-        let line = this.state.doc.lineAt(node.from);
-        // Skip line starts that are covered by a sibling (or cousin, etc)
-        for (;;) {
-            let atBreak = node.resolve(line.from);
-            while (atBreak.parent && atBreak.parent.from == atBreak.from)
-                atBreak = atBreak.parent;
-            if (isParent(atBreak, node))
-                break;
-            line = this.state.doc.lineAt(atBreak.from);
-        }
-        return this.lineIndent(line.from);
-    }
-    /**
-    Continue looking for indentations in the node's parent nodes,
-    and return the result of that.
-    */
-    continue() {
-        return indentFor(this.context.next, this.base, this.pos);
-    }
-}
-function isParent(parent, of) {
-    for (let cur = of; cur; cur = cur.parent)
-        if (parent == cur)
-            return true;
-    return false;
-}
-// Check whether a delimited node is aligned (meaning there are
-// non-skipped nodes on the same line as the opening delimiter). And
-// if so, return the opening token.
-function bracketedAligned(context) {
-    let tree = context.node;
-    let openToken = tree.childAfter(tree.from), last = tree.lastChild;
-    if (!openToken)
-        return null;
-    let sim = context.options.simulateBreak;
-    let openLine = context.state.doc.lineAt(openToken.from);
-    let lineEnd = sim == null || sim <= openLine.from ? openLine.to : Math.min(openLine.to, sim);
-    for (let pos = openToken.to;;) {
-        let next = tree.childAfter(pos);
-        if (!next || next == last)
-            return null;
-        if (!next.type.isSkipped)
-            return next.from < lineEnd ? openToken : null;
-        pos = next.to;
-    }
-}
-function delimitedStrategy(context, align, units, closing, closedAt) {
-    let after = context.textAfter, space = after.match(/^\s*/)[0].length;
-    let closed = closing && after.slice(space, space + closing.length) == closing || closedAt == context.pos + space;
-    let aligned = align ? bracketedAligned(context) : null;
-    if (aligned)
-        return closed ? context.column(aligned.from) : context.column(aligned.to);
-    return context.baseIndent + (closed ? 0 : context.unit * units);
-}
 /**
 Creates an indentation strategy that, by default, indents
 continued lines one unit more than the node's base indentation.
@@ -974,58 +706,6 @@ function continuedIndent({ except, units = 1 } = {}) {
         return context.baseIndent + (matchExcept ? 0 : units * context.unit);
     };
 }
-const DontIndentBeyond = 200;
-/**
-Enables reindentation on input. When a language defines an
-`indentOnInput` field in its [language
-data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt), which must hold a regular
-expression, the line at the cursor will be reindented whenever new
-text is typed and the input from the start of the line up to the
-cursor matches that regexp.
-
-To avoid unneccesary reindents, it is recommended to start the
-regexp with `^` (usually followed by `\s*`), and end it with `$`.
-For example, `/^\s*\}$/` will reindent when a closing brace is
-added at the start of a line.
-*/
-function indentOnInput() {
-    return index.EditorState.transactionFilter.of(tr => {
-        if (!tr.docChanged || !tr.isUserEvent("input.type") && !tr.isUserEvent("input.complete"))
-            return tr;
-        let rules = tr.startState.languageDataAt("indentOnInput", tr.startState.selection.main.head);
-        if (!rules.length)
-            return tr;
-        let doc = tr.newDoc, { head } = tr.newSelection.main, line = doc.lineAt(head);
-        if (head > line.from + DontIndentBeyond)
-            return tr;
-        let lineStart = doc.sliceString(line.from, head);
-        if (!rules.some(r => r.test(lineStart)))
-            return tr;
-        let { state } = tr, last = -1, changes = [];
-        for (let { head } of state.selection.ranges) {
-            let line = state.doc.lineAt(head);
-            if (line.from == last)
-                continue;
-            last = line.from;
-            let indent = getIndentation(state, line.from);
-            if (indent == null)
-                continue;
-            let cur = /^\s*/.exec(line.text)[0];
-            let norm = indentString(state, indent);
-            if (cur != norm)
-                changes.push({ from: line.from, to: line.from + cur.length, insert: norm });
-        }
-        return changes.length ? [tr, { changes, sequential: true }] : tr;
-    });
-}
-
-/**
-A facet that registers a code folding service. When called with
-the extent of a line, such a function should return a foldable
-range that starts on that line (but continues beyond it), if one
-can be found.
-*/
-const foldService = /*@__PURE__*/index.Facet.define();
 /**
 This node prop is used to associate folding information with
 syntax node types. Given a syntax node, it should check whether
@@ -1042,693 +722,6 @@ function foldInside(node) {
     let first = node.firstChild, last = node.lastChild;
     return first && first.to < last.from ? { from: first.to, to: last.type.isError ? node.to : last.from } : null;
 }
-function syntaxFolding(state, start, end) {
-    let tree = syntaxTree(state);
-    if (tree.length < end)
-        return null;
-    let stack = tree.resolveStack(end, 1);
-    let found = null;
-    for (let iter = stack; iter; iter = iter.next) {
-        let cur = iter.node;
-        if (cur.to <= end || cur.from > end)
-            continue;
-        if (found && cur.from < start)
-            break;
-        let prop = cur.type.prop(foldNodeProp);
-        if (prop && (cur.to < tree.length - 50 || tree.length == state.doc.length || !isUnfinished(cur))) {
-            let value = prop(cur, state);
-            if (value && value.from <= end && value.from >= start && value.to > end)
-                found = value;
-        }
-    }
-    return found;
-}
-function isUnfinished(node) {
-    let ch = node.lastChild;
-    return ch && ch.to == node.to && ch.type.isError;
-}
-/**
-Check whether the given line is foldable. First asks any fold
-services registered through
-[`foldService`](https://codemirror.net/6/docs/ref/#language.foldService), and if none of them return
-a result, tries to query the [fold node
-prop](https://codemirror.net/6/docs/ref/#language.foldNodeProp) of syntax nodes that cover the end
-of the line.
-*/
-function foldable(state, lineStart, lineEnd) {
-    for (let service of state.facet(foldService)) {
-        let result = service(state, lineStart, lineEnd);
-        if (result)
-            return result;
-    }
-    return syntaxFolding(state, lineStart, lineEnd);
-}
-function mapRange(range, mapping) {
-    let from = mapping.mapPos(range.from, 1), to = mapping.mapPos(range.to, -1);
-    return from >= to ? undefined : { from, to };
-}
-/**
-State effect that can be attached to a transaction to fold the
-given range. (You probably only need this in exceptional
-circumstances—usually you'll just want to let
-[`foldCode`](https://codemirror.net/6/docs/ref/#language.foldCode) and the [fold
-gutter](https://codemirror.net/6/docs/ref/#language.foldGutter) create the transactions.)
-*/
-const foldEffect = /*@__PURE__*/index.StateEffect.define({ map: mapRange });
-/**
-State effect that unfolds the given range (if it was folded).
-*/
-const unfoldEffect = /*@__PURE__*/index.StateEffect.define({ map: mapRange });
-function selectedLines(view) {
-    let lines = [];
-    for (let { head } of view.state.selection.ranges) {
-        if (lines.some(l => l.from <= head && l.to >= head))
-            continue;
-        lines.push(view.lineBlockAt(head));
-    }
-    return lines;
-}
-/**
-The state field that stores the folded ranges (as a [decoration
-set](https://codemirror.net/6/docs/ref/#view.DecorationSet)). Can be passed to
-[`EditorState.toJSON`](https://codemirror.net/6/docs/ref/#state.EditorState.toJSON) and
-[`fromJSON`](https://codemirror.net/6/docs/ref/#state.EditorState^fromJSON) to serialize the fold
-state.
-*/
-const foldState = /*@__PURE__*/index.StateField.define({
-    create() {
-        return index$3.Decoration.none;
-    },
-    update(folded, tr) {
-        folded = folded.map(tr.changes);
-        for (let e of tr.effects) {
-            if (e.is(foldEffect) && !foldExists(folded, e.value.from, e.value.to)) {
-                let { preparePlaceholder } = tr.state.facet(foldConfig);
-                let widget = !preparePlaceholder ? foldWidget :
-                    index$3.Decoration.replace({ widget: new PreparedFoldWidget(preparePlaceholder(tr.state, e.value)) });
-                folded = folded.update({ add: [widget.range(e.value.from, e.value.to)] });
-            }
-            else if (e.is(unfoldEffect)) {
-                folded = folded.update({ filter: (from, to) => e.value.from != from || e.value.to != to,
-                    filterFrom: e.value.from, filterTo: e.value.to });
-            }
-        }
-        // Clear folded ranges that cover the selection head
-        if (tr.selection) {
-            let onSelection = false, { head } = tr.selection.main;
-            folded.between(head, head, (a, b) => { if (a < head && b > head)
-                onSelection = true; });
-            if (onSelection)
-                folded = folded.update({
-                    filterFrom: head,
-                    filterTo: head,
-                    filter: (a, b) => b <= head || a >= head
-                });
-        }
-        return folded;
-    },
-    provide: f => index$3.EditorView.decorations.from(f),
-    toJSON(folded, state) {
-        let ranges = [];
-        folded.between(0, state.doc.length, (from, to) => { ranges.push(from, to); });
-        return ranges;
-    },
-    fromJSON(value) {
-        if (!Array.isArray(value) || value.length % 2)
-            throw new RangeError("Invalid JSON for fold state");
-        let ranges = [];
-        for (let i = 0; i < value.length;) {
-            let from = value[i++], to = value[i++];
-            if (typeof from != "number" || typeof to != "number")
-                throw new RangeError("Invalid JSON for fold state");
-            ranges.push(foldWidget.range(from, to));
-        }
-        return index$3.Decoration.set(ranges, true);
-    }
-});
-function findFold(state, from, to) {
-    var _a;
-    let found = null;
-    (_a = state.field(foldState, false)) === null || _a === void 0 ? void 0 : _a.between(from, to, (from, to) => {
-        if (!found || found.from > from)
-            found = { from, to };
-    });
-    return found;
-}
-function foldExists(folded, from, to) {
-    let found = false;
-    folded.between(from, from, (a, b) => { if (a == from && b == to)
-        found = true; });
-    return found;
-}
-function maybeEnable(state, other) {
-    return state.field(foldState, false) ? other : other.concat(index.StateEffect.appendConfig.of(codeFolding()));
-}
-/**
-Fold the lines that are selected, if possible.
-*/
-const foldCode = view => {
-    for (let line of selectedLines(view)) {
-        let range = foldable(view.state, line.from, line.to);
-        if (range) {
-            view.dispatch({ effects: maybeEnable(view.state, [foldEffect.of(range), announceFold(view, range)]) });
-            return true;
-        }
-    }
-    return false;
-};
-/**
-Unfold folded ranges on selected lines.
-*/
-const unfoldCode = view => {
-    if (!view.state.field(foldState, false))
-        return false;
-    let effects = [];
-    for (let line of selectedLines(view)) {
-        let folded = findFold(view.state, line.from, line.to);
-        if (folded)
-            effects.push(unfoldEffect.of(folded), announceFold(view, folded, false));
-    }
-    if (effects.length)
-        view.dispatch({ effects });
-    return effects.length > 0;
-};
-function announceFold(view, range, fold = true) {
-    let lineFrom = view.state.doc.lineAt(range.from).number, lineTo = view.state.doc.lineAt(range.to).number;
-    return index$3.EditorView.announce.of(`${view.state.phrase(fold ? "Folded lines" : "Unfolded lines")} ${lineFrom} ${view.state.phrase("to")} ${lineTo}.`);
-}
-/**
-Fold all top-level foldable ranges. Note that, in most cases,
-folding information will depend on the [syntax
-tree](https://codemirror.net/6/docs/ref/#language.syntaxTree), and folding everything may not work
-reliably when the document hasn't been fully parsed (either
-because the editor state was only just initialized, or because the
-document is so big that the parser decided not to parse it
-entirely).
-*/
-const foldAll = view => {
-    let { state } = view, effects = [];
-    for (let pos = 0; pos < state.doc.length;) {
-        let line = view.lineBlockAt(pos), range = foldable(state, line.from, line.to);
-        if (range)
-            effects.push(foldEffect.of(range));
-        pos = (range ? view.lineBlockAt(range.to) : line).to + 1;
-    }
-    if (effects.length)
-        view.dispatch({ effects: maybeEnable(view.state, effects) });
-    return !!effects.length;
-};
-/**
-Unfold all folded code.
-*/
-const unfoldAll = view => {
-    let field = view.state.field(foldState, false);
-    if (!field || !field.size)
-        return false;
-    let effects = [];
-    field.between(0, view.state.doc.length, (from, to) => { effects.push(unfoldEffect.of({ from, to })); });
-    view.dispatch({ effects });
-    return true;
-};
-/**
-Default fold-related key bindings.
-
- - Ctrl-Shift-[ (Cmd-Alt-[ on macOS): [`foldCode`](https://codemirror.net/6/docs/ref/#language.foldCode).
- - Ctrl-Shift-] (Cmd-Alt-] on macOS): [`unfoldCode`](https://codemirror.net/6/docs/ref/#language.unfoldCode).
- - Ctrl-Alt-[: [`foldAll`](https://codemirror.net/6/docs/ref/#language.foldAll).
- - Ctrl-Alt-]: [`unfoldAll`](https://codemirror.net/6/docs/ref/#language.unfoldAll).
-*/
-const foldKeymap = [
-    { key: "Ctrl-Shift-[", mac: "Cmd-Alt-[", run: foldCode },
-    { key: "Ctrl-Shift-]", mac: "Cmd-Alt-]", run: unfoldCode },
-    { key: "Ctrl-Alt-[", run: foldAll },
-    { key: "Ctrl-Alt-]", run: unfoldAll }
-];
-const defaultConfig = {
-    placeholderDOM: null,
-    preparePlaceholder: null,
-    placeholderText: "…"
-};
-const foldConfig = /*@__PURE__*/index.Facet.define({
-    combine(values) { return index.combineConfig(values, defaultConfig); }
-});
-/**
-Create an extension that configures code folding.
-*/
-function codeFolding(config) {
-    let result = [foldState, baseTheme$1];
-    if (config)
-        result.push(foldConfig.of(config));
-    return result;
-}
-function widgetToDOM(view, prepared) {
-    let { state } = view, conf = state.facet(foldConfig);
-    let onclick = (event) => {
-        let line = view.lineBlockAt(view.posAtDOM(event.target));
-        let folded = findFold(view.state, line.from, line.to);
-        if (folded)
-            view.dispatch({ effects: unfoldEffect.of(folded) });
-        event.preventDefault();
-    };
-    if (conf.placeholderDOM)
-        return conf.placeholderDOM(view, onclick, prepared);
-    let element = document.createElement("span");
-    element.textContent = conf.placeholderText;
-    element.setAttribute("aria-label", state.phrase("folded code"));
-    element.title = state.phrase("unfold");
-    element.className = "cm-foldPlaceholder";
-    element.onclick = onclick;
-    return element;
-}
-const foldWidget = /*@__PURE__*/index$3.Decoration.replace({ widget: /*@__PURE__*/new class extends index$3.WidgetType {
-        toDOM(view) { return widgetToDOM(view, null); }
-    } });
-class PreparedFoldWidget extends index$3.WidgetType {
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    eq(other) { return this.value == other.value; }
-    toDOM(view) { return widgetToDOM(view, this.value); }
-}
-const foldGutterDefaults = {
-    openText: "⌄",
-    closedText: "›",
-    markerDOM: null,
-    domEventHandlers: {},
-    foldingChanged: () => false
-};
-class FoldMarker extends index$3.GutterMarker {
-    constructor(config, open) {
-        super();
-        this.config = config;
-        this.open = open;
-    }
-    eq(other) { return this.config == other.config && this.open == other.open; }
-    toDOM(view) {
-        if (this.config.markerDOM)
-            return this.config.markerDOM(this.open);
-        let span = document.createElement("span");
-        span.textContent = this.open ? this.config.openText : this.config.closedText;
-        span.title = view.state.phrase(this.open ? "Fold line" : "Unfold line");
-        return span;
-    }
-}
-/**
-Create an extension that registers a fold gutter, which shows a
-fold status indicator before foldable lines (which can be clicked
-to fold or unfold the line).
-*/
-function foldGutter(config = {}) {
-    let fullConfig = Object.assign(Object.assign({}, foldGutterDefaults), config);
-    let canFold = new FoldMarker(fullConfig, true), canUnfold = new FoldMarker(fullConfig, false);
-    let markers = index$3.ViewPlugin.fromClass(class {
-        constructor(view) {
-            this.from = view.viewport.from;
-            this.markers = this.buildMarkers(view);
-        }
-        update(update) {
-            if (update.docChanged || update.viewportChanged ||
-                update.startState.facet(language) != update.state.facet(language) ||
-                update.startState.field(foldState, false) != update.state.field(foldState, false) ||
-                syntaxTree(update.startState) != syntaxTree(update.state) ||
-                fullConfig.foldingChanged(update))
-                this.markers = this.buildMarkers(update.view);
-        }
-        buildMarkers(view) {
-            let builder = new index.RangeSetBuilder();
-            for (let line of view.viewportLineBlocks) {
-                let mark = findFold(view.state, line.from, line.to) ? canUnfold
-                    : foldable(view.state, line.from, line.to) ? canFold : null;
-                if (mark)
-                    builder.add(line.from, line.from, mark);
-            }
-            return builder.finish();
-        }
-    });
-    let { domEventHandlers } = fullConfig;
-    return [
-        markers,
-        index$3.gutter({
-            class: "cm-foldGutter",
-            markers(view) { var _a; return ((_a = view.plugin(markers)) === null || _a === void 0 ? void 0 : _a.markers) || index.RangeSet.empty; },
-            initialSpacer() {
-                return new FoldMarker(fullConfig, false);
-            },
-            domEventHandlers: Object.assign(Object.assign({}, domEventHandlers), { click: (view, line, event) => {
-                    if (domEventHandlers.click && domEventHandlers.click(view, line, event))
-                        return true;
-                    let folded = findFold(view.state, line.from, line.to);
-                    if (folded) {
-                        view.dispatch({ effects: unfoldEffect.of(folded) });
-                        return true;
-                    }
-                    let range = foldable(view.state, line.from, line.to);
-                    if (range) {
-                        view.dispatch({ effects: foldEffect.of(range) });
-                        return true;
-                    }
-                    return false;
-                } })
-        }),
-        codeFolding()
-    ];
-}
-const baseTheme$1 = /*@__PURE__*/index$3.EditorView.baseTheme({
-    ".cm-foldPlaceholder": {
-        backgroundColor: "#eee",
-        border: "1px solid #ddd",
-        color: "#888",
-        borderRadius: ".2em",
-        margin: "0 1px",
-        padding: "0 1px",
-        cursor: "pointer"
-    },
-    ".cm-foldGutter span": {
-        padding: "0 1px",
-        cursor: "pointer"
-    }
-});
-
-/**
-A highlight style associates CSS styles with higlighting
-[tags](https://lezer.codemirror.net/docs/ref#highlight.Tag).
-*/
-class HighlightStyle {
-    constructor(
-    /**
-    The tag styles used to create this highlight style.
-    */
-    specs, options) {
-        this.specs = specs;
-        let modSpec;
-        function def(spec) {
-            let cls = styleMod.StyleModule.newName();
-            (modSpec || (modSpec = Object.create(null)))["." + cls] = spec;
-            return cls;
-        }
-        const all = typeof options.all == "string" ? options.all : options.all ? def(options.all) : undefined;
-        const scopeOpt = options.scope;
-        this.scope = scopeOpt instanceof Language ? (type) => type.prop(languageDataProp) == scopeOpt.data
-            : scopeOpt ? (type) => type == scopeOpt : undefined;
-        this.style = index$1.tagHighlighter(specs.map(style => ({
-            tag: style.tag,
-            class: style.class || def(Object.assign({}, style, { tag: null }))
-        })), {
-            all,
-        }).style;
-        this.module = modSpec ? new styleMod.StyleModule(modSpec) : null;
-        this.themeType = options.themeType;
-    }
-    /**
-    Create a highlighter style that associates the given styles to
-    the given tags. The specs must be objects that hold a style tag
-    or array of tags in their `tag` property, and either a single
-    `class` property providing a static CSS class (for highlighter
-    that rely on external styling), or a
-    [`style-mod`](https://github.com/marijnh/style-mod#documentation)-style
-    set of CSS properties (which define the styling for those tags).
-    
-    The CSS rules created for a highlighter will be emitted in the
-    order of the spec's properties. That means that for elements that
-    have multiple tags associated with them, styles defined further
-    down in the list will have a higher CSS precedence than styles
-    defined earlier.
-    */
-    static define(specs, options) {
-        return new HighlightStyle(specs, options || {});
-    }
-}
-const highlighterFacet = /*@__PURE__*/index.Facet.define();
-const fallbackHighlighter = /*@__PURE__*/index.Facet.define({
-    combine(values) { return values.length ? [values[0]] : null; }
-});
-function getHighlighters(state) {
-    let main = state.facet(highlighterFacet);
-    return main.length ? main : state.facet(fallbackHighlighter);
-}
-/**
-Wrap a highlighter in an editor extension that uses it to apply
-syntax highlighting to the editor content.
-
-When multiple (non-fallback) styles are provided, the styling
-applied is the union of the classes they emit.
-*/
-function syntaxHighlighting(highlighter, options) {
-    let ext = [treeHighlighter], themeType;
-    if (highlighter instanceof HighlightStyle) {
-        if (highlighter.module)
-            ext.push(index$3.EditorView.styleModule.of(highlighter.module));
-        themeType = highlighter.themeType;
-    }
-    if (options === null || options === void 0 ? void 0 : options.fallback)
-        ext.push(fallbackHighlighter.of(highlighter));
-    else if (themeType)
-        ext.push(highlighterFacet.computeN([index$3.EditorView.darkTheme], state => {
-            return state.facet(index$3.EditorView.darkTheme) == (themeType == "dark") ? [highlighter] : [];
-        }));
-    else
-        ext.push(highlighterFacet.of(highlighter));
-    return ext;
-}
-class TreeHighlighter {
-    constructor(view) {
-        this.markCache = Object.create(null);
-        this.tree = syntaxTree(view.state);
-        this.decorations = this.buildDeco(view, getHighlighters(view.state));
-    }
-    update(update) {
-        let tree = syntaxTree(update.state), highlighters = getHighlighters(update.state);
-        let styleChange = highlighters != getHighlighters(update.startState);
-        if (tree.length < update.view.viewport.to && !styleChange && tree.type == this.tree.type) {
-            this.decorations = this.decorations.map(update.changes);
-        }
-        else if (tree != this.tree || update.viewportChanged || styleChange) {
-            this.tree = tree;
-            this.decorations = this.buildDeco(update.view, highlighters);
-        }
-    }
-    buildDeco(view, highlighters) {
-        if (!highlighters || !this.tree.length)
-            return index$3.Decoration.none;
-        let builder = new index.RangeSetBuilder();
-        for (let { from, to } of view.visibleRanges) {
-            index$1.highlightTree(this.tree, highlighters, (from, to, style) => {
-                builder.add(from, to, this.markCache[style] || (this.markCache[style] = index$3.Decoration.mark({ class: style })));
-            }, from, to);
-        }
-        return builder.finish();
-    }
-}
-const treeHighlighter = /*@__PURE__*/index.Prec.high(/*@__PURE__*/index$3.ViewPlugin.fromClass(TreeHighlighter, {
-    decorations: v => v.decorations
-}));
-/**
-A default highlight style (works well with light themes).
-*/
-const defaultHighlightStyle = /*@__PURE__*/HighlightStyle.define([
-    { tag: index$1.tags.meta,
-        color: "#404740" },
-    { tag: index$1.tags.link,
-        textDecoration: "underline" },
-    { tag: index$1.tags.heading,
-        textDecoration: "underline",
-        fontWeight: "bold" },
-    { tag: index$1.tags.emphasis,
-        fontStyle: "italic" },
-    { tag: index$1.tags.strong,
-        fontWeight: "bold" },
-    { tag: index$1.tags.strikethrough,
-        textDecoration: "line-through" },
-    { tag: index$1.tags.keyword,
-        color: "#708" },
-    { tag: [index$1.tags.atom, index$1.tags.bool, index$1.tags.url, index$1.tags.contentSeparator, index$1.tags.labelName],
-        color: "#219" },
-    { tag: [index$1.tags.literal, index$1.tags.inserted],
-        color: "#164" },
-    { tag: [index$1.tags.string, index$1.tags.deleted],
-        color: "#a11" },
-    { tag: [index$1.tags.regexp, index$1.tags.escape, /*@__PURE__*/index$1.tags.special(index$1.tags.string)],
-        color: "#e40" },
-    { tag: /*@__PURE__*/index$1.tags.definition(index$1.tags.variableName),
-        color: "#00f" },
-    { tag: /*@__PURE__*/index$1.tags.local(index$1.tags.variableName),
-        color: "#30a" },
-    { tag: [index$1.tags.typeName, index$1.tags.namespace],
-        color: "#085" },
-    { tag: index$1.tags.className,
-        color: "#167" },
-    { tag: [/*@__PURE__*/index$1.tags.special(index$1.tags.variableName), index$1.tags.macroName],
-        color: "#256" },
-    { tag: /*@__PURE__*/index$1.tags.definition(index$1.tags.propertyName),
-        color: "#00c" },
-    { tag: index$1.tags.comment,
-        color: "#940" },
-    { tag: index$1.tags.invalid,
-        color: "#f00" }
-]);
-
-const baseTheme = /*@__PURE__*/index$3.EditorView.baseTheme({
-    "&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
-    "&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
-});
-const DefaultScanDist = 10000, DefaultBrackets = "()[]{}";
-const bracketMatchingConfig = /*@__PURE__*/index.Facet.define({
-    combine(configs) {
-        return index.combineConfig(configs, {
-            afterCursor: true,
-            brackets: DefaultBrackets,
-            maxScanDistance: DefaultScanDist,
-            renderMatch: defaultRenderMatch
-        });
-    }
-});
-const matchingMark = /*@__PURE__*/index$3.Decoration.mark({ class: "cm-matchingBracket" }), nonmatchingMark = /*@__PURE__*/index$3.Decoration.mark({ class: "cm-nonmatchingBracket" });
-function defaultRenderMatch(match) {
-    let decorations = [];
-    let mark = match.matched ? matchingMark : nonmatchingMark;
-    decorations.push(mark.range(match.start.from, match.start.to));
-    if (match.end)
-        decorations.push(mark.range(match.end.from, match.end.to));
-    return decorations;
-}
-const bracketMatchingState = /*@__PURE__*/index.StateField.define({
-    create() { return index$3.Decoration.none; },
-    update(deco, tr) {
-        if (!tr.docChanged && !tr.selection)
-            return deco;
-        let decorations = [];
-        let config = tr.state.facet(bracketMatchingConfig);
-        for (let range of tr.state.selection.ranges) {
-            if (!range.empty)
-                continue;
-            let match = matchBrackets(tr.state, range.head, -1, config)
-                || (range.head > 0 && matchBrackets(tr.state, range.head - 1, 1, config))
-                || (config.afterCursor &&
-                    (matchBrackets(tr.state, range.head, 1, config) ||
-                        (range.head < tr.state.doc.length && matchBrackets(tr.state, range.head + 1, -1, config))));
-            if (match)
-                decorations = decorations.concat(config.renderMatch(match, tr.state));
-        }
-        return index$3.Decoration.set(decorations, true);
-    },
-    provide: f => index$3.EditorView.decorations.from(f)
-});
-const bracketMatchingUnique = [
-    bracketMatchingState,
-    baseTheme
-];
-/**
-Create an extension that enables bracket matching. Whenever the
-cursor is next to a bracket, that bracket and the one it matches
-are highlighted. Or, when no matching bracket is found, another
-highlighting style is used to indicate this.
-*/
-function bracketMatching(config = {}) {
-    return [bracketMatchingConfig.of(config), bracketMatchingUnique];
-}
-/**
-When larger syntax nodes, such as HTML tags, are marked as
-opening/closing, it can be a bit messy to treat the whole node as
-a matchable bracket. This node prop allows you to define, for such
-a node, a ‘handle’—the part of the node that is highlighted, and
-that the cursor must be on to activate highlighting in the first
-place.
-*/
-const bracketMatchingHandle = /*@__PURE__*/new index$2.NodeProp();
-function matchingNodes(node, dir, brackets) {
-    let byProp = node.prop(dir < 0 ? index$2.NodeProp.openedBy : index$2.NodeProp.closedBy);
-    if (byProp)
-        return byProp;
-    if (node.name.length == 1) {
-        let index = brackets.indexOf(node.name);
-        if (index > -1 && index % 2 == (dir < 0 ? 1 : 0))
-            return [brackets[index + dir]];
-    }
-    return null;
-}
-function findHandle(node) {
-    let hasHandle = node.type.prop(bracketMatchingHandle);
-    return hasHandle ? hasHandle(node.node) : node;
-}
-/**
-Find the matching bracket for the token at `pos`, scanning
-direction `dir`. Only the `brackets` and `maxScanDistance`
-properties are used from `config`, if given. Returns null if no
-bracket was found at `pos`, or a match result otherwise.
-*/
-function matchBrackets(state, pos, dir, config = {}) {
-    let maxScanDistance = config.maxScanDistance || DefaultScanDist, brackets = config.brackets || DefaultBrackets;
-    let tree = syntaxTree(state), node = tree.resolveInner(pos, dir);
-    for (let cur = node; cur; cur = cur.parent) {
-        let matches = matchingNodes(cur.type, dir, brackets);
-        if (matches && cur.from < cur.to) {
-            let handle = findHandle(cur);
-            if (handle && (dir > 0 ? pos >= handle.from && pos < handle.to : pos > handle.from && pos <= handle.to))
-                return matchMarkedBrackets(state, pos, dir, cur, handle, matches, brackets);
-        }
-    }
-    return matchPlainBrackets(state, pos, dir, tree, node.type, maxScanDistance, brackets);
-}
-function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, brackets) {
-    let parent = token.parent, firstToken = { from: handle.from, to: handle.to };
-    let depth = 0, cursor = parent === null || parent === void 0 ? void 0 : parent.cursor();
-    if (cursor && (dir < 0 ? cursor.childBefore(token.from) : cursor.childAfter(token.to)))
-        do {
-            if (dir < 0 ? cursor.to <= token.from : cursor.from >= token.to) {
-                if (depth == 0 && matching.indexOf(cursor.type.name) > -1 && cursor.from < cursor.to) {
-                    let endHandle = findHandle(cursor);
-                    return { start: firstToken, end: endHandle ? { from: endHandle.from, to: endHandle.to } : undefined, matched: true };
-                }
-                else if (matchingNodes(cursor.type, dir, brackets)) {
-                    depth++;
-                }
-                else if (matchingNodes(cursor.type, -dir, brackets)) {
-                    if (depth == 0) {
-                        let endHandle = findHandle(cursor);
-                        return {
-                            start: firstToken,
-                            end: endHandle && endHandle.from < endHandle.to ? { from: endHandle.from, to: endHandle.to } : undefined,
-                            matched: false
-                        };
-                    }
-                    depth--;
-                }
-            }
-        } while (dir < 0 ? cursor.prevSibling() : cursor.nextSibling());
-    return { start: firstToken, matched: false };
-}
-function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, brackets) {
-    let startCh = dir < 0 ? state.sliceDoc(pos - 1, pos) : state.sliceDoc(pos, pos + 1);
-    let bracket = brackets.indexOf(startCh);
-    if (bracket < 0 || (bracket % 2 == 0) != (dir > 0))
-        return null;
-    let startToken = { from: dir < 0 ? pos - 1 : pos, to: dir > 0 ? pos + 1 : pos };
-    let iter = state.doc.iterRange(pos, dir > 0 ? state.doc.length : 0), depth = 0;
-    for (let distance = 0; !(iter.next()).done && distance <= maxScanDistance;) {
-        let text = iter.value;
-        if (dir < 0)
-            distance += text.length;
-        let basePos = pos + distance * dir;
-        for (let pos = dir > 0 ? 0 : text.length - 1, end = dir > 0 ? text.length : -1; pos != end; pos += dir) {
-            let found = brackets.indexOf(text[pos]);
-            if (found < 0 || tree.resolveInner(basePos + pos, 1).type != tokenType)
-                continue;
-            if ((found % 2 == 0) == (dir > 0)) {
-                depth++;
-            }
-            else if (depth == 1) { // Closing
-                return { start: startToken, end: { from: basePos + pos, to: basePos + pos + 1 }, matched: (found >> 1) == (bracket >> 1) };
-            }
-            else {
-                depth--;
-            }
-        }
-        if (dir > 0)
-            distance += text.length;
-    }
-    return iter.done ? { start: startToken, matched: false } : null;
-}
 const noTokens = /*@__PURE__*/Object.create(null);
 const typeArray = [index$2.NodeType.none];
 const warned = [];
@@ -1797,43 +790,20 @@ function createTokenType(extra, tagStr) {
 }
 
 exports.DocInput = DocInput;
-exports.HighlightStyle = HighlightStyle;
-exports.IndentContext = IndentContext;
 exports.LRLanguage = LRLanguage;
 exports.Language = Language;
 exports.LanguageSupport = LanguageSupport;
 exports.ParseContext = ParseContext;
-exports.TreeIndentContext = TreeIndentContext;
-exports.bracketMatching = bracketMatching;
-exports.bracketMatchingHandle = bracketMatchingHandle;
-exports.codeFolding = codeFolding;
 exports.continuedIndent = continuedIndent;
-exports.defaultHighlightStyle = defaultHighlightStyle;
 exports.defineLanguageFacet = defineLanguageFacet;
-exports.foldAll = foldAll;
-exports.foldCode = foldCode;
-exports.foldEffect = foldEffect;
-exports.foldGutter = foldGutter;
 exports.foldInside = foldInside;
-exports.foldKeymap = foldKeymap;
 exports.foldNodeProp = foldNodeProp;
-exports.foldService = foldService;
-exports.foldState = foldState;
-exports.foldable = foldable;
 exports.getIndentUnit = getIndentUnit;
-exports.getIndentation = getIndentation;
 exports.indentNodeProp = indentNodeProp;
-exports.indentOnInput = indentOnInput;
-exports.indentService = indentService;
 exports.indentString = indentString;
 exports.indentUnit = indentUnit;
 exports.language = language;
 exports.languageDataProp = languageDataProp;
-exports.matchBrackets = matchBrackets;
 exports.sublanguageProp = sublanguageProp;
-exports.syntaxHighlighting = syntaxHighlighting;
 exports.syntaxTree = syntaxTree;
-exports.unfoldAll = unfoldAll;
-exports.unfoldCode = unfoldCode;
-exports.unfoldEffect = unfoldEffect;
 //# sourceMappingURL=index.js.map