monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/tokenizer.js

@@ -0,0 +1,301 @@
+import { NotSupportedError } from '../../../../../base/common/errors.js';
+import { TokenMetadata } from '../../../encodedTokenAttributes.js';
+import { TextAstNode } from './ast.js';
+import { lengthZero, toLength, lengthAdd, lengthToObj, lengthGetColumnCountIfZeroLineCount, lengthDiff } from './length.js';
+import { SmallImmutableSet } from './smallImmutableSet.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class Token {
+    constructor(length, kind, 
+    /**
+     * If this token is an opening bracket, this is the id of the opening bracket.
+     * If this token is a closing bracket, this is the id of the first opening bracket that is closed by this bracket.
+     * Otherwise, it is -1.
+     */
+    bracketId, 
+    /**
+     * If this token is an opening bracket, this just contains `bracketId`.
+     * If this token is a closing bracket, this lists all opening bracket ids, that it closes.
+     * Otherwise, it is empty.
+     */
+    bracketIds, astNode) {
+        this.length = length;
+        this.kind = kind;
+        this.bracketId = bracketId;
+        this.bracketIds = bracketIds;
+        this.astNode = astNode;
+    }
+}
+class TextBufferTokenizer {
+    constructor(textModel, bracketTokens) {
+        this.textModel = textModel;
+        this.bracketTokens = bracketTokens;
+        this.reader = new NonPeekableTextBufferTokenizer(this.textModel, this.bracketTokens);
+        this._offset = lengthZero;
+        this.didPeek = false;
+        this.peeked = null;
+        this.textBufferLineCount = textModel.getLineCount();
+        this.textBufferLastLineLength = textModel.getLineLength(this.textBufferLineCount);
+    }
+    get offset() {
+        return this._offset;
+    }
+    get length() {
+        return toLength(this.textBufferLineCount - 1, this.textBufferLastLineLength);
+    }
+    skip(length) {
+        this.didPeek = false;
+        this._offset = lengthAdd(this._offset, length);
+        const obj = lengthToObj(this._offset);
+        this.reader.setPosition(obj.lineCount, obj.columnCount);
+    }
+    read() {
+        let token;
+        if (this.peeked) {
+            this.didPeek = false;
+            token = this.peeked;
+        }
+        else {
+            token = this.reader.read();
+        }
+        if (token) {
+            this._offset = lengthAdd(this._offset, token.length);
+        }
+        return token;
+    }
+    peek() {
+        if (!this.didPeek) {
+            this.peeked = this.reader.read();
+            this.didPeek = true;
+        }
+        return this.peeked;
+    }
+}
+/**
+ * Does not support peek.
+*/
+class NonPeekableTextBufferTokenizer {
+    constructor(textModel, bracketTokens) {
+        this.textModel = textModel;
+        this.bracketTokens = bracketTokens;
+        this.lineIdx = 0;
+        this.line = null;
+        this.lineCharOffset = 0;
+        this.lineTokens = null;
+        this.lineTokenOffset = 0;
+        /** Must be a zero line token. The end of the document cannot be peeked. */
+        this.peekedToken = null;
+        this.textBufferLineCount = textModel.getLineCount();
+        this.textBufferLastLineLength = textModel.getLineLength(this.textBufferLineCount);
+    }
+    setPosition(lineIdx, column) {
+        // We must not jump into a token!
+        if (lineIdx === this.lineIdx) {
+            this.lineCharOffset = column;
+            if (this.line !== null) {
+                this.lineTokenOffset = this.lineCharOffset === 0 ? 0 : this.lineTokens.findTokenIndexAtOffset(this.lineCharOffset);
+            }
+        }
+        else {
+            this.lineIdx = lineIdx;
+            this.lineCharOffset = column;
+            this.line = null;
+        }
+        this.peekedToken = null;
+    }
+    read() {
+        if (this.peekedToken) {
+            const token = this.peekedToken;
+            this.peekedToken = null;
+            this.lineCharOffset += lengthGetColumnCountIfZeroLineCount(token.length);
+            return token;
+        }
+        if (this.lineIdx > this.textBufferLineCount - 1 || (this.lineIdx === this.textBufferLineCount - 1 && this.lineCharOffset >= this.textBufferLastLineLength)) {
+            // We are after the end
+            return null;
+        }
+        if (this.line === null) {
+            this.lineTokens = this.textModel.tokenization.getLineTokens(this.lineIdx + 1);
+            this.line = this.lineTokens.getLineContent();
+            this.lineTokenOffset = this.lineCharOffset === 0 ? 0 : this.lineTokens.findTokenIndexAtOffset(this.lineCharOffset);
+        }
+        const startLineIdx = this.lineIdx;
+        const startLineCharOffset = this.lineCharOffset;
+        // limits the length of text tokens.
+        // If text tokens get too long, incremental updates will be slow
+        let lengthHeuristic = 0;
+        while (true) {
+            const lineTokens = this.lineTokens;
+            const tokenCount = lineTokens.getCount();
+            let peekedBracketToken = null;
+            if (this.lineTokenOffset < tokenCount) {
+                const tokenMetadata = lineTokens.getMetadata(this.lineTokenOffset);
+                while (this.lineTokenOffset + 1 < tokenCount && tokenMetadata === lineTokens.getMetadata(this.lineTokenOffset + 1)) {
+                    // Skip tokens that are identical.
+                    // Sometimes, (bracket) identifiers are split up into multiple tokens.
+                    this.lineTokenOffset++;
+                }
+                const isOther = TokenMetadata.getTokenType(tokenMetadata) === 0 /* StandardTokenType.Other */;
+                const containsBracketType = TokenMetadata.containsBalancedBrackets(tokenMetadata);
+                const endOffset = lineTokens.getEndOffset(this.lineTokenOffset);
+                // Is there a bracket token next? Only consume text.
+                if (containsBracketType && isOther && this.lineCharOffset < endOffset) {
+                    const languageId = lineTokens.getLanguageId(this.lineTokenOffset);
+                    const text = this.line.substring(this.lineCharOffset, endOffset);
+                    const brackets = this.bracketTokens.getSingleLanguageBracketTokens(languageId);
+                    const regexp = brackets.regExpGlobal;
+                    if (regexp) {
+                        regexp.lastIndex = 0;
+                        const match = regexp.exec(text);
+                        if (match) {
+                            peekedBracketToken = brackets.getToken(match[0]);
+                            if (peekedBracketToken) {
+                                // Consume leading text of the token
+                                this.lineCharOffset += match.index;
+                            }
+                        }
+                    }
+                }
+                lengthHeuristic += endOffset - this.lineCharOffset;
+                if (peekedBracketToken) {
+                    // Don't skip the entire token, as a single token could contain multiple brackets.
+                    if (startLineIdx !== this.lineIdx || startLineCharOffset !== this.lineCharOffset) {
+                        // There is text before the bracket
+                        this.peekedToken = peekedBracketToken;
+                        break;
+                    }
+                    else {
+                        // Consume the peeked token
+                        this.lineCharOffset += lengthGetColumnCountIfZeroLineCount(peekedBracketToken.length);
+                        return peekedBracketToken;
+                    }
+                }
+                else {
+                    // Skip the entire token, as the token contains no brackets at all.
+                    this.lineTokenOffset++;
+                    this.lineCharOffset = endOffset;
+                }
+            }
+            else {
+                if (this.lineIdx === this.textBufferLineCount - 1) {
+                    break;
+                }
+                this.lineIdx++;
+                this.lineTokens = this.textModel.tokenization.getLineTokens(this.lineIdx + 1);
+                this.lineTokenOffset = 0;
+                this.line = this.lineTokens.getLineContent();
+                this.lineCharOffset = 0;
+                lengthHeuristic += 33; // max 1000/33 = 30 lines
+                // This limits the amount of work to recompute min-indentation
+                if (lengthHeuristic > 1000) {
+                    // only break (automatically) at the end of line.
+                    break;
+                }
+            }
+            if (lengthHeuristic > 1500) {
+                // Eventually break regardless of the line length so that
+                // very long lines do not cause bad performance.
+                // This effective limits max indentation to 500, as
+                // indentation is not computed across multiple text nodes.
+                break;
+            }
+        }
+        // If a token contains some proper indentation, it also contains \n{INDENTATION+}(?!{INDENTATION}),
+        // unless the line is too long.
+        // Thus, the min indentation of the document is the minimum min indentation of every text node.
+        const length = lengthDiff(startLineIdx, startLineCharOffset, this.lineIdx, this.lineCharOffset);
+        return new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length));
+    }
+}
+class FastTokenizer {
+    constructor(text, brackets) {
+        this.text = text;
+        this._offset = lengthZero;
+        this.idx = 0;
+        const regExpStr = brackets.getRegExpStr();
+        const regexp = regExpStr ? new RegExp(regExpStr + '|\n', 'gi') : null;
+        const tokens = [];
+        let match;
+        let curLineCount = 0;
+        let lastLineBreakOffset = 0;
+        let lastTokenEndOffset = 0;
+        let lastTokenEndLine = 0;
+        const smallTextTokens0Line = [];
+        for (let i = 0; i < 60; i++) {
+            smallTextTokens0Line.push(new Token(toLength(0, i), 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(toLength(0, i))));
+        }
+        const smallTextTokens1Line = [];
+        for (let i = 0; i < 60; i++) {
+            smallTextTokens1Line.push(new Token(toLength(1, i), 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(toLength(1, i))));
+        }
+        if (regexp) {
+            regexp.lastIndex = 0;
+            // If a token contains indentation, it also contains \n{INDENTATION+}(?!{INDENTATION})
+            while ((match = regexp.exec(text)) !== null) {
+                const curOffset = match.index;
+                const value = match[0];
+                if (value === '\n') {
+                    curLineCount++;
+                    lastLineBreakOffset = curOffset + 1;
+                }
+                else {
+                    if (lastTokenEndOffset !== curOffset) {
+                        let token;
+                        if (lastTokenEndLine === curLineCount) {
+                            const colCount = curOffset - lastTokenEndOffset;
+                            if (colCount < smallTextTokens0Line.length) {
+                                token = smallTextTokens0Line[colCount];
+                            }
+                            else {
+                                const length = toLength(0, colCount);
+                                token = new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length));
+                            }
+                        }
+                        else {
+                            const lineCount = curLineCount - lastTokenEndLine;
+                            const colCount = curOffset - lastLineBreakOffset;
+                            if (lineCount === 1 && colCount < smallTextTokens1Line.length) {
+                                token = smallTextTokens1Line[colCount];
+                            }
+                            else {
+                                const length = toLength(lineCount, colCount);
+                                token = new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length));
+                            }
+                        }
+                        tokens.push(token);
+                    }
+                    // value is matched by regexp, so the token must exist
+                    tokens.push(brackets.getToken(value));
+                    lastTokenEndOffset = curOffset + value.length;
+                    lastTokenEndLine = curLineCount;
+                }
+            }
+        }
+        const offset = text.length;
+        if (lastTokenEndOffset !== offset) {
+            const length = (lastTokenEndLine === curLineCount)
+                ? toLength(0, offset - lastTokenEndOffset)
+                : toLength(curLineCount - lastTokenEndLine, offset - lastLineBreakOffset);
+            tokens.push(new Token(length, 0 /* TokenKind.Text */, -1, SmallImmutableSet.getEmpty(), new TextAstNode(length)));
+        }
+        this.length = toLength(curLineCount, offset - lastLineBreakOffset);
+        this.tokens = tokens;
+    }
+    get offset() {
+        return this._offset;
+    }
+    read() {
+        return this.tokens[this.idx++] || null;
+    }
+    peek() {
+        return this.tokens[this.idx] || null;
+    }
+    skip(length) {
+        throw new NotSupportedError();
+    }
+}
+
+export { FastTokenizer, TextBufferTokenizer, Token };

