@codemirror/language 0.19.3 → 0.19.7

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 0.19.7 (2021-12-02)
+
+### Bug fixes
+
+Fix an issue where the parse worker could incorrectly stop working when the parse tree has skipped gaps in it.
+
+## 0.19.6 (2021-11-26)
+
+### Bug fixes
+
+Fixes an issue where the background parse work would be scheduled too aggressively, degrading responsiveness on a newly-created editor with a large document.
+
+Improve initial highlight for mixed-language editors and limit the amount of parsing done on state creation for faster startup.
+
+## 0.19.5 (2021-11-17)
+
+### New features
+
+The new function `syntaxTreeAvailable` can be used to check if a fully-parsed syntax tree is available up to a given document position.
+
+The module now exports `syntaxParserRunning`, which tells you whether the background parser is still planning to do more work for a given editor view.
+
+## 0.19.4 (2021-11-13)
+
+### New features
+
+`LanguageDescription.of` now takes an optional already-loaded extension.
+
 ## 0.19.3 (2021-09-13)
 
 ### Bug fixes

package/dist/index.cjs

@@ -179,7 +179,31 @@ 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;
-    return !parse ? null : parse.treeLen >= upto || parse.work(timeout, upto) ? parse.tree : null;
+    return !parse ? null : parse.isDone(upto) || parse.work(timeout, upto) ? parse.tree : null;
+}
+/**
+Queries whether there is a full syntax tree available up to the
+given document position. If there isn't, the background parse
+process _might_ still be working and update the tree further, but
+there is no guarantee of that—the parser will [stop
+working](https://codemirror.net/6/docs/ref/#language.syntaxParserStopped) when it has spent a
+certain amount of time or has moved beyond the visible viewport.
+Always returns false if no language has been enabled.
+*/
+function syntaxTreeAvailable(state, upto = state.doc.length) {
+    var _a;
+    return ((_a = state.field(Language.state, false)) === null || _a === void 0 ? void 0 : _a.context.isDone(upto)) || false;
+}
+/**
+Tells you whether the language parser is planning to do more
+parsing work (in a `requestIdleCallback` pseudo-thread) or has
+stopped running, either because it parsed the entire document,
+because it spent too much time and was cut off, or because there
+is no language parser enabled.
+*/
+function syntaxParserRunning(view) {
+    var _a;
+    return ((_a = view.plugin(parseWorker)) === null || _a === void 0 ? void 0 : _a.isWorking()) || false;
 }
 // Lezer-style Input object for a Text document.
 class DocInput {
@@ -277,12 +301,12 @@ class ParseContext {
         }
         return this.withContext(() => {
             var _a;
+            let endTime = Date.now() + time;
             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);
-            let endTime = Date.now() + time;
             for (;;) {
                 let done = this.parse.advance();
                 if (done) {
@@ -305,10 +329,11 @@ class ParseContext {
     */
     takeTree() {
         let pos, tree;
-        if (this.parse && (pos = this.parse.parsedPos) > this.treeLen) {
+        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(common.TreeFragment.addTree(this.tree, this.fragments, true));
             this.parse = null;
@@ -426,13 +451,8 @@ class ParseContext {
     /**
     @internal
     */
-    movedPast(pos) {
-        return this.treeLen < pos && this.parse && this.parse.parsedPos >= pos;
-    }
-    /**
-    @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;
     }
@@ -462,13 +482,14 @@ class LanguageState {
         // 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(25 /* Apply */, upto))
+        if (!newCx.work(20 /* Apply */, upto))
             newCx.takeTree();
         return new LanguageState(newCx);
     }
     static init(state) {
-        let parseState = new ParseContext(state.facet(language).parser, state, [], common.Tree.empty, 0, { from: 0, to: state.doc.length }, [], null);
-        if (!parseState.work(25 /* Apply */))
+        let vpTo = Math.min(3000 /* InitViewport */, state.doc.length);
+        let parseState = new ParseContext(state.facet(language).parser, state, [], common.Tree.empty, 0, { from: 0, to: vpTo }, [], null);
+        if (!parseState.work(20 /* Apply */, vpTo))
             parseState.takeTree();
         return new LanguageState(parseState);
     }
@@ -484,13 +505,22 @@ Language.state = state.StateField.define({
         return value.apply(tr);
     }
 });
-let requestIdle = typeof window != "undefined" && window.requestIdleCallback ||
-    ((callback, { timeout }) => setTimeout(callback, timeout));
-let cancelIdle = typeof window != "undefined" && window.cancelIdleCallback || clearTimeout;
+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 parseWorker = view.ViewPlugin.fromClass(class ParseWorker {
     constructor(view) {
         this.view = view;
-        this.working = -1;
+        this.working = null;
+        this.workScheduled = 0;
         // End of the current time chunk
         this.chunkEnd = -1;
         // Milliseconds of budget left for this chunk
@@ -510,14 +540,14 @@ const parseWorker = view.ViewPlugin.fromClass(class ParseWorker {
         this.checkAsyncSchedule(cx);
     }
     scheduleWork() {
-        if (this.working > -1)
+        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, { timeout: 500 /* Pause */ });
+            this.working = requestIdle(this.work);
     }
     work(deadline) {
-        this.working = -1;
+        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 */;
@@ -526,28 +556,36 @@ const parseWorker = view.ViewPlugin.fromClass(class ParseWorker {
         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.treeLen >= vpTo + 1000000 /* MaxParseAhead */)
+        if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* MaxParseAhead */))
             return;
-        let time = Math.min(this.chunkBudget, deadline ? Math.max(25 /* MinSlice */, deadline.timeRemaining()) : 100 /* Slice */);
-        let done = field.context.work(time, vpTo + 1000000 /* MaxParseAhead */);
+        let time = Math.min(this.chunkBudget, 100 /* Slice */, deadline ? Math.max(25 /* MinSlice */, deadline.timeRemaining() - 5) : 1e9);
+        let viewportFirst = field.context.treeLen < vpTo && state.doc.length > vpTo + 1000;
+        let done = field.context.work(time, vpTo + (viewportFirst ? 0 : 100000 /* MaxParseAhead */));
         this.chunkBudget -= Date.now() - now;
-        if (done || this.chunkBudget <= 0 || field.context.movedPast(vpTo)) {
+        if (done || this.chunkBudget <= 0) {
             field.context.takeTree();
             this.view.dispatch({ effects: Language.setState.of(new LanguageState(field.context)) });
         }
-        if (!done && this.chunkBudget > 0)
+        if (this.chunkBudget > 0 && !(done && !viewportFirst))
             this.scheduleWork();
         this.checkAsyncSchedule(field.context);
     }
     checkAsyncSchedule(cx) {
         if (cx.scheduleOn) {
-            cx.scheduleOn.then(() => this.scheduleWork());
+            this.workScheduled++;
+            cx.scheduleOn
+                .then(() => this.scheduleWork())
+                .catch(err => view.logException(this.view.state, err))
+                .then(() => this.workScheduled--);
             cx.scheduleOn = null;
         }
     }
     destroy() {
-        if (this.working >= 0)
-            cancelIdle(this.working);
+        if (this.working)
+            this.working();
+    }
+    isWorking() {
+        return this.working || this.workScheduled > 0;
     }
 }, {
     eventHandlers: { focus() { this.scheduleWork(); } }
@@ -611,16 +649,17 @@ class LanguageDescription {
     Optional filename pattern that should be associated with this
     language.
     */
-    filename, loadFunc) {
+    filename, loadFunc, 
+    /**
+    If the language has been loaded, this will hold its value.
+    */
+    support = undefined) {
         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.
-        */
-        this.support = undefined;
+        this.support = support;
         this.loading = null;
     }
     /**
@@ -635,7 +674,13 @@ class LanguageDescription {
     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);
+        let { load, support } = spec;
+        if (!load) {
+            if (!support)
+                throw new RangeError("Must pass either 'load' or 'support' to LanguageDescription.of");
+            load = () => Promise.resolve(support);
+        }
+        return new LanguageDescription(spec.name, (spec.alias || []).concat(spec.name).map(s => s.toLowerCase()), spec.extensions || [], spec.filename, load, support);
     }
     /**
     Look for a language in the given array of descriptions that
@@ -1126,4 +1171,6 @@ exports.indentString = indentString;
 exports.indentUnit = indentUnit;
 exports.language = language;
 exports.languageDataProp = languageDataProp;
+exports.syntaxParserRunning = syntaxParserRunning;
 exports.syntaxTree = syntaxTree;
+exports.syntaxTreeAvailable = syntaxTreeAvailable;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { NodeProp, NodeType, Parser, Tree, TreeFragment, Input, PartialParse, SyntaxNode } from '@lezer/common';
 import { LRParser, ParserConfig } from '@lezer/lr';
 import { Facet, Extension, EditorState } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
 
 /**
 Node prop stored in a grammar's top syntax node to provide the
@@ -139,6 +140,24 @@ up to that point if the tree isn't already available.
 */
 declare function ensureSyntaxTree(state: EditorState, upto: number, timeout?: number): Tree | null;
 /**
+Queries whether there is a full syntax tree available up to the
+given document position. If there isn't, the background parse
+process _might_ still be working and update the tree further, but
+there is no guarantee of that—the parser will [stop
+working](https://codemirror.net/6/docs/ref/#language.syntaxParserStopped) when it has spent a
+certain amount of time or has moved beyond the visible viewport.
+Always returns false if no language has been enabled.
+*/
+declare function syntaxTreeAvailable(state: EditorState, upto?: number): boolean;
+/**
+Tells you whether the language parser is planning to do more
+parsing work (in a `requestIdleCallback` pseudo-thread) or has
+stopped running, either because it parsed the entire document,
+because it spent too much time and was cut off, or because there
+is no language parser enabled.
+*/
+declare function syntaxParserRunning(view: EditorView): boolean | (() => void);
+/**
 A parse context provided to parsers working on the editor content.
 */
 declare class ParseContext {
@@ -298,7 +317,8 @@ declare class LanguageDescription {
         */
         alias?: readonly string[];
         /**
-        An optional array of extensions associated with this language.
+        An optional array of filename extensions associated with this
+        language.
         */
         extensions?: readonly string[];
         /**
@@ -308,7 +328,12 @@ declare class LanguageDescription {
         /**
         A function that will asynchronously load the language.
         */
-        load: () => Promise<LanguageSupport>;
+        load?: () => Promise<LanguageSupport>;
+        /**
+        Alternatively to `load`, you can provide an already loaded
+        support object. Either this or `load` should be provided.
+        */
+        support?: LanguageSupport;
     }): LanguageDescription;
     /**
     Look for a language in the given array of descriptions that
@@ -584,4 +609,4 @@ declare function foldable(state: EditorState, lineStart: number, lineEnd: number
     to: number;
 } | null;
 
-export { IndentContext, LRLanguage, Language, LanguageDescription, LanguageSupport, ParseContext, TreeIndentContext, continuedIndent, defineLanguageFacet, delimitedIndent, ensureSyntaxTree, flatIndent, foldInside, foldNodeProp, foldService, foldable, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentService, indentString, indentUnit, language, languageDataProp, syntaxTree };
+export { IndentContext, LRLanguage, Language, LanguageDescription, LanguageSupport, ParseContext, TreeIndentContext, continuedIndent, defineLanguageFacet, delimitedIndent, ensureSyntaxTree, flatIndent, foldInside, foldNodeProp, foldService, foldable, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentService, indentString, indentUnit, language, languageDataProp, syntaxParserRunning, syntaxTree, syntaxTreeAvailable };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { NodeProp, Tree, TreeFragment, Parser, NodeType } from '@lezer/common';
-import { Facet, EditorState, StateEffect, StateField } from '@codemirror/state';
-import { ViewPlugin } from '@codemirror/view';
+import { StateEffect, StateField, Facet, EditorState } from '@codemirror/state';
+import { ViewPlugin, logException } from '@codemirror/view';
 import { countColumn } from '@codemirror/text';
 
 /**
@@ -175,7 +175,31 @@ 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;
-    return !parse ? null : parse.treeLen >= upto || parse.work(timeout, upto) ? parse.tree : null;
+    return !parse ? null : parse.isDone(upto) || parse.work(timeout, upto) ? parse.tree : null;
+}
+/**
+Queries whether there is a full syntax tree available up to the
+given document position. If there isn't, the background parse
+process _might_ still be working and update the tree further, but
+there is no guarantee of that—the parser will [stop
+working](https://codemirror.net/6/docs/ref/#language.syntaxParserStopped) when it has spent a
+certain amount of time or has moved beyond the visible viewport.
+Always returns false if no language has been enabled.
+*/
+function syntaxTreeAvailable(state, upto = state.doc.length) {
+    var _a;
+    return ((_a = state.field(Language.state, false)) === null || _a === void 0 ? void 0 : _a.context.isDone(upto)) || false;
+}
+/**
+Tells you whether the language parser is planning to do more
+parsing work (in a `requestIdleCallback` pseudo-thread) or has
+stopped running, either because it parsed the entire document,
+because it spent too much time and was cut off, or because there
+is no language parser enabled.
+*/
+function syntaxParserRunning(view) {
+    var _a;
+    return ((_a = view.plugin(parseWorker)) === null || _a === void 0 ? void 0 : _a.isWorking()) || false;
 }
 // Lezer-style Input object for a Text document.
 class DocInput {
@@ -273,12 +297,12 @@ class ParseContext {
         }
         return this.withContext(() => {
             var _a;
+            let endTime = Date.now() + time;
             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);
-            let endTime = Date.now() + time;
             for (;;) {
                 let done = this.parse.advance();
                 if (done) {
@@ -301,10 +325,11 @@ class ParseContext {
     */
     takeTree() {
         let pos, tree;
-        if (this.parse && (pos = this.parse.parsedPos) > this.treeLen) {
+        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(TreeFragment.addTree(this.tree, this.fragments, true));
             this.parse = null;
@@ -422,13 +447,8 @@ class ParseContext {
     /**
     @internal
     */
-    movedPast(pos) {
-        return this.treeLen < pos && this.parse && this.parse.parsedPos >= pos;
-    }
-    /**
-    @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;
     }
@@ -458,13 +478,14 @@ class LanguageState {
         // 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(25 /* Apply */, upto))
+        if (!newCx.work(20 /* Apply */, upto))
             newCx.takeTree();
         return new LanguageState(newCx);
     }
     static init(state) {
-        let parseState = new ParseContext(state.facet(language).parser, state, [], Tree.empty, 0, { from: 0, to: state.doc.length }, [], null);
-        if (!parseState.work(25 /* Apply */))
+        let vpTo = Math.min(3000 /* InitViewport */, state.doc.length);
+        let parseState = new ParseContext(state.facet(language).parser, state, [], Tree.empty, 0, { from: 0, to: vpTo }, [], null);
+        if (!parseState.work(20 /* Apply */, vpTo))
             parseState.takeTree();
         return new LanguageState(parseState);
     }
@@ -480,13 +501,22 @@ Language.state = /*@__PURE__*/StateField.define({
         return value.apply(tr);
     }
 });
-let requestIdle = typeof window != "undefined" && window.requestIdleCallback ||
-    ((callback, { timeout }) => setTimeout(callback, timeout));
-let cancelIdle = typeof window != "undefined" && window.cancelIdleCallback || clearTimeout;
+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 parseWorker = /*@__PURE__*/ViewPlugin.fromClass(class ParseWorker {
     constructor(view) {
         this.view = view;
-        this.working = -1;
+        this.working = null;
+        this.workScheduled = 0;
         // End of the current time chunk
         this.chunkEnd = -1;
         // Milliseconds of budget left for this chunk
@@ -506,14 +536,14 @@ const parseWorker = /*@__PURE__*/ViewPlugin.fromClass(class ParseWorker {
         this.checkAsyncSchedule(cx);
     }
     scheduleWork() {
-        if (this.working > -1)
+        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, { timeout: 500 /* Pause */ });
+            this.working = requestIdle(this.work);
     }
     work(deadline) {
-        this.working = -1;
+        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 */;
@@ -522,28 +552,36 @@ const parseWorker = /*@__PURE__*/ViewPlugin.fromClass(class ParseWorker {
         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.treeLen >= vpTo + 1000000 /* MaxParseAhead */)
+        if (field.tree == field.context.tree && field.context.isDone(vpTo + 100000 /* MaxParseAhead */))
             return;
-        let time = Math.min(this.chunkBudget, deadline ? Math.max(25 /* MinSlice */, deadline.timeRemaining()) : 100 /* Slice */);
-        let done = field.context.work(time, vpTo + 1000000 /* MaxParseAhead */);
+        let time = Math.min(this.chunkBudget, 100 /* Slice */, deadline ? Math.max(25 /* MinSlice */, deadline.timeRemaining() - 5) : 1e9);
+        let viewportFirst = field.context.treeLen < vpTo && state.doc.length > vpTo + 1000;
+        let done = field.context.work(time, vpTo + (viewportFirst ? 0 : 100000 /* MaxParseAhead */));
         this.chunkBudget -= Date.now() - now;
-        if (done || this.chunkBudget <= 0 || field.context.movedPast(vpTo)) {
+        if (done || this.chunkBudget <= 0) {
             field.context.takeTree();
             this.view.dispatch({ effects: Language.setState.of(new LanguageState(field.context)) });
         }
-        if (!done && this.chunkBudget > 0)
+        if (this.chunkBudget > 0 && !(done && !viewportFirst))
             this.scheduleWork();
         this.checkAsyncSchedule(field.context);
     }
     checkAsyncSchedule(cx) {
         if (cx.scheduleOn) {
-            cx.scheduleOn.then(() => this.scheduleWork());
+            this.workScheduled++;
+            cx.scheduleOn
+                .then(() => this.scheduleWork())
+                .catch(err => logException(this.view.state, err))
+                .then(() => this.workScheduled--);
             cx.scheduleOn = null;
         }
     }
     destroy() {
-        if (this.working >= 0)
-            cancelIdle(this.working);
+        if (this.working)
+            this.working();
+    }
+    isWorking() {
+        return this.working || this.workScheduled > 0;
     }
 }, {
     eventHandlers: { focus() { this.scheduleWork(); } }
@@ -607,16 +645,17 @@ class LanguageDescription {
     Optional filename pattern that should be associated with this
     language.
     */
-    filename, loadFunc) {
+    filename, loadFunc, 
+    /**
+    If the language has been loaded, this will hold its value.
+    */
+    support = undefined) {
         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.
-        */
-        this.support = undefined;
+        this.support = support;
         this.loading = null;
     }
     /**
@@ -631,7 +670,13 @@ class LanguageDescription {
     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);
+        let { load, support } = spec;
+        if (!load) {
+            if (!support)
+                throw new RangeError("Must pass either 'load' or 'support' to LanguageDescription.of");
+            load = () => Promise.resolve(support);
+        }
+        return new LanguageDescription(spec.name, (spec.alias || []).concat(spec.name).map(s => s.toLowerCase()), spec.extensions || [], spec.filename, load, support);
     }
     /**
     Look for a language in the given array of descriptions that
@@ -1097,4 +1142,4 @@ function foldable(state, lineStart, lineEnd) {
     return syntaxFolding(state, lineStart, lineEnd);
 }
 
-export { IndentContext, LRLanguage, Language, LanguageDescription, LanguageSupport, ParseContext, TreeIndentContext, continuedIndent, defineLanguageFacet, delimitedIndent, ensureSyntaxTree, flatIndent, foldInside, foldNodeProp, foldService, foldable, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentService, indentString, indentUnit, language, languageDataProp, syntaxTree };
+export { IndentContext, LRLanguage, Language, LanguageDescription, LanguageSupport, ParseContext, TreeIndentContext, continuedIndent, defineLanguageFacet, delimitedIndent, ensureSyntaxTree, flatIndent, foldInside, foldNodeProp, foldService, foldable, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentService, indentString, indentUnit, language, languageDataProp, syntaxParserRunning, syntaxTree, syntaxTreeAvailable };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemirror/language",
-  "version": "0.19.3",
+  "version": "0.19.7",
   "description": "Language support infrastructure for the CodeMirror code editor",
   "scripts": {
     "test": "cm-runtests",