monaco-editor11 1.0.9 → 1.1.1

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

@@ -1,301 +0,0 @@
-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

@@ -1,261 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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 };