package/dist/workers/editor/common/tokenizerSyntaxTokenBackend.js

@@ -0,0 +1,261 @@
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { MutableDisposable, DisposableMap } from '../../../../base/common/lifecycle.js';
+import { countEOL } from '../../core/misc/eolCounter.js';
+import { Position } from '../../core/position.js';
+import { LineRange } from '../../core/ranges/lineRange.js';
+import { TokenizationRegistry } from '../../languages.js';
+import { ContiguousMultilineTokensBuilder } from '../../tokens/contiguousMultilineTokensBuilder.js';
+import { ContiguousTokensStore } from '../../tokens/contiguousTokensStore.js';
+import { TrackingTokenizationStateStore, TokenizerWithStateStoreAndTextModel, DefaultBackgroundTokenizer } from '../textModelTokens.js';
+import { AbstractSyntaxTokenBackend, AttachedViewHandler } from './abstractSyntaxTokenBackend.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/** For TextMate */
+class TokenizerSyntaxTokenBackend extends AbstractSyntaxTokenBackend {
+    constructor(languageIdCodec, textModel, getLanguageId, attachedViews) {
+        super(languageIdCodec, textModel);
+        this.getLanguageId = getLanguageId;
+        this._tokenizer = null;
+        this._backgroundTokenizationState = 1 /* BackgroundTokenizationState.InProgress */;
+        this._onDidChangeBackgroundTokenizationState = this._register(new Emitter());
+        this.onDidChangeBackgroundTokenizationState = this._onDidChangeBackgroundTokenizationState.event;
+        this._defaultBackgroundTokenizer = null;
+        this._backgroundTokenizer = this._register(new MutableDisposable());
+        this._tokens = new ContiguousTokensStore(this._languageIdCodec);
+        this._debugBackgroundTokenizer = this._register(new MutableDisposable());
+        this._attachedViewStates = this._register(new DisposableMap());
+        this._register(TokenizationRegistry.onDidChange((e) => {
+            const languageId = this.getLanguageId();
+            if (e.changedLanguages.indexOf(languageId) === -1) {
+                return;
+            }
+            this.todo_resetTokenization();
+        }));
+        this.todo_resetTokenization();
+        this._register(attachedViews.onDidChangeVisibleRanges(({ view, state }) => {
+            if (state) {
+                let existing = this._attachedViewStates.get(view);
+                if (!existing) {
+                    existing = new AttachedViewHandler(() => this.refreshRanges(existing.lineRanges));
+                    this._attachedViewStates.set(view, existing);
+                }
+                existing.handleStateChange(state);
+            }
+            else {
+                this._attachedViewStates.deleteAndDispose(view);
+            }
+        }));
+    }
+    todo_resetTokenization(fireTokenChangeEvent = true) {
+        this._tokens.flush();
+        this._debugBackgroundTokens?.flush();
+        if (this._debugBackgroundStates) {
+            this._debugBackgroundStates = new TrackingTokenizationStateStore(this._textModel.getLineCount());
+        }
+        if (fireTokenChangeEvent) {
+            this._onDidChangeTokens.fire({
+                semanticTokensApplied: false,
+                ranges: [
+                    {
+                        fromLineNumber: 1,
+                        toLineNumber: this._textModel.getLineCount(),
+                    },
+                ],
+            });
+        }
+        const initializeTokenization = () => {
+            if (this._textModel.isTooLargeForTokenization()) {
+                return [null, null];
+            }
+            const tokenizationSupport = TokenizationRegistry.get(this.getLanguageId());
+            if (!tokenizationSupport) {
+                return [null, null];
+            }
+            let initialState;
+            try {
+                initialState = tokenizationSupport.getInitialState();
+            }
+            catch (e) {
+                onUnexpectedError(e);
+                return [null, null];
+            }
+            return [tokenizationSupport, initialState];
+        };
+        const [tokenizationSupport, initialState] = initializeTokenization();
+        if (tokenizationSupport && initialState) {
+            this._tokenizer = new TokenizerWithStateStoreAndTextModel(this._textModel.getLineCount(), tokenizationSupport, this._textModel, this._languageIdCodec);
+        }
+        else {
+            this._tokenizer = null;
+        }
+        this._backgroundTokenizer.clear();
+        this._defaultBackgroundTokenizer = null;
+        if (this._tokenizer) {
+            const b = {
+                setTokens: (tokens) => {
+                    this.setTokens(tokens);
+                },
+                backgroundTokenizationFinished: () => {
+                    if (this._backgroundTokenizationState === 2 /* BackgroundTokenizationState.Completed */) {
+                        // We already did a full tokenization and don't go back to progressing.
+                        return;
+                    }
+                    const newState = 2 /* BackgroundTokenizationState.Completed */;
+                    this._backgroundTokenizationState = newState;
+                    this._onDidChangeBackgroundTokenizationState.fire();
+                },
+                setEndState: (lineNumber, state) => {
+                    if (!this._tokenizer) {
+                        return;
+                    }
+                    const firstInvalidEndStateLineNumber = this._tokenizer.store.getFirstInvalidEndStateLineNumber();
+                    // Don't accept states for definitely valid states, the renderer is ahead of the worker!
+                    if (firstInvalidEndStateLineNumber !== null && lineNumber >= firstInvalidEndStateLineNumber) {
+                        this._tokenizer?.store.setEndState(lineNumber, state);
+                    }
+                },
+            };
+            if (tokenizationSupport && tokenizationSupport.createBackgroundTokenizer && !tokenizationSupport.backgroundTokenizerShouldOnlyVerifyTokens) {
+                this._backgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, b);
+            }
+            if (!this._backgroundTokenizer.value && !this._textModel.isTooLargeForTokenization()) {
+                this._backgroundTokenizer.value = this._defaultBackgroundTokenizer =
+                    new DefaultBackgroundTokenizer(this._tokenizer, b);
+                this._defaultBackgroundTokenizer.handleChanges();
+            }
+            if (tokenizationSupport?.backgroundTokenizerShouldOnlyVerifyTokens && tokenizationSupport.createBackgroundTokenizer) {
+                this._debugBackgroundTokens = new ContiguousTokensStore(this._languageIdCodec);
+                this._debugBackgroundStates = new TrackingTokenizationStateStore(this._textModel.getLineCount());
+                this._debugBackgroundTokenizer.clear();
+                this._debugBackgroundTokenizer.value = tokenizationSupport.createBackgroundTokenizer(this._textModel, {
+                    setTokens: (tokens) => {
+                        this._debugBackgroundTokens?.setMultilineTokens(tokens, this._textModel);
+                    },
+                    backgroundTokenizationFinished() {
+                        // NO OP
+                    },
+                    setEndState: (lineNumber, state) => {
+                        this._debugBackgroundStates?.setEndState(lineNumber, state);
+                    },
+                });
+            }
+            else {
+                this._debugBackgroundTokens = undefined;
+                this._debugBackgroundStates = undefined;
+                this._debugBackgroundTokenizer.value = undefined;
+            }
+        }
+        this.refreshAllVisibleLineTokens();
+    }
+    handleDidChangeAttached() {
+        this._defaultBackgroundTokenizer?.handleChanges();
+    }
+    handleDidChangeContent(e) {
+        if (e.isFlush) {
+            // Don't fire the event, as the view might not have got the text change event yet
+            this.todo_resetTokenization(false);
+        }
+        else if (!e.isEolChange) { // We don't have to do anything on an EOL change
+            for (const c of e.changes) {
+                const [eolCount, firstLineLength] = countEOL(c.text);
+                this._tokens.acceptEdit(c.range, eolCount, firstLineLength);
+                this._debugBackgroundTokens?.acceptEdit(c.range, eolCount, firstLineLength);
+            }
+            this._debugBackgroundStates?.acceptChanges(e.changes);
+            if (this._tokenizer) {
+                this._tokenizer.store.acceptChanges(e.changes);
+            }
+            this._defaultBackgroundTokenizer?.handleChanges();
+        }
+    }
+    setTokens(tokens) {
+        const { changes } = this._tokens.setMultilineTokens(tokens, this._textModel);
+        if (changes.length > 0) {
+            this._onDidChangeTokens.fire({ semanticTokensApplied: false, ranges: changes, });
+        }
+        return { changes: changes };
+    }
+    refreshAllVisibleLineTokens() {
+        const ranges = LineRange.joinMany([...this._attachedViewStates].map(([_, s]) => s.lineRanges));
+        this.refreshRanges(ranges);
+    }
+    refreshRanges(ranges) {
+        for (const range of ranges) {
+            this.refreshRange(range.startLineNumber, range.endLineNumberExclusive - 1);
+        }
+    }
+    refreshRange(startLineNumber, endLineNumber) {
+        if (!this._tokenizer) {
+            return;
+        }
+        startLineNumber = Math.max(1, Math.min(this._textModel.getLineCount(), startLineNumber));
+        endLineNumber = Math.min(this._textModel.getLineCount(), endLineNumber);
+        const builder = new ContiguousMultilineTokensBuilder();
+        const { heuristicTokens } = this._tokenizer.tokenizeHeuristically(builder, startLineNumber, endLineNumber);
+        const changedTokens = this.setTokens(builder.finalize());
+        if (heuristicTokens) {
+            // We overrode tokens with heuristically computed ones.
+            // Because old states might get reused (thus stopping invalidation),
+            // we have to explicitly request the tokens for the changed ranges again.
+            for (const c of changedTokens.changes) {
+                this._backgroundTokenizer.value?.requestTokens(c.fromLineNumber, c.toLineNumber + 1);
+            }
+        }
+        this._defaultBackgroundTokenizer?.checkFinished();
+    }
+    forceTokenization(lineNumber) {
+        const builder = new ContiguousMultilineTokensBuilder();
+        this._tokenizer?.updateTokensUntilLine(builder, lineNumber);
+        this.setTokens(builder.finalize());
+        this._defaultBackgroundTokenizer?.checkFinished();
+    }
+    hasAccurateTokensForLine(lineNumber) {
+        if (!this._tokenizer) {
+            return true;
+        }
+        return this._tokenizer.hasAccurateTokensForLine(lineNumber);
+    }
+    isCheapToTokenize(lineNumber) {
+        if (!this._tokenizer) {
+            return true;
+        }
+        return this._tokenizer.isCheapToTokenize(lineNumber);
+    }
+    getLineTokens(lineNumber) {
+        const lineText = this._textModel.getLineContent(lineNumber);
+        const result = this._tokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);
+        if (this._debugBackgroundTokens && this._debugBackgroundStates && this._tokenizer) {
+            if (this._debugBackgroundStates.getFirstInvalidEndStateLineNumberOrMax() > lineNumber && this._tokenizer.store.getFirstInvalidEndStateLineNumberOrMax() > lineNumber) {
+                const backgroundResult = this._debugBackgroundTokens.getTokens(this._textModel.getLanguageId(), lineNumber - 1, lineText);
+                if (!result.equals(backgroundResult) && this._debugBackgroundTokenizer.value?.reportMismatchingTokens) {
+                    this._debugBackgroundTokenizer.value.reportMismatchingTokens(lineNumber);
+                }
+            }
+        }
+        return result;
+    }
+    getTokenTypeIfInsertingCharacter(lineNumber, column, character) {
+        if (!this._tokenizer) {
+            return 0 /* StandardTokenType.Other */;
+        }
+        const position = this._textModel.validatePosition(new Position(lineNumber, column));
+        this.forceTokenization(position.lineNumber);
+        return this._tokenizer.getTokenTypeIfInsertingCharacter(position, character);
+    }
+    tokenizeLinesAt(lineNumber, lines) {
+        if (!this._tokenizer) {
+            return null;
+        }
+        this.forceTokenization(lineNumber);
+        return this._tokenizer.tokenizeLinesAt(lineNumber, lines);
+    }
+    get hasTokens() {
+        return this._tokens.hasTokens;
+    }
+}
+
+export { TokenizerSyntaxTokenBackend };

package/dist/workers/editor/common/treeSitterLibraryService.js

@@ -0,0 +1,9 @@
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const ITreeSitterLibraryService = createDecorator('treeSitterLibraryService');
+
+export { ITreeSitterLibraryService };