@vuu-ui/vuu-codemirror 0.8.34 → 0.8.36

package/cjs/node_modules/@codemirror/language/dist/index.js

@@ -1,1308 +0,0 @@
-'use strict';
-
-var index = require('../../../@lezer/common/dist/index.js');
-var index$1 = require('../../state/dist/index.js');
-var index$2 = require('../../view/dist/index.js');
-var highlight = require('@lezer/highlight');
-var styleMod = require('../../../style-mod/src/style-mod.js');
-
-var _a;
-/**
-Node prop stored in a parser's top syntax node to provide the
-facet that stores language-specific data for that language.
-*/
-const languageDataProp = /*@__PURE__*/new index.NodeProp();
-/**
-Helper function to define a facet (to be added to the top syntax
-node(s) for a language via
-[`languageDataProp`](https://codemirror.net/6/docs/ref/#language.languageDataProp)), that will be
-used to associate language data with the language. You
-probably only need this when subclassing
-[`Language`](https://codemirror.net/6/docs/ref/#language.Language).
-*/
-function defineLanguageFacet(baseData) {
-    return index$1.Facet.define({
-        combine: baseData ? values => values.concat(baseData) : undefined
-    });
-}
-/**
-Syntax node prop used to register sublanguages. Should be added to
-the top level node type for the language.
-*/
-const sublanguageProp = /*@__PURE__*/new index.NodeProp();
-/**
-A language object manages parsing and per-language
-[metadata](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt). Parse data is
-managed as a [Lezer](https://lezer.codemirror.net) tree. The class
-can be used directly, via the [`LRLanguage`](https://codemirror.net/6/docs/ref/#language.LRLanguage)
-subclass for [Lezer](https://lezer.codemirror.net/) LR parsers, or
-via the [`StreamLanguage`](https://codemirror.net/6/docs/ref/#language.StreamLanguage) subclass
-for stream parsers.
-*/
-class Language {
-    /**
-    Construct a language object. If you need to invoke this
-    directly, first define a data facet with
-    [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet), and then
-    configure your parser to [attach](https://codemirror.net/6/docs/ref/#language.languageDataProp) it
-    to the language's outer syntax node.
-    */
-    constructor(
-    /**
-    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) facet
-    used for this language.
-    */
-    data, parser, extraExtensions = [], 
-    /**
-    A language name.
-    */
-    name = "") {
-        this.data = data;
-        this.name = name;
-        // Kludge to define EditorState.tree as a debugging helper,
-        // without the EditorState package actually knowing about
-        // languages and lezer trees.
-        if (!index$1.EditorState.prototype.hasOwnProperty("tree"))
-            Object.defineProperty(index$1.EditorState.prototype, "tree", { get() { return syntaxTree(this); } });
-        this.parser = parser;
-        this.extension = [
-            language.of(this),
-            index$1.EditorState.languageData.of((state, pos, side) => {
-                let top = topNodeAt(state, pos, side), data = top.type.prop(languageDataProp);
-                if (!data)
-                    return [];
-                let base = state.facet(data), sub = top.type.prop(sublanguageProp);
-                if (sub) {
-                    let innerNode = top.resolve(pos - top.from, side);
-                    for (let sublang of sub)
-                        if (sublang.test(innerNode, state)) {
-                            let data = state.facet(sublang.facet);
-                            return sublang.type == "replace" ? data : data.concat(base);
-                        }
-                }
-                return base;
-            })
-        ].concat(extraExtensions);
-    }
-    /**
-    Query whether this language is active at the given position.
-    */
-    isActiveAt(state, pos, side = -1) {
-        return topNodeAt(state, pos, side).type.prop(languageDataProp) == this.data;
-    }
-    /**
-    Find the document regions that were parsed using this language.
-    The returned regions will _include_ any nested languages rooted
-    in this language, when those exist.
-    */
-    findRegions(state) {
-        let lang = state.facet(language);
-        if ((lang === null || lang === void 0 ? void 0 : lang.data) == this.data)
-            return [{ from: 0, to: state.doc.length }];
-        if (!lang || !lang.allowsNesting)
-            return [];
-        let result = [];
-        let explore = (tree, from) => {
-            if (tree.prop(languageDataProp) == this.data) {
-                result.push({ from, to: from + tree.length });
-                return;
-            }
-            let mount = tree.prop(index.NodeProp.mounted);
-            if (mount) {
-                if (mount.tree.prop(languageDataProp) == this.data) {
-                    if (mount.overlay)
-                        for (let r of mount.overlay)
-                            result.push({ from: r.from + from, to: r.to + from });
-                    else
-                        result.push({ from: from, to: from + tree.length });
-                    return;
-                }
-                else if (mount.overlay) {
-                    let size = result.length;
-                    explore(mount.tree, mount.overlay[0].from + from);
-                    if (result.length > size)
-                        return;
-                }
-            }
-            for (let i = 0; i < tree.children.length; i++) {
-                let ch = tree.children[i];
-                if (ch instanceof index.Tree)
-                    explore(ch, tree.positions[i] + from);
-            }
-        };
-        explore(syntaxTree(state), 0);
-        return result;
-    }
-    /**
-    Indicates whether this language allows nested languages. The
-    default implementation returns true.
-    */
-    get allowsNesting() { return true; }
-}
-/**
-@internal
-*/
-Language.setState = /*@__PURE__*/index$1.StateEffect.define();
-function topNodeAt(state, pos, side) {
-    let topLang = state.facet(language), tree = syntaxTree(state).topNode;
-    if (!topLang || topLang.allowsNesting) {
-        for (let node = tree; node; node = node.enter(pos, side, index.IterMode.ExcludeBuffers))
-            if (node.type.isTop)
-                tree = node;
-    }
-    return tree;
-}
-/**
-A subclass of [`Language`](https://codemirror.net/6/docs/ref/#language.Language) for use with Lezer
-[LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser)
-parsers.
-*/
-class LRLanguage extends Language {
-    constructor(data, parser, name) {
-        super(data, parser, [], name);
-        this.parser = parser;
-    }
-    /**
-    Define a language from a parser.
-    */
-    static define(spec) {
-        let data = defineLanguageFacet(spec.languageData);
-        return new LRLanguage(data, spec.parser.configure({
-            props: [languageDataProp.add(type => type.isTop ? data : undefined)]
-        }), spec.name);
-    }
-    /**
-    Create a new instance of this language with a reconfigured
-    version of its parser and optionally a new name.
-    */
-    configure(options, name) {
-        return new LRLanguage(this.data, this.parser.configure(options), name || this.name);
-    }
-    get allowsNesting() { return this.parser.hasWrappers(); }
-}
-/**
-Get the syntax tree for a state, which is the current (possibly
-incomplete) parse tree of the active
-[language](https://codemirror.net/6/docs/ref/#language.Language), or the empty tree if there is no
-language available.
-*/
-function syntaxTree(state) {
-    let field = state.field(Language.state, false);
-    return field ? field.tree : index.Tree.empty;
-}
-/**
-Try to get a parse tree that spans at least up to `upto`. The
-method will do at most `timeout` milliseconds of work to parse
-up to that point if the tree isn't already available.
-*/
-function ensureSyntaxTree(state, upto, timeout = 50) {
-    var _a;
-    let parse = (_a = state.field(Language.state, false)) === null || _a === void 0 ? void 0 : _a.context;
-    if (!parse)
-        return null;
-    let oldVieport = parse.viewport;
-    parse.updateViewport({ from: 0, to: upto });
-    let result = parse.isDone(upto) || parse.work(timeout, upto) ? parse.tree : null;
-    parse.updateViewport(oldVieport);
-    return result;
-}
-/**
-Lezer-style
-[`Input`](https://lezer.codemirror.net/docs/ref#common.Input)
-object for a [`Text`](https://codemirror.net/6/docs/ref/#state.Text) object.
-*/
-class DocInput {
-    /**
-    Create an input object for the given document.
-    */
-    constructor(doc) {
-        this.doc = doc;
-        this.cursorPos = 0;
-        this.string = "";
-        this.cursor = doc.iter();
-    }
-    get length() { return this.doc.length; }
-    syncTo(pos) {
-        this.string = this.cursor.next(pos - this.cursorPos).value;
-        this.cursorPos = pos + this.string.length;
-        return this.cursorPos - this.string.length;
-    }
-    chunk(pos) {
-        this.syncTo(pos);
-        return this.string;
-    }
-    get lineChunks() { return true; }
-    read(from, to) {
-        let stringStart = this.cursorPos - this.string.length;
-        if (from < stringStart || to >= this.cursorPos)
-            return this.doc.sliceString(from, to);
-        else
-            return this.string.slice(from - stringStart, to - stringStart);
-    }
-}
-let currentContext = null;
-/**
-A parse context provided to parsers working on the editor content.
-*/
-class ParseContext {
-    constructor(parser, 
-    /**
-    The current editor state.
-    */
-    state, 
-    /**
-    Tree fragments that can be reused by incremental re-parses.
-    */
-    fragments = [], 
-    /**
-    @internal
-    */
-    tree, 
-    /**
-    @internal
-    */
-    treeLen, 
-    /**
-    The current editor viewport (or some overapproximation
-    thereof). Intended to be used for opportunistically avoiding
-    work (in which case
-    [`skipUntilInView`](https://codemirror.net/6/docs/ref/#language.ParseContext.skipUntilInView)
-    should be called to make sure the parser is restarted when the
-    skipped region becomes visible).
-    */
-    viewport, 
-    /**
-    @internal
-    */
-    skipped, 
-    /**
-    This is where skipping parsers can register a promise that,
-    when resolved, will schedule a new parse. It is cleared when
-    the parse worker picks up the promise. @internal
-    */
-    scheduleOn) {
-        this.parser = parser;
-        this.state = state;
-        this.fragments = fragments;
-        this.tree = tree;
-        this.treeLen = treeLen;
-        this.viewport = viewport;
-        this.skipped = skipped;
-        this.scheduleOn = scheduleOn;
-        this.parse = null;
-        /**
-        @internal
-        */
-        this.tempSkipped = [];
-    }
-    /**
-    @internal
-    */
-    static create(parser, state, viewport) {
-        return new ParseContext(parser, state, [], index.Tree.empty, 0, viewport, [], null);
-    }
-    startParse() {
-        return this.parser.startParse(new DocInput(this.state.doc), this.fragments);
-    }
-    /**
-    @internal
-    */
-    work(until, upto) {
-        if (upto != null && upto >= this.state.doc.length)
-            upto = undefined;
-        if (this.tree != index.Tree.empty && this.isDone(upto !== null && upto !== void 0 ? upto : this.state.doc.length)) {
-            this.takeTree();
-            return true;
-        }
-        return this.withContext(() => {
-            var _a;
-            if (typeof until == "number") {
-                let endTime = Date.now() + until;
-                until = () => Date.now() > endTime;
-            }
-            if (!this.parse)
-                this.parse = this.startParse();
-            if (upto != null && (this.parse.stoppedAt == null || this.parse.stoppedAt > upto) &&
-                upto < this.state.doc.length)
-                this.parse.stopAt(upto);
-            for (;;) {
-                let done = this.parse.advance();
-                if (done) {
-                    this.fragments = this.withoutTempSkipped(index.TreeFragment.addTree(done, this.fragments, this.parse.stoppedAt != null));
-                    this.treeLen = (_a = this.parse.stoppedAt) !== null && _a !== void 0 ? _a : this.state.doc.length;
-                    this.tree = done;
-                    this.parse = null;
-                    if (this.treeLen < (upto !== null && upto !== void 0 ? upto : this.state.doc.length))
-                        this.parse = this.startParse();
-                    else
-                        return true;
-                }
-                if (until())
-                    return false;
-            }
-        });
-    }
-    /**
-    @internal
-    */
-    takeTree() {
-        let pos, tree;
-        if (this.parse && (pos = this.parse.parsedPos) >= this.treeLen) {
-            if (this.parse.stoppedAt == null || this.parse.stoppedAt > pos)
-                this.parse.stopAt(pos);
-            this.withContext(() => { while (!(tree = this.parse.advance())) { } });
-            this.treeLen = pos;
-            this.tree = tree;
-            this.fragments = this.withoutTempSkipped(index.TreeFragment.addTree(this.tree, this.fragments, true));
-            this.parse = null;
-        }
-    }
-    withContext(f) {
-        let prev = currentContext;
-        currentContext = this;
-        try {
-            return f();
-        }
-        finally {
-            currentContext = prev;
-        }
-    }
-    withoutTempSkipped(fragments) {
-        for (let r; r = this.tempSkipped.pop();)
-            fragments = cutFragments(fragments, r.from, r.to);
-        return fragments;
-    }
-    /**
-    @internal
-    */
-    changes(changes, newState) {
-        let { fragments, tree, treeLen, viewport, skipped } = this;
-        this.takeTree();
-        if (!changes.empty) {
-            let ranges = [];
-            changes.iterChangedRanges((fromA, toA, fromB, toB) => ranges.push({ fromA, toA, fromB, toB }));
-            fragments = index.TreeFragment.applyChanges(fragments, ranges);
-            tree = index.Tree.empty;
-            treeLen = 0;
-            viewport = { from: changes.mapPos(viewport.from, -1), to: changes.mapPos(viewport.to, 1) };
-            if (this.skipped.length) {
-                skipped = [];
-                for (let r of this.skipped) {
-                    let from = changes.mapPos(r.from, 1), to = changes.mapPos(r.to, -1);
-                    if (from < to)
-                        skipped.push({ from, to });
-                }
-            }
-        }
-        return new ParseContext(this.parser, newState, fragments, tree, treeLen, viewport, skipped, this.scheduleOn);
-    }
-    /**
-    @internal
-    */
-    updateViewport(viewport) {
-        if (this.viewport.from == viewport.from && this.viewport.to == viewport.to)
-            return false;
-        this.viewport = viewport;
-        let startLen = this.skipped.length;
-        for (let i = 0; i < this.skipped.length; i++) {
-            let { from, to } = this.skipped[i];
-            if (from < viewport.to && to > viewport.from) {
-                this.fragments = cutFragments(this.fragments, from, to);
-                this.skipped.splice(i--, 1);
-            }
-        }
-        if (this.skipped.length >= startLen)
-            return false;
-        this.reset();
-        return true;
-    }
-    /**
-    @internal
-    */
-    reset() {
-        if (this.parse) {
-            this.takeTree();
-            this.parse = null;
-        }
-    }
-    /**
-    Notify the parse scheduler that the given region was skipped
-    because it wasn't in view, and the parse should be restarted
-    when it comes into view.
-    */
-    skipUntilInView(from, to) {
-        this.skipped.push({ from, to });
-    }
-    /**
-    Returns a parser intended to be used as placeholder when
-    asynchronously loading a nested parser. It'll skip its input and
-    mark it as not-really-parsed, so that the next update will parse
-    it again.
-    
-    When `until` is given, a reparse will be scheduled when that
-    promise resolves.
-    */
-    static getSkippingParser(until) {
-        return new class extends index.Parser {
-            createParse(input, fragments, ranges) {
-                let from = ranges[0].from, to = ranges[ranges.length - 1].to;
-                let parser = {
-                    parsedPos: from,
-                    advance() {
-                        let cx = currentContext;
-                        if (cx) {
-                            for (let r of ranges)
-                                cx.tempSkipped.push(r);
-                            if (until)
-                                cx.scheduleOn = cx.scheduleOn ? Promise.all([cx.scheduleOn, until]) : until;
-                        }
-                        this.parsedPos = to;
-                        return new index.Tree(index.NodeType.none, [], [], to - from);
-                    },
-                    stoppedAt: null,
-                    stopAt() { }
-                };
-                return parser;
-            }
-        };
-    }
-    /**
-    @internal
-    */
-    isDone(upto) {
-        upto = Math.min(upto, this.state.doc.length);
-        let frags = this.fragments;
-        return this.treeLen >= upto && frags.length && frags[0].from == 0 && frags[0].to >= upto;
-    }
-    /**
-    Get the context for the current parse, or `null` if no editor
-    parse is in progress.
-    */
-    static get() { return currentContext; }
-}
-function cutFragments(fragments, from, to) {
-    return index.TreeFragment.applyChanges(fragments, [{ fromA: from, toA: to, fromB: from, toB: to }]);
-}
-class LanguageState {
-    constructor(
-    // A mutable parse state that is used to preserve work done during
-    // the lifetime of a state when moving to the next state.
-    context) {
-        this.context = context;
-        this.tree = context.tree;
-    }
-    apply(tr) {
-        if (!tr.docChanged && this.tree == this.context.tree)
-            return this;
-        let newCx = this.context.changes(tr.changes, tr.state);
-        // If the previous parse wasn't done, go forward only up to its
-        // end position or the end of the viewport, to avoid slowing down
-        // state updates with parse work beyond the viewport.
-        let upto = this.context.treeLen == tr.startState.doc.length ? undefined
-            : Math.max(tr.changes.mapPos(this.context.treeLen), newCx.viewport.to);
-        if (!newCx.work(20 /* Apply */, upto))
-            newCx.takeTree();
-        return new LanguageState(newCx);
-    }
-    static init(state) {
-        let vpTo = Math.min(3000 /* InitViewport */, state.doc.length);
-        let parseState = ParseContext.create(state.facet(language).parser, state, { from: 0, to: vpTo });
-        if (!parseState.work(20 /* Apply */, vpTo))
-            parseState.takeTree();
-        return new LanguageState(parseState);
-    }
-}
-Language.state = /*@__PURE__*/index$1.StateField.define({
-    create: LanguageState.init,
-    update(value, tr) {
-        for (let e of tr.effects)
-            if (e.is(Language.setState))
-                return e.value;
-        if (tr.startState.facet(language) != tr.state.facet(language))
-            return LanguageState.init(tr.state);
-        return value.apply(tr);
-    }
-});
-let requestIdle = (callback) => {
-    let timeout = setTimeout(() => callback(), 500 /* MaxPause */);
-    return () => clearTimeout(timeout);
-};
-if (typeof requestIdleCallback != "undefined")
-    requestIdle = (callback) => {
-        let idle = -1, timeout = setTimeout(() => {
-            idle = requestIdleCallback(callback, { timeout: 500 /* MaxPause */ - 100 /* MinPause */ });
-        }, 100 /* MinPause */);
-        return () => idle < 0 ? clearTimeout(timeout) : cancelIdleCallback(idle);
-    };
-const isInputPending = typeof navigator != "undefined" && ((_a = navigator.scheduling) === null || _a === void 0 ? void 0 : _a.isInputPending)
-    ? () => navigator.scheduling.isInputPending() : null;
-const parseWorker = /*@__PURE__*/index$2.ViewPlugin.fromClass(class ParseWorker {
-    constructor(view) {
-        this.view = view;
-        this.working = null;
-        this.workScheduled = 0;
-        // End of the current time chunk
-        this.chunkEnd = -1;
-        // Milliseconds of budget left for this chunk
-        this.chunkBudget = -1;
-        this.work = this.work.bind(this);
-        this.scheduleWork();
-    }
-    update(update) {
-        let cx = this.view.state.field(Language.state).context;
-        if (cx.updateViewport(update.view.viewport) || this.view.viewport.to > cx.treeLen)
-            this.scheduleWork();
-        if (update.docChanged) {
-            if (this.view.hasFocus)
-                this.chunkBudget += 50 /* ChangeBonus */;
-            this.scheduleWork();
-        }
-        this.checkAsyncSchedule(cx);
-    }
-    scheduleWork() {
-        if (this.working)
-            return;
-        let { state } = this.view, field = state.field(Language.state);
-        if (field.tree != field.context.tree || !field.context.isDone(state.doc.length))
-            this.working = requestIdle(this.work);
-    }
-    work(deadline) {
-        this.working = null;
-        let now = Date.now();
-        if (this.chunkEnd < now && (this.chunkEnd < 0 || this.view.hasFocus)) { // Start a new chunk
-            this.chunkEnd = now + 30000 /* ChunkTime */;
-            this.chunkBudget = 3000 /* ChunkBudget */;
-        }
-        if (this.chunkBudget <= 0)
-            return; // No more budget
-        let { state, viewport: { to: vpTo } } = this.view, field = state.field(Language.state);
-        if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* MaxParseAhead */))
-            return;
-        let endTime = Date.now() + Math.min(this.chunkBudget, 100 /* Slice */, deadline && !isInputPending ? Math.max(25 /* MinSlice */, deadline.timeRemaining() - 5) : 1e9);
-        let viewportFirst = field.context.treeLen < vpTo && state.doc.length > vpTo + 1000;
-        let done = field.context.work(() => {
-            return isInputPending && isInputPending() || Date.now() > endTime;
-        }, vpTo + (viewportFirst ? 0 : 100000 /* MaxParseAhead */));
-        this.chunkBudget -= Date.now() - now;
-        if (done || this.chunkBudget <= 0) {
-            field.context.takeTree();
-            this.view.dispatch({ effects: Language.setState.of(new LanguageState(field.context)) });
-        }
-        if (this.chunkBudget > 0 && !(done && !viewportFirst))
-            this.scheduleWork();
-        this.checkAsyncSchedule(field.context);
-    }
-    checkAsyncSchedule(cx) {
-        if (cx.scheduleOn) {
-            this.workScheduled++;
-            cx.scheduleOn
-                .then(() => this.scheduleWork())
-                .catch(err => index$2.logException(this.view.state, err))
-                .then(() => this.workScheduled--);
-            cx.scheduleOn = null;
-        }
-    }
-    destroy() {
-        if (this.working)
-            this.working();
-    }
-    isWorking() {
-        return !!(this.working || this.workScheduled > 0);
-    }
-}, {
-    eventHandlers: { focus() { this.scheduleWork(); } }
-});
-/**
-The facet used to associate a language with an editor state. Used
-by `Language` object's `extension` property (so you don't need to
-manually wrap your languages in this). Can be used to access the
-current language on a state.
-*/
-const language = /*@__PURE__*/index$1.Facet.define({
-    combine(languages) { return languages.length ? languages[0] : null; },
-    enables: language => [
-        Language.state,
-        parseWorker,
-        index$2.EditorView.contentAttributes.compute([language], state => {
-            let lang = state.facet(language);
-            return lang && lang.name ? { "data-language": lang.name } : {};
-        })
-    ]
-});
-/**
-This class bundles a [language](https://codemirror.net/6/docs/ref/#language.Language) with an
-optional set of supporting extensions. Language packages are
-encouraged to export a function that optionally takes a
-configuration object and returns a `LanguageSupport` instance, as
-the main way for client code to use the package.
-*/
-class LanguageSupport {
-    /**
-    Create a language support object.
-    */
-    constructor(
-    /**
-    The language object.
-    */
-    language, 
-    /**
-    An optional set of supporting extensions. When nesting a
-    language in another language, the outer language is encouraged
-    to include the supporting extensions for its inner languages
-    in its own set of support extensions.
-    */
-    support = []) {
-        this.language = language;
-        this.support = support;
-        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$1.Facet.define();
-/**
-Facet for overriding the unit by which indentation happens. Should
-be a string consisting either entirely of the same whitespace
-character. When not set, this defaults to 2 spaces.
-*/
-const indentUnit = /*@__PURE__*/index$1.Facet.define({
-    combine: values => {
-        if (!values.length)
-            return "  ";
-        let unit = values[0];
-        if (!unit || /\S/.test(unit) || Array.from(unit).some(e => e != unit[0]))
-            throw new Error("Invalid indent unit: " + JSON.stringify(values[0]));
-        return unit;
-    }
-});
-/**
-Return the _column width_ of an indent unit in the state.
-Determined by the [`indentUnit`](https://codemirror.net/6/docs/ref/#language.indentUnit)
-facet, and [`tabSize`](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize) when that
-contains tabs.
-*/
-function getIndentUnit(state) {
-    let unit = state.facet(indentUnit);
-    return unit.charCodeAt(0) == 9 ? state.tabSize * unit.length : unit.length;
-}
-/**
-Create an indentation string that covers columns 0 to `cols`.
-Will use tabs for as much of the columns as possible when the
-[`indentUnit`](https://codemirror.net/6/docs/ref/#language.indentUnit) facet contains
-tabs.
-*/
-function indentString(state, cols) {
-    let result = "", ts = state.tabSize, ch = state.facet(indentUnit)[0];
-    if (ch == "\t") {
-        while (cols >= ts) {
-            result += "\t";
-            cols -= ts;
-        }
-        ch = " ";
-    }
-    for (let i = 0; i < cols; i++)
-        result += ch;
-    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$1.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 ? 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$1.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
-[`indentString`](https://codemirror.net/6/docs/ref/#language.indentString)) or null, where null
-indicates that no definitive indentation can be determined.
-*/
-const indentNodeProp = /*@__PURE__*/new index.NodeProp();
-// Compute the indentation for a given position from the syntax tree.
-function syntaxIndentation(cx, ast, pos) {
-    return indentFrom(ast.resolveInner(pos).enterUnfinishedNodesBefore(pos), pos, cx);
-}
-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.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 indentFrom(node, pos, base) {
-    for (; node; node = node.parent) {
-        let strategy = indentStrategy(node);
-        if (strategy)
-            return strategy(TreeIndentContext.create(base, pos, node));
-    }
-    return 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, 
-    /**
-    The syntax tree node to which the indentation strategy
-    applies.
-    */
-    node) {
-        super(base.state, base.options);
-        this.base = base;
-        this.pos = pos;
-        this.node = node;
-    }
-    /**
-    @internal
-    */
-    static create(base, pos, node) {
-        return new TreeIndentContext(base, pos, node);
-    }
-    /**
-    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() {
-        let parent = this.node.parent;
-        return parent ? indentFrom(parent, this.pos, this.base) : 0;
-    }
-}
-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);
-}
-
-/**
-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 = highlight.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$1.Facet.define();
-const fallbackHighlighter = /*@__PURE__*/index$1.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$2.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$2.EditorView.darkTheme], state => {
-            return state.facet(index$2.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$2.Decoration.none;
-        let builder = new index$1.RangeSetBuilder();
-        for (let { from, to } of view.visibleRanges) {
-            highlight.highlightTree(this.tree, highlighters, (from, to, style) => {
-                builder.add(from, to, this.markCache[style] || (this.markCache[style] = index$2.Decoration.mark({ class: style })));
-            }, from, to);
-        }
-        return builder.finish();
-    }
-}
-const treeHighlighter = /*@__PURE__*/index$1.Prec.high(/*@__PURE__*/index$2.ViewPlugin.fromClass(TreeHighlighter, {
-    decorations: v => v.decorations
-}));
-/**
-A default highlight style (works well with light themes).
-*/
-const defaultHighlightStyle = /*@__PURE__*/HighlightStyle.define([
-    { tag: highlight.tags.meta,
-        color: "#404740" },
-    { tag: highlight.tags.link,
-        textDecoration: "underline" },
-    { tag: highlight.tags.heading,
-        textDecoration: "underline",
-        fontWeight: "bold" },
-    { tag: highlight.tags.emphasis,
-        fontStyle: "italic" },
-    { tag: highlight.tags.strong,
-        fontWeight: "bold" },
-    { tag: highlight.tags.strikethrough,
-        textDecoration: "line-through" },
-    { tag: highlight.tags.keyword,
-        color: "#708" },
-    { tag: [highlight.tags.atom, highlight.tags.bool, highlight.tags.url, highlight.tags.contentSeparator, highlight.tags.labelName],
-        color: "#219" },
-    { tag: [highlight.tags.literal, highlight.tags.inserted],
-        color: "#164" },
-    { tag: [highlight.tags.string, highlight.tags.deleted],
-        color: "#a11" },
-    { tag: [highlight.tags.regexp, highlight.tags.escape, /*@__PURE__*/highlight.tags.special(highlight.tags.string)],
-        color: "#e40" },
-    { tag: /*@__PURE__*/highlight.tags.definition(highlight.tags.variableName),
-        color: "#00f" },
-    { tag: /*@__PURE__*/highlight.tags.local(highlight.tags.variableName),
-        color: "#30a" },
-    { tag: [highlight.tags.typeName, highlight.tags.namespace],
-        color: "#085" },
-    { tag: highlight.tags.className,
-        color: "#167" },
-    { tag: [/*@__PURE__*/highlight.tags.special(highlight.tags.variableName), highlight.tags.macroName],
-        color: "#256" },
-    { tag: /*@__PURE__*/highlight.tags.definition(highlight.tags.propertyName),
-        color: "#00c" },
-    { tag: highlight.tags.comment,
-        color: "#940" },
-    { tag: highlight.tags.invalid,
-        color: "#f00" }
-]);
-const DefaultScanDist = 10000, DefaultBrackets = "()[]{}";
-/**
-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.NodeProp();
-function matchingNodes(node, dir, brackets) {
-    let byProp = node.prop(dir < 0 ? index.NodeProp.openedBy : index.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.NodeType.none];
-const warned = [];
-const defaultTable = /*@__PURE__*/Object.create(null);
-for (let [legacyName, name] of [
-    ["variable", "variableName"],
-    ["variable-2", "variableName.special"],
-    ["string-2", "string.special"],
-    ["def", "variableName.definition"],
-    ["tag", "tagName"],
-    ["attribute", "attributeName"],
-    ["type", "typeName"],
-    ["builtin", "variableName.standard"],
-    ["qualifier", "modifier"],
-    ["error", "invalid"],
-    ["header", "heading"],
-    ["property", "propertyName"]
-])
-    defaultTable[legacyName] = /*@__PURE__*/createTokenType(noTokens, name);
-function warnForPart(part, msg) {
-    if (warned.indexOf(part) > -1)
-        return;
-    warned.push(part);
-    console.warn(msg);
-}
-function createTokenType(extra, tagStr) {
-    let tag = null;
-    for (let part of tagStr.split(".")) {
-        let value = (extra[part] || highlight.tags[part]);
-        if (!value) {
-            warnForPart(part, `Unknown highlighting tag ${part}`);
-        }
-        else if (typeof value == "function") {
-            if (!tag)
-                warnForPart(part, `Modifier ${part} used at start of tag`);
-            else
-                tag = value(tag);
-        }
-        else {
-            if (tag)
-                warnForPart(part, `Tag ${part} used as modifier`);
-            else
-                tag = value;
-        }
-    }
-    if (!tag)
-        return 0;
-    let name = tagStr.replace(/ /g, "_"), type = index.NodeType.define({
-        id: typeArray.length,
-        name,
-        props: [highlight.styleTags({ [name]: tag })]
-    });
-    typeArray.push(type);
-    return type.id;
-}
-
-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.bracketMatchingHandle = bracketMatchingHandle;
-exports.defaultHighlightStyle = defaultHighlightStyle;
-exports.defineLanguageFacet = defineLanguageFacet;
-exports.ensureSyntaxTree = ensureSyntaxTree;
-exports.getIndentUnit = getIndentUnit;
-exports.getIndentation = getIndentation;
-exports.indentNodeProp = indentNodeProp;
-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;
-//# sourceMappingURL=index.js.map