@codemirror/language 0.17.4 → 0.18.2

package/dist/index.js

@@ -3,37 +3,52 @@ import { Text, countColumn } from '@codemirror/text';
 import { Facet, EditorState, StateEffect, StateField, Transaction } from '@codemirror/state';
 import { ViewPlugin } from '@codemirror/view';
 
-/// Node prop stored in a grammar's top syntax node to provide the
-/// facet that stores language data for that language.
-const languageDataProp = new NodeProp();
-/// Helper function to define a facet (to be added to the top syntax
-/// node(s) for a language via
-/// [`languageDataProp`](#language.languageDataProp)), that will be
-/// used to associate language data with the language. You
-/// probably only need this when subclassing
-/// [`Language`](#language.Language).
+/**
+Node prop stored in a grammar's top syntax node to provide the
+facet that stores language data for that language.
+*/
+const languageDataProp = /*@__PURE__*/new 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 Facet.define({
         combine: baseData ? values => values.concat(baseData) : undefined
     });
 }
-/// A language object manages parsing and per-language
-/// [metadata](#state.EditorState.languageDataAt). Parse data is
-/// managed as a [Lezer](https://lezer.codemirror.net) tree. You'll
-/// want to subclass this class for custom parsers, or use the
-/// [`LezerLanguage`](#language.LezerLanguage) or
-/// [`StreamLanguage`](#stream-parser.StreamLanguage) abstractions for
-/// [Lezer](https://lezer.codemirror.net/) or stream parsers.
+/**
+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. You'll
+want to subclass this class for custom parsers, or use the
+[`LezerLanguage`](https://codemirror.net/6/docs/ref/#language.LezerLanguage) or
+[`StreamLanguage`](https://codemirror.net/6/docs/ref/#stream-parser.StreamLanguage) abstractions for
+[Lezer](https://lezer.codemirror.net/) or stream parsers.
+*/
 class Language {
-    /// Construct a language object. You usually don't need to invoke
-    /// this directly. But when you do, make sure you use
-    /// [`defineLanguageFacet`](#language.defineLanguageFacet) to create
-    /// the first argument.
+    /**
+    Construct a language object. You usually don't need to invoke
+    this directly. But when you do, make sure you use
+    [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet) to create
+    the first argument.
+    */
     constructor(
-    /// The [language data](#state.EditorState.languageDataAt) data
-    /// facet used for this language.
-    data, parser, extraExtensions = []) {
+    /**
+    The [language data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) data
+    facet used for this language.
+    */
+    data, parser, 
+    /**
+    The node type of the top node of trees produced by this parser.
+    */
+    topNode, extraExtensions = []) {
         this.data = data;
+        this.topNode = topNode;
         // Kludge to define EditorState.tree as a debugging helper,
         // without the EditorState package actually knowing about
         // languages and lezer trees.
@@ -45,13 +60,17 @@ class Language {
             EditorState.languageData.of((state, pos) => state.facet(languageDataFacetAt(state, pos)))
         ].concat(extraExtensions);
     }
-    /// Query whether this language is active at the given position.
+    /**
+    Query whether this language is active at the given position.
+    */
     isActiveAt(state, pos) {
         return languageDataFacetAt(state, pos) == 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.
+    /**
+    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)
@@ -70,20 +89,26 @@ class Language {
         });
         return result;
     }
-    /// Indicates whether this language allows nested languages. The
-    /// default implementation returns true.
+    /**
+    Indicates whether this language allows nested languages. The
+    default implementation returns true.
+    */
     get allowsNesting() { return true; }
-    /// Use this language to parse the given string into a tree.
+    /**
+    Use this language to parse the given string into a tree.
+    */
     parseString(code) {
         let doc = Text.of(code.split("\n"));
-        let parse = this.parser.startParse(new DocInput(doc), 0, new EditorParseContext(this.parser, EditorState.create({ doc }), [], Tree.empty, { from: 0, to: code.length }, []));
+        let parse = this.parser.startParse(new DocInput(doc), 0, new EditorParseContext(this.parser, EditorState.create({ doc }), [], Tree.empty, { from: 0, to: code.length }, [], null));
         let tree;
         while (!(tree = parse.advance())) { }
         return tree;
     }
 }
-/// @internal
-Language.setState = StateEffect.define();
+/**
+@internal
+*/
+Language.setState = /*@__PURE__*/StateEffect.define();
 function languageDataFacetAt(state, pos) {
     let topLang = state.facet(language);
     if (!topLang)
@@ -100,38 +125,48 @@ function languageDataFacetAt(state, pos) {
     }
     return topLang.data;
 }
-/// A subclass of [`Language`](#language.Language) for use with
-/// [Lezer](https://lezer.codemirror.net/docs/ref#lezer.Parser)
-/// parsers.
+/**
+A subclass of [`Language`](https://codemirror.net/6/docs/ref/#language.Language) for use with
+[Lezer](https://lezer.codemirror.net/docs/ref#lezer.Parser)
+parsers.
+*/
 class LezerLanguage extends Language {
     constructor(data, parser) {
-        super(data, parser);
+        super(data, parser, parser.topNode);
         this.parser = parser;
     }
-    /// Define a language from a parser.
+    /**
+    Define a language from a parser.
+    */
     static define(spec) {
         let data = defineLanguageFacet(spec.languageData);
         return new LezerLanguage(data, spec.parser.configure({
             props: [languageDataProp.add(type => type.isTop ? data : undefined)]
         }));
     }
-    /// Create a new instance of this language with a reconfigured
-    /// version of its parser.
+    /**
+    Create a new instance of this language with a reconfigured
+    version of its parser.
+    */
     configure(options) {
         return new LezerLanguage(this.data, this.parser.configure(options));
     }
     get allowsNesting() { return this.parser.hasNested; }
 }
-/// Get the syntax tree for a state, which is the current (possibly
-/// incomplete) parse tree of active [language](#language.Language),
-/// or the empty tree if there is no language available.
+/**
+Get the syntax tree for a state, which is the current (possibly
+incomplete) parse tree of 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 : 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.
+/**
+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;
@@ -174,7 +209,7 @@ class DocInput {
         let stringStart = this.cursorPos - this.string.length;
         if (pos < stringStart || pos >= this.cursorPos)
             stringStart = this.syncTo(pos);
-        return this.cursor.lineBreak ? "" : this.string.slice(pos - stringStart);
+        return this.cursor.lineBreak ? "" : this.string.slice(pos - stringStart, Math.min(this.length - stringStart, this.string.length));
     }
     read(from, to) {
         let stringStart = this.cursorPos - this.string.length;
@@ -187,36 +222,61 @@ class DocInput {
         return new DocInput(this.doc, at);
     }
 }
-/// A parse context provided to parsers working on the editor content.
+/**
+A parse context provided to parsers working on the editor content.
+*/
 class EditorParseContext {
-    /// @internal
+    /**
+    @internal
+    */
     constructor(parser, 
-    /// The current editor state.
+    /**
+    The current editor state.
+    */
     state, 
-    /// Tree fragments that can be reused by incremental re-parses.
+    /**
+    Tree fragments that can be reused by incremental re-parses.
+    */
     fragments = [], 
-    /// @internal
+    /**
+    @internal
+    */
     tree, 
-    /// The current editor viewport (or some overapproximation
-    /// thereof). Intended to be used for opportunistically avoiding
-    /// work (in which case
-    /// [`skipUntilInView`](#language.EditorParseContext.skipUntilInView)
-    /// should be called to make sure the parser is restarted when the
-    /// skipped region becomes visible).
+    /**
+    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.EditorParseContext.skipUntilInView)
+    should be called to make sure the parser is restarted when the
+    skipped region becomes visible).
+    */
     viewport, 
-    /// @internal
-    skipped) {
+    /**
+    @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.viewport = viewport;
         this.skipped = skipped;
+        this.scheduleOn = scheduleOn;
         this.parse = null;
-        /// @internal
+        /**
+        @internal
+        */
         this.tempSkipped = [];
     }
-    /// @internal
+    /**
+    @internal
+    */
     work(time, upto) {
         if (this.tree != Tree.empty && (upto == null ? this.tree.length == this.state.doc.length : this.tree.length >= upto)) {
             this.takeTree();
@@ -241,7 +301,9 @@ class EditorParseContext {
                 return false;
         }
     }
-    /// @internal
+    /**
+    @internal
+    */
     takeTree() {
         if (this.parse && this.parse.pos > this.tree.length) {
             this.tree = this.parse.forceFinish();
@@ -253,7 +315,9 @@ class EditorParseContext {
             fragments = cutFragments(fragments, r.from, r.to);
         return fragments;
     }
-    /// @internal
+    /**
+    @internal
+    */
     changes(changes, newState) {
         let { fragments, tree, viewport, skipped } = this;
         this.takeTree();
@@ -272,9 +336,11 @@ class EditorParseContext {
                 }
             }
         }
-        return new EditorParseContext(this.parser, newState, fragments, tree, viewport, skipped);
+        return new EditorParseContext(this.parser, newState, fragments, tree, viewport, skipped, this.scheduleOn);
     }
-    /// @internal
+    /**
+    @internal
+    */
     updateViewport(viewport) {
         this.viewport = viewport;
         let startLen = this.skipped.length;
@@ -287,40 +353,61 @@ class EditorParseContext {
         }
         return this.skipped.length < startLen;
     }
-    /// @internal
+    /**
+    @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.
+    /**
+    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 });
     }
-    /// @internal
+    /**
+    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 {
+            startParse(input, startPos, context) {
+                return {
+                    pos: startPos,
+                    advance() {
+                        let ecx = context;
+                        ecx.tempSkipped.push({ from: startPos, to: input.length });
+                        if (until)
+                            ecx.scheduleOn = ecx.scheduleOn ? Promise.all([ecx.scheduleOn, until]) : until;
+                        this.pos = input.length;
+                        return new Tree(NodeType.none, [], [], input.length - startPos);
+                    },
+                    forceFinish() { return this.advance(); }
+                };
+            }
+        };
+    }
+    /**
+    @internal
+    */
     movedPast(pos) {
         return this.tree.length < pos && this.parse && this.parse.pos >= pos;
     }
 }
-/// 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.
-EditorParseContext.skippingParser = {
-    startParse(input, startPos, context) {
-        return {
-            pos: startPos,
-            advance() {
-                context.tempSkipped.push({ from: startPos, to: input.length });
-                this.pos = input.length;
-                return new Tree(NodeType.none, [], [], input.length - startPos);
-            },
-            forceFinish() { return this.advance(); }
-        };
-    }
-};
+/**
+FIXME backwards compatible shim, remove on next major @internal
+*/
+EditorParseContext.skippingParser = /*@__PURE__*/EditorParseContext.getSkippingParser();
 function cutFragments(fragments, from, to) {
     return TreeFragment.applyChanges(fragments, [{ fromA: from, toA: to, fromB: from, toB: to }]);
 }
@@ -346,13 +433,13 @@ class LanguageState {
         return new LanguageState(newCx);
     }
     static init(state) {
-        let parseState = new EditorParseContext(state.facet(language).parser, state, [], Tree.empty, { from: 0, to: state.doc.length }, []);
+        let parseState = new EditorParseContext(state.facet(language).parser, state, [], Tree.empty, { from: 0, to: state.doc.length }, [], null);
         if (!parseState.work(25 /* Apply */))
             parseState.takeTree();
         return new LanguageState(parseState);
     }
 }
-Language.state = StateField.define({
+Language.state = /*@__PURE__*/StateField.define({
     create: LanguageState.init,
     update(value, tr) {
         for (let e of tr.effects)
@@ -366,7 +453,7 @@ Language.state = StateField.define({
 let requestIdle = typeof window != "undefined" && window.requestIdleCallback ||
     ((callback, { timeout }) => setTimeout(callback, timeout));
 let cancelIdle = typeof window != "undefined" && window.cancelIdleCallback || clearTimeout;
-const parseWorker = ViewPlugin.fromClass(class ParseWorker {
+const parseWorker = /*@__PURE__*/ViewPlugin.fromClass(class ParseWorker {
     constructor(view) {
         this.view = view;
         this.working = -1;
@@ -378,8 +465,8 @@ const parseWorker = ViewPlugin.fromClass(class ParseWorker {
         this.scheduleWork();
     }
     update(update) {
+        let cx = this.view.state.field(Language.state).context;
         if (update.viewportChanged) {
-            let cx = this.view.state.field(Language.state).context;
             if (cx.updateViewport(update.view.viewport))
                 cx.reset();
             if (this.view.viewport.to > cx.tree.length)
@@ -390,12 +477,13 @@ const parseWorker = ViewPlugin.fromClass(class ParseWorker {
                 this.chunkBudget += 50 /* ChangeBonus */;
             this.scheduleWork();
         }
+        this.checkAsyncSchedule(cx);
     }
     scheduleWork() {
         if (this.working > -1)
             return;
-        let { state } = this.view, field = state.field(Language.state);
-        if (field.tree.length >= state.doc.length)
+        let { state } = this.view, field = state.field(Language.state), frags = field.context.fragments;
+        if (field.tree.length >= state.doc.length && frags.length && frags[0].from == 0 && frags[0].to >= state.doc.length)
             return;
         this.working = requestIdle(this.work, { timeout: 500 /* Pause */ });
     }
@@ -420,6 +508,13 @@ const parseWorker = ViewPlugin.fromClass(class ParseWorker {
         }
         if (!done && this.chunkBudget > 0)
             this.scheduleWork();
+        this.checkAsyncSchedule(field.context);
+    }
+    checkAsyncSchedule(cx) {
+        if (cx.scheduleOn) {
+            cx.scheduleOn.then(() => this.scheduleWork());
+            cx.scheduleOn = null;
+        }
     }
     destroy() {
         if (this.working >= 0)
@@ -428,70 +523,98 @@ const parseWorker = ViewPlugin.fromClass(class ParseWorker {
 }, {
     eventHandlers: { focus() { this.scheduleWork(); } }
 });
-/// The facet used to associate a language with an editor state.
-const language = Facet.define({
+/**
+The facet used to associate a language with an editor state.
+*/
+const language = /*@__PURE__*/Facet.define({
     combine(languages) { return languages.length ? languages[0] : null; },
     enables: [Language.state, parseWorker]
 });
-/// This class bundles a [language object](#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.
+/**
+This class bundles a [language object](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 support object.
+    /**
+    Create a support object.
+    */
     constructor(
-    /// The language object.
+    /**
+    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.
+    /**
+    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];
     }
 }
-/// Language descriptions are used to store metadata about languages
-/// and to dynamically load them. Their main role is finding the
-/// appropriate language for a filename or dynamically loading nested
-/// parsers.
+/**
+Language descriptions are used to store metadata about languages
+and to dynamically load them. Their main role is finding the
+appropriate language for a filename or dynamically loading nested
+parsers.
+*/
 class LanguageDescription {
     constructor(
-    /// The name of this language.
+    /**
+    The name of this language.
+    */
     name, 
-    /// Alternative names for the mode (lowercased, includes `this.name`).
+    /**
+    Alternative names for the mode (lowercased, includes `this.name`).
+    */
     alias, 
-    /// File extensions associated with this language.
+    /**
+    File extensions associated with this language.
+    */
     extensions, 
-    /// Optional filename pattern that should be associated with this
-    /// language.
+    /**
+    Optional filename pattern that should be associated with this
+    language.
+    */
     filename, loadFunc) {
         this.name = name;
         this.alias = alias;
         this.extensions = extensions;
         this.filename = filename;
         this.loadFunc = loadFunc;
-        /// If the language has been loaded, this will hold its value.
+        /**
+        If the language has been loaded, this will hold its value.
+        */
         this.support = undefined;
         this.loading = null;
     }
-    /// Start loading the the language. Will return a promise that
-    /// resolves to a [`LanguageSupport`](#language.LanguageSupport)
-    /// object when the language successfully loads.
+    /**
+    Start loading the the language. Will return a promise that
+    resolves to a [`LanguageSupport`](https://codemirror.net/6/docs/ref/#language.LanguageSupport)
+    object when the language successfully loads.
+    */
     load() {
         return this.loading || (this.loading = this.loadFunc().then(support => this.support = support, err => { this.loading = null; throw err; }));
     }
-    /// Create a language description.
+    /**
+    Create a language description.
+    */
     static of(spec) {
         return new LanguageDescription(spec.name, (spec.alias || []).concat(spec.name).map(s => s.toLowerCase()), spec.extensions || [], spec.filename, spec.load);
     }
-    /// Look for a language in the given array of descriptions that
-    /// matches the filename. Will first match
-    /// [`filename`](#language.LanguageDescription.filename) patterns,
-    /// and then [extensions](#language.LanguageDescription.extensions),
-    /// and return the first language that matches.
+    /**
+    Look for a language in the given array of descriptions that
+    matches the filename. Will first match
+    [`filename`](https://codemirror.net/6/docs/ref/#language.LanguageDescription.filename) patterns,
+    and then [extensions](https://codemirror.net/6/docs/ref/#language.LanguageDescription.extensions),
+    and return the first language that matches.
+    */
     static matchFilename(descs, filename) {
         for (let d of descs)
             if (d.filename && d.filename.test(filename))
@@ -503,11 +626,13 @@ class LanguageDescription {
                     return d;
         return null;
     }
-    /// Look for a language whose name or alias matches the the given
-    /// name (case-insensitively). If `fuzzy` is true, and no direct
-    /// matchs is found, this'll also search for a language whose name
-    /// or alias occurs in the string (for names shorter than three
-    /// characters, only when surrounded by non-word characters).
+    /**
+    Look for a language whose name or alias matches the the given
+    name (case-insensitively). If `fuzzy` is true, and no direct
+    matchs is found, this'll also search for a language whose name
+    or alias occurs in the string (for names shorter than three
+    characters, only when surrounded by non-word characters).
+    */
     static matchLanguageName(descs, name, fuzzy = true) {
         name = name.toLowerCase();
         for (let d of descs)
@@ -524,14 +649,18 @@ class LanguageDescription {
     }
 }
 
-/// Facet that defines a way to provide a function that computes the
-/// appropriate indentation depth at the start of a given line, or
-/// `null` to indicate no appropriate indentation could be determined.
-const indentService = Facet.define();
-/// Facet for overriding the unit by which indentation happens.
-/// Should be a string consisting either entirely of spaces or
-/// entirely of tabs. When not set, this defaults to 2 spaces.
-const indentUnit = Facet.define({
+/**
+Facet that defines a way to provide a function that computes the
+appropriate indentation depth at the start of a given line, or
+`null` to indicate no appropriate indentation could be determined.
+*/
+const indentService = /*@__PURE__*/Facet.define();
+/**
+Facet for overriding the unit by which indentation happens.
+Should be a string consisting either entirely of spaces or
+entirely of tabs. When not set, this defaults to 2 spaces.
+*/
+const indentUnit = /*@__PURE__*/Facet.define({
     combine: values => {
         if (!values.length)
             return "  ";
@@ -540,18 +669,22 @@ const indentUnit = Facet.define({
         return values[0];
     }
 });
-/// Return the _column width_ of an indent unit in the state.
-/// Determined by the [`indentUnit`](#language.indentUnit)
-/// facet, and [`tabSize`](#state.EditorState^tabSize) when that
-/// contains tabs.
+/**
+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`](#language.indentUnit) facet contains
-/// tabs.
+/**
+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;
     if (state.facet(indentUnit).charCodeAt(0) == 9)
@@ -563,12 +696,14 @@ function indentString(state, cols) {
         result += " ";
     return result;
 }
-/// Get the indentation at the given position. Will first consult any
-/// [indent services](#language.indentService) that are registered,
-/// and if none of those return an indentation, this will check the
-/// syntax tree for the [indent node prop](#language.indentNodeProp)
-/// and use that if found. Returns a number when an indentation could
-/// be determined, and null otherwise.
+/**
+Get the indentation 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 EditorState)
         context = new IndentContext(context);
@@ -580,23 +715,33 @@ function getIndentation(context, pos) {
     let tree = syntaxTree(context.state);
     return tree ? syntaxIndentation(context, tree, pos) : null;
 }
-/// Indentation contexts are used when calling [indentation
-/// services](#language.indentService). They provide helper utilities
-/// useful in indentation logic, and can selectively override the
-/// indentation reported for some lines.
+/**
+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.
+    /**
+    Create an indent context.
+    */
     constructor(
-    /// The editor state.
+    /**
+    The editor state.
+    */
     state, 
-    /// @internal
+    /**
+    @internal
+    */
     options = {}) {
         this.state = state;
         this.options = options;
         this.unit = getIndentUnit(state);
     }
-    /// Get the text directly after `pos`, either the entire line
-    /// or the next 100 characters, whichever is shorter.
+    /**
+    Get the text directly after `pos`, either the entire line
+    or the next 100 characters, whichever is shorter.
+    */
     textAfterPos(pos) {
         var _a, _b;
         let sim = (_a = this.options) === null || _a === void 0 ? void 0 : _a.simulateBreak;
@@ -604,7 +749,9 @@ class IndentContext {
             return "";
         return this.state.sliceDoc(pos, Math.min(pos + 100, sim != null && sim > pos ? sim : 1e9, this.state.doc.lineAt(pos).to));
     }
-    /// Find the column for the given position.
+    /**
+    Find the column for the given position.
+    */
     column(pos) {
         var _a;
         let line = this.state.doc.lineAt(pos), text = line.text.slice(0, pos - line.from);
@@ -614,12 +761,16 @@ class IndentContext {
             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.
+    /**
+    find the column position (taking tabs into account) of the given
+    position in the given string.
+    */
     countColumn(line, pos) {
         return countColumn(pos < 0 ? line : line.slice(0, pos), 0, this.state.tabSize);
     }
-    /// Find the indentation column of the given document line.
+    /**
+    Find the indentation column of the given document line.
+    */
     lineIndent(line) {
         var _a;
         let override = (_a = this.options) === null || _a === void 0 ? void 0 : _a.overrideIndentation;
@@ -631,11 +782,13 @@ class IndentContext {
         return this.countColumn(line.text, line.text.search(/\S/));
     }
 }
-/// 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 or null, where null indicates that no
-/// definitive indentation can be determined.
-const indentNodeProp = new NodeProp();
+/**
+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 or null, where null indicates that no
+definitive indentation can be determined.
+*/
+const indentNodeProp = /*@__PURE__*/new NodeProp();
 // Compute the indentation for a given position from the syntax tree.
 function syntaxIndentation(cx, ast, pos) {
     let tree = ast.resolve(pos);
@@ -655,12 +808,7 @@ function syntaxIndentation(cx, ast, pos) {
             scanPos = scan.to + 1;
         }
     }
-    for (; tree; tree = tree.parent) {
-        let strategy = indentStrategy(tree);
-        if (strategy)
-            return strategy(new TreeIndentContext(cx, pos, tree));
-    }
-    return null;
+    return indentFrom(tree, pos, cx);
 }
 function ignoreClosed(cx) {
     var _a, _b;
@@ -677,31 +825,52 @@ function indentStrategy(tree) {
     }
     return tree.parent == null ? topIndent : null;
 }
+function indentFrom(node, pos, base) {
+    for (; node; node = node.parent) {
+        let strategy = indentStrategy(node);
+        if (strategy)
+            return strategy(new TreeIndentContext(base, pos, node));
+    }
+    return null;
+}
 function topIndent() { return 0; }
-/// Objects of this type provide context information and helper
-/// methods to indentation functions.
+/**
+Objects of this type provide context information and helper
+methods to indentation functions.
+*/
 class TreeIndentContext extends IndentContext {
-    /// @internal
+    /**
+    @internal
+    */
     constructor(base, 
-    /// The position at which indentation is being computed.
+    /**
+    The position at which indentation is being computed.
+    */
     pos, 
-    /// The syntax tree node to which the indentation strategy
-    /// applies.
+    /**
+    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;
     }
-    /// Get the text directly after `this.pos`, either the entire line
-    /// or the next 100 characters, whichever is shorter.
+    /**
+    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 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() {
         let line = this.state.doc.lineAt(this.node.from);
         // Skip line starts that are covered by a sibling (or cousin, etc)
@@ -715,6 +884,14 @@ class TreeIndentContext extends IndentContext {
         }
         return this.lineIndent(line);
     }
+    /**
+    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)
@@ -743,15 +920,17 @@ function bracketedAligned(context) {
         pos = next.to;
     }
 }
-/// An indentation strategy for delimited (usually bracketed) nodes.
-/// Will, by default, indent one unit more than the parent's base
-/// indent unless the line starts with a closing token. When `align`
-/// is true and there are non-skipped nodes on the node's opening
-/// line, the content of the node will be aligned with the end of the
-/// opening node, like this:
-///
-///     foo(bar,
-///         baz)
+/**
+An indentation strategy for delimited (usually bracketed) nodes.
+Will, by default, indent one unit more than the parent's base
+indent unless the line starts with a closing token. When `align`
+is true and there are non-skipped nodes on the node's opening
+line, the content of the node will be aligned with the end of the
+opening node, like this:
+
+    foo(bar,
+        baz)
+*/
 function delimitedIndent({ closing, align = true, units = 1 }) {
     return (context) => delimitedStrategy(context, align, units, closing);
 }
@@ -763,15 +942,19 @@ function delimitedStrategy(context, align, units, closing, closedAt) {
         return closed ? context.column(aligned.from) : context.column(aligned.to);
     return context.baseIndent + (closed ? 0 : context.unit * units);
 }
-/// An indentation strategy that aligns a node's content to its base
-/// indentation.
+/**
+An indentation strategy that aligns a node's content to its base
+indentation.
+*/
 const flatIndent = (context) => context.baseIndent;
-/// Creates an indentation strategy that, by default, indents
-/// continued lines one unit more than the node's base indentation.
-/// You can provide `except` to prevent indentation of lines that
-/// match a pattern (for example `/^else\b/` in `if`/`else`
-/// constructs), and you can change the amount of units used with the
-/// `units` option.
+/**
+Creates an indentation strategy that, by default, indents
+continued lines one unit more than the node's base indentation.
+You can provide `except` to prevent indentation of lines that
+match a pattern (for example `/^else\b/` in `if`/`else`
+constructs), and you can change the amount of units used with the
+`units` option.
+*/
 function continuedIndent({ except, units = 1 } = {}) {
     return (context) => {
         let matchExcept = except && except.test(context.textAfter);
@@ -779,17 +962,19 @@ function continuedIndent({ except, units = 1 } = {}) {
     };
 }
 const DontIndentBeyond = 200;
-/// Enables reindentation on input. When a language defines an
-/// `indentOnInput` field in its [language
-/// data](#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.
+/**
+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 EditorState.transactionFilter.of(tr => {
         if (!tr.docChanged || tr.annotation(Transaction.userEvent) != "input")
@@ -821,16 +1006,29 @@ function indentOnInput() {
     });
 }
 
-/// 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 = Facet.define();
-/// This node prop is used to associate folding information with
-/// syntax node types. Given a syntax node, it should check whether
-/// that tree is foldable and return the range that can be collapsed
-/// when it is.
-const foldNodeProp = new NodeProp();
+/**
+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__*/Facet.define();
+/**
+This node prop is used to associate folding information with
+syntax node types. Given a syntax node, it should check whether
+that tree is foldable and return the range that can be collapsed
+when it is.
+*/
+const foldNodeProp = /*@__PURE__*/new NodeProp();
+/**
+[Fold](https://codemirror.net/6/docs/ref/#language.foldNodeProp) function that folds everything but
+the first and the last child of a syntax node. Useful for nodes
+that start and end with delimiters.
+*/
+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 == 0)
@@ -851,12 +1049,14 @@ function syntaxFolding(state, start, end) {
     }
     return found;
 }
-/// Check whether the given line is foldable. First asks any fold
-/// services registered through
-/// [`foldService`](#language.foldService), and if none of them return
-/// a result, tries to query the [fold node
-/// prop](#language.foldNodeProp) of syntax nodes that cover the end
-/// of the line.
+/**
+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);
@@ -866,4 +1066,4 @@ function foldable(state, lineStart, lineEnd) {
     return syntaxFolding(state, lineStart, lineEnd);
 }
 
-export { EditorParseContext, IndentContext, Language, LanguageDescription, LanguageSupport, LezerLanguage, TreeIndentContext, continuedIndent, defineLanguageFacet, delimitedIndent, ensureSyntaxTree, flatIndent, foldNodeProp, foldService, foldable, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentService, indentString, indentUnit, language, languageDataProp, syntaxTree };
+export { EditorParseContext, IndentContext, Language, LanguageDescription, LanguageSupport, LezerLanguage, TreeIndentContext, continuedIndent, defineLanguageFacet, delimitedIndent, ensureSyntaxTree, flatIndent, foldInside, foldNodeProp, foldService, foldable, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentService, indentString, indentUnit, language, languageDataProp, syntaxTree };