@astrojs/ts-plugin 1.0.9 → 1.0.10

package/dist/astro-snapshots.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstroSnapshotManager = exports.AstroSnapshot = void 0;
+const trace_mapping_1 = require("@jridgewell/trace-mapping");
+const astro2tsx_js_1 = require("./astro2tsx.js");
+const utils_js_1 = require("./utils.js");
+class AstroSnapshot {
+    constructor(typescript, fileName, astroCode, traceMap, logger) {
+        this.typescript = typescript;
+        this.fileName = fileName;
+        this.astroCode = astroCode;
+        this.traceMap = traceMap;
+        this.logger = logger;
+        this.convertInternalCodePositions = false;
+    }
+    update(astroCode, traceMap) {
+        this.astroCode = astroCode;
+        this.traceMap = traceMap;
+        this.lineOffsets = undefined;
+        this.log('Updated Snapshot');
+    }
+    getOriginalTextSpan(textSpan) {
+        const start = this.getOriginalOffset(textSpan.start);
+        if (start === -1) {
+            return null;
+        }
+        // Assumption: We don't change identifiers itself, so we don't change ranges.
+        return {
+            start,
+            length: textSpan.length,
+        };
+    }
+    getOriginalOffset(generatedOffset) {
+        if (!this.scriptInfo) {
+            return generatedOffset;
+        }
+        this.toggleMappingMode(true);
+        const lineOffset = this.scriptInfo.positionToLineOffset(generatedOffset);
+        this.debug('try convert offset', generatedOffset, '/', lineOffset);
+        const original = (0, trace_mapping_1.originalPositionFor)(this.traceMap, {
+            line: lineOffset.line,
+            column: lineOffset.offset,
+        });
+        this.toggleMappingMode(false);
+        if (!original.line) {
+            return -1;
+        }
+        const originalOffset = this.scriptInfo.lineOffsetToPosition(original.line, original.column);
+        this.debug('converted offset to', original, '/', originalOffset);
+        return originalOffset;
+    }
+    setAndPatchScriptInfo(scriptInfo) {
+        // @ts-expect-error
+        scriptInfo.scriptKind = this.typescript.ScriptKind.TSX;
+        const positionToLineOffset = scriptInfo.positionToLineOffset.bind(scriptInfo);
+        scriptInfo.positionToLineOffset = (position) => {
+            if (this.convertInternalCodePositions) {
+                const lineOffset = positionToLineOffset(position);
+                this.debug('positionToLineOffset for generated code', position, lineOffset);
+                return lineOffset;
+            }
+            const lineOffset = this.positionAt(position);
+            this.debug('positionToLineOffset for original code', position, lineOffset);
+            return { line: lineOffset.line + 1, offset: lineOffset.character + 1 };
+        };
+        const lineOffsetToPosition = scriptInfo.lineOffsetToPosition.bind(scriptInfo);
+        scriptInfo.lineOffsetToPosition = (line, offset) => {
+            if (this.convertInternalCodePositions) {
+                const position = lineOffsetToPosition(line, offset);
+                this.debug('lineOffsetToPosition for generated code', { line, offset }, position);
+                return position;
+            }
+            const position = this.offsetAt({ line: line - 1, character: offset - 1 });
+            this.debug('lineOffsetToPosition for original code', { line, offset }, position);
+            return position;
+        };
+        this.scriptInfo = scriptInfo;
+        this.log('patched scriptInfo');
+    }
+    /**
+     * Get the line and character based on the offset
+     * @param offset The index of the position
+     */
+    positionAt(offset) {
+        offset = this.clamp(offset, 0, this.astroCode.length);
+        const lineOffsets = this.getLineOffsets();
+        let low = 0;
+        let high = lineOffsets.length;
+        if (high === 0) {
+            return { line: 0, character: offset };
+        }
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (lineOffsets[mid] > offset) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        // low is the least x for which the line offset is larger than the current offset
+        // or array.length if no line offset is larger than the current offset
+        const line = low - 1;
+        return { line, character: offset - lineOffsets[line] };
+    }
+    /**
+     * Get the index of the line and character position
+     * @param position Line and character position
+     */
+    offsetAt(position) {
+        const lineOffsets = this.getLineOffsets();
+        if (position.line >= lineOffsets.length) {
+            return this.astroCode.length;
+        }
+        else if (position.line < 0) {
+            return 0;
+        }
+        const lineOffset = lineOffsets[position.line];
+        const nextLineOffset = position.line + 1 < lineOffsets.length
+            ? lineOffsets[position.line + 1]
+            : this.astroCode.length;
+        return this.clamp(nextLineOffset, lineOffset, lineOffset + position.character);
+    }
+    getLineOffsets() {
+        if (this.lineOffsets) {
+            return this.lineOffsets;
+        }
+        const lineOffsets = [];
+        const text = this.astroCode;
+        let isLineStart = true;
+        for (let i = 0; i < text.length; i++) {
+            if (isLineStart) {
+                lineOffsets.push(i);
+                isLineStart = false;
+            }
+            const ch = text.charAt(i);
+            isLineStart = ch === '\r' || ch === '\n';
+            if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
+                i++;
+            }
+        }
+        if (isLineStart && text.length > 0) {
+            lineOffsets.push(text.length);
+        }
+        this.lineOffsets = lineOffsets;
+        return lineOffsets;
+    }
+    clamp(num, min, max) {
+        return Math.max(min, Math.min(max, num));
+    }
+    log(...args) {
+        this.logger.log('AstroSnapshot:', this.fileName, '-', ...args);
+    }
+    debug(...args) {
+        this.logger.debug('AstroSnapshot:', this.fileName, '-', ...args);
+    }
+    toggleMappingMode(convertInternalCodePositions) {
+        this.convertInternalCodePositions = convertInternalCodePositions;
+    }
+    getText() {
+        const snapshot = this.scriptInfo?.getSnapshot();
+        if (!snapshot) {
+            return '';
+        }
+        return snapshot.getText(0, snapshot.getLength());
+    }
+}
+exports.AstroSnapshot = AstroSnapshot;
+class AstroSnapshotManager {
+    constructor(typescript, projectService, logger) {
+        this.typescript = typescript;
+        this.projectService = projectService;
+        this.logger = logger;
+        this.snapshots = new Map();
+        this.patchProjectServiceReadFile();
+    }
+    get(fileName) {
+        return this.snapshots.get(fileName);
+    }
+    create(fileName) {
+        if (this.snapshots.has(fileName)) {
+            return this.snapshots.get(fileName);
+        }
+        // This will trigger projectService.host.readFile which is patched below
+        const scriptInfo = this.projectService.getOrCreateScriptInfoForNormalizedPath(this.typescript.server.toNormalizedPath(fileName), false);
+        if (!scriptInfo) {
+            this.logger.log('Was not able get snapshot for', fileName);
+            return;
+        }
+        try {
+            scriptInfo.getSnapshot(); // needed to trigger readFile
+        }
+        catch (e) {
+            this.logger.log('Loading Snapshot failed', fileName);
+        }
+        const snapshot = this.snapshots.get(fileName);
+        if (!snapshot) {
+            this.logger.log('Astro snapshot was not found after trying to load script snapshot for', fileName);
+            return; // should never get here
+        }
+        snapshot.setAndPatchScriptInfo(scriptInfo);
+        this.snapshots.set(fileName, snapshot);
+        return snapshot;
+    }
+    patchProjectServiceReadFile() {
+        const readFile = this.projectService.host.readFile;
+        this.projectService.host.readFile = (path) => {
+            if ((0, utils_js_1.isAstroFilePath)(path)) {
+                this.logger.debug('Read Astro file:', path);
+                const astroCode = readFile(path) || '';
+                try {
+                    const result = (0, astro2tsx_js_1.astro2tsx)(astroCode, path);
+                    const existingSnapshot = this.snapshots.get(path);
+                    if (existingSnapshot) {
+                        existingSnapshot.update(astroCode, new trace_mapping_1.TraceMap(result.map));
+                    }
+                    else {
+                        this.snapshots.set(path, new AstroSnapshot(this.typescript, path, astroCode, new trace_mapping_1.TraceMap(result.map), this.logger));
+                    }
+                    this.logger.log('Successfully read Astro file contents of', path);
+                    return result.code;
+                }
+                catch (e) {
+                    this.logger.log('Error loading Astro file:', path);
+                    this.logger.debug('Error:', e);
+                }
+            }
+            else {
+                return readFile(path);
+            }
+        };
+    }
+}
+exports.AstroSnapshotManager = AstroSnapshotManager;

package/dist/astro-sys.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAstroSys = void 0;
+const utils_js_1 = require("./utils.js");
+/**
+ * This should only be accessed by TS astro module resolution.
+ */
+function createAstroSys(logger, typescript) {
+    const astroSys = {
+        ...typescript.sys,
+        fileExists(path) {
+            return typescript.sys.fileExists((0, utils_js_1.ensureRealAstroFilePath)(path));
+        },
+        readDirectory(path, extensions, exclude, include, depth) {
+            const extensionsWithAstro = (extensions ?? []).concat('.astro');
+            return typescript.sys.readDirectory(path, extensionsWithAstro, exclude, include, depth);
+        },
+    };
+    if (typescript.sys.realpath) {
+        const realpath = typescript.sys.realpath;
+        astroSys.realpath = function (path) {
+            if ((0, utils_js_1.isVirtualAstroFilePath)(path)) {
+                return realpath((0, utils_js_1.toRealAstroFilePath)(path)) + '.ts';
+            }
+            return realpath(path);
+        };
+    }
+    return astroSys;
+}
+exports.createAstroSys = createAstroSys;

package/dist/astro2tsx.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astro2tsx = void 0;
+const sync_1 = require("@astrojs/compiler/sync");
+function astro2tsx(content, fileName) {
+    try {
+        const tsx = (0, sync_1.convertToTSX)(content, { filename: fileName });
+        return tsx;
+    }
+    catch (e) {
+        console.error(`There was an error transforming ${fileName} to TSX. An empty file will be returned instead. Please create an issue: https://github.com/withastro/language-tools/issues\nError: ${e}.`);
+        return {
+            code: '',
+            map: {
+                file: fileName,
+                sources: [],
+                sourcesContent: [],
+                names: [],
+                mappings: '',
+                version: 0,
+            },
+            diagnostics: [],
+        };
+    }
+}
+exports.astro2tsx = astro2tsx;

package/dist/index.js

@@ -0,0 +1,50 @@
+"use strict";
+const astro_snapshots_js_1 = require("./astro-snapshots.js");
+const index_js_1 = require("./language-service/index.js");
+const logger_js_1 = require("./logger.js");
+const module_loader_js_1 = require("./module-loader.js");
+const project_astro_files_js_1 = require("./project-astro-files.js");
+const utils_js_1 = require("./utils.js");
+function init(modules) {
+    const ts = modules.typescript;
+    function create(info) {
+        const logger = new logger_js_1.Logger(info.project.projectService.logger);
+        const parsedCommandLine = info.languageServiceHost.getParsedCommandLine?.((0, utils_js_1.getConfigPathForProject)(info.project));
+        if (!isAstroProject(info.project, parsedCommandLine)) {
+            logger.log('Detected that this is not an Astro project, abort patching TypeScript');
+            return info.languageService;
+        }
+        if ((0, index_js_1.isPatched)(info.languageService)) {
+            return info.languageService;
+        }
+        logger.log('Starting Astro plugin');
+        const snapshotManager = new astro_snapshots_js_1.AstroSnapshotManager(modules.typescript, info.project.projectService, logger);
+        if (parsedCommandLine) {
+            new project_astro_files_js_1.ProjectAstroFilesManager(modules.typescript, info.project, info.serverHost, snapshotManager, parsedCommandLine);
+        }
+        (0, module_loader_js_1.patchModuleLoader)(logger, snapshotManager, modules.typescript, info.languageServiceHost, info.project);
+        return (0, index_js_1.decorateLanguageService)(info.languageService, snapshotManager, ts, logger);
+    }
+    function getExternalFiles(project) {
+        return project_astro_files_js_1.ProjectAstroFilesManager.getInstance(project.getProjectName())?.getFiles() ?? [];
+    }
+    function isAstroProject(project, parsedCommandLine) {
+        if (parsedCommandLine) {
+            const astroFiles = (0, utils_js_1.readProjectAstroFilesFromFs)(ts, project, parsedCommandLine);
+            if (astroFiles.length > 0)
+                return true;
+        }
+        try {
+            const compilerOptions = project.getCompilerOptions();
+            const hasAstroInstalled = typeof compilerOptions.configFilePath !== 'string' ||
+                require.resolve('astro', { paths: [compilerOptions.configFilePath] });
+            return hasAstroInstalled;
+        }
+        catch (e) {
+            project.projectService.logger.info(e);
+            return false;
+        }
+    }
+    return { create, getExternalFiles };
+}
+module.exports = init;

package/dist/language-service/completions.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateCompletions = void 0;
+const utils_js_1 = require("../utils.js");
+const componentPostfix = '__AstroComponent_';
+function decorateCompletions(ls, logger) {
+    const getCompletionsAtPosition = ls.getCompletionsAtPosition;
+    ls.getCompletionsAtPosition = (fileName, position, options) => {
+        const completions = getCompletionsAtPosition(fileName, position, options);
+        if (!completions) {
+            return completions;
+        }
+        return {
+            ...completions,
+            entries: completions.entries.map((entry) => {
+                if (!(0, utils_js_1.isAstroFilePath)(entry.source || '') || !entry.name.endsWith(componentPostfix)) {
+                    return entry;
+                }
+                return {
+                    ...entry,
+                    name: entry.name.slice(0, -componentPostfix.length),
+                };
+            }),
+        };
+    };
+    const getCompletionEntryDetails = ls.getCompletionEntryDetails;
+    ls.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+        if (!(0, utils_js_1.isAstroFilePath)(source || '')) {
+            const details = getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
+            if (details) {
+                return details;
+            }
+        }
+        // In the completion list we removed the component postfix. Internally,
+        // the language service saved the list with the postfix, so details
+        // won't match anything. Therefore add it back and remove it afterwards again.
+        const astroDetails = getCompletionEntryDetails(fileName, position, entryName + componentPostfix, formatOptions, source, preferences, data);
+        if (!astroDetails) {
+            return undefined;
+        }
+        logger.debug('Found Astro Component import completion details');
+        return (0, utils_js_1.replaceDeep)(astroDetails, componentPostfix, '');
+    };
+}
+exports.decorateCompletions = decorateCompletions;

package/dist/language-service/definition.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateGetDefinition = void 0;
+const utils_1 = require("../utils");
+function decorateGetDefinition(ls, snapshotManager) {
+    const getDefinitionAndBoundSpan = ls.getDefinitionAndBoundSpan;
+    ls.getDefinitionAndBoundSpan = (fileName, position) => {
+        const definition = getDefinitionAndBoundSpan(fileName, position);
+        if (!definition?.definitions) {
+            return definition;
+        }
+        return {
+            ...definition,
+            definitions: definition.definitions
+                .map((def) => {
+                if (!(0, utils_1.isAstroFilePath)(def.fileName)) {
+                    return def;
+                }
+                let textSpan = snapshotManager.get(def.fileName)?.getOriginalTextSpan(def.textSpan);
+                if (!textSpan) {
+                    // Unmapped positions are for example the default export.
+                    // Fall back to the start of the file to at least go to the correct file.
+                    textSpan = { start: 0, length: 1 };
+                }
+                return {
+                    ...def,
+                    textSpan,
+                    // Spare the work for now
+                    originalTextSpan: undefined,
+                    contextSpan: undefined,
+                    originalContextSpan: undefined,
+                };
+            })
+                .filter(utils_1.isNotNullOrUndefined),
+        };
+    };
+}
+exports.decorateGetDefinition = decorateGetDefinition;

package/dist/language-service/diagnostics.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateDiagnostics = exports.DiagnosticCodes = void 0;
+const utils_js_1 = require("../utils.js");
+var DiagnosticCodes;
+(function (DiagnosticCodes) {
+    DiagnosticCodes[DiagnosticCodes["CANNOT_FIND_MODULE"] = 2307] = "CANNOT_FIND_MODULE";
+})(DiagnosticCodes || (exports.DiagnosticCodes = DiagnosticCodes = {}));
+function decorateDiagnostics(ls, typescript) {
+    decorateSyntacticDiagnostics(ls);
+    decorateSemanticDiagnostics(ls, typescript);
+    decorateSuggestionDiagnostics(ls);
+}
+exports.decorateDiagnostics = decorateDiagnostics;
+function decorateSyntacticDiagnostics(ls) {
+    const getSyntacticDiagnostics = ls.getSyntacticDiagnostics;
+    ls.getSyntacticDiagnostics = (fileName) => {
+        // Diagnostics inside Astro files are done
+        // by the @astrojs/language-server / Astro for VS Code extension
+        if ((0, utils_js_1.isAstroFilePath)(fileName)) {
+            return [];
+        }
+        return getSyntacticDiagnostics(fileName);
+    };
+}
+function decorateSemanticDiagnostics(ls, typescript) {
+    const getSemanticDiagnostics = ls.getSemanticDiagnostics;
+    ls.getSemanticDiagnostics = (fileName) => {
+        // Diagnostics inside Astro files are done
+        // by the @astrojs/language-server / Astro for VS Code extension
+        if ((0, utils_js_1.isAstroFilePath)(fileName)) {
+            return [];
+        }
+        let diagnostics = getSemanticDiagnostics(fileName);
+        diagnostics = diagnostics.map((diag) => {
+            const message = typescript.flattenDiagnosticMessageText(diag.messageText, typescript.sys.newLine);
+            if (diag.code === DiagnosticCodes.CANNOT_FIND_MODULE &&
+                message.includes('astro:content') &&
+                // TypeScript will keep the diagnostics here in cache, so if we just blindly always add to it, our added message will be there twice
+                // Not sure if there's a generic way to ensure that we only add it once, so for now we'll just check for the message we want to add
+                !message.includes('content collections')) {
+                diag.messageText =
+                    message +
+                        `${typescript.sys.newLine}${typescript.sys.newLine}` +
+                        "If you're using content collections, make sure to run `astro dev`, `astro build` or `astro sync` to first generate the types so you can import from them. If you already ran one of those commands, restarting the TS Server might be necessary in order for the change to take effect.";
+            }
+            return diag;
+        });
+        return diagnostics;
+    };
+}
+function decorateSuggestionDiagnostics(ls) {
+    const getSuggestionDiagnostics = ls.getSuggestionDiagnostics;
+    ls.getSuggestionDiagnostics = (fileName) => {
+        // Diagnostics inside Astro files are done
+        // by the @astrojs/language-server / Astro for VS Code extension
+        if ((0, utils_js_1.isAstroFilePath)(fileName)) {
+            return [];
+        }
+        return getSuggestionDiagnostics(fileName);
+    };
+}

package/dist/language-service/file-references.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateGetFileReferences = void 0;
+const utils_js_1 = require("../utils.js");
+function decorateGetFileReferences(ls, snapshotManager) {
+    const getFileReferences = ls.getFileReferences;
+    ls.getFileReferences = (fileName) => {
+        const references = getFileReferences(fileName);
+        return references
+            ?.map((ref) => {
+            if (!(0, utils_js_1.isAstroFilePath)(ref.fileName)) {
+                return ref;
+            }
+            const textSpan = snapshotManager.get(ref.fileName)?.getOriginalTextSpan(ref.textSpan);
+            if (!textSpan) {
+                return undefined;
+            }
+            return {
+                ...ref,
+                textSpan,
+                // Spare the work for now
+                contextSpan: undefined,
+                originalTextSpan: undefined,
+                originalContextSpan: undefined,
+            };
+        })
+            .filter(utils_js_1.isNotNullOrUndefined);
+    };
+}
+exports.decorateGetFileReferences = decorateGetFileReferences;

package/dist/language-service/find-references.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateFindReferences = void 0;
+const utils_js_1 = require("../utils.js");
+function decorateFindReferences(ls, snapshotManager, logger) {
+    decorateGetReferencesAtPosition(ls, snapshotManager, logger);
+    _decorateFindReferences(ls, snapshotManager, logger);
+}
+exports.decorateFindReferences = decorateFindReferences;
+function _decorateFindReferences(ls, snapshotManager, logger) {
+    const findReferences = ls.findReferences;
+    ls.findReferences = (fileName, position) => {
+        const references = findReferences(fileName, position);
+        return references
+            ?.map((reference) => {
+            const snapshot = snapshotManager.get(reference.definition.fileName);
+            if (!(0, utils_js_1.isAstroFilePath)(reference.definition.fileName) || !snapshot) {
+                return reference;
+            }
+            const textSpan = snapshot.getOriginalTextSpan(reference.definition.textSpan);
+            if (!textSpan) {
+                return null;
+            }
+            return {
+                definition: {
+                    ...reference.definition,
+                    textSpan,
+                    // Spare the work for now
+                    originalTextSpan: undefined,
+                },
+                references: mapReferences(reference.references, snapshotManager, logger),
+            };
+        })
+            .filter(utils_js_1.isNotNullOrUndefined);
+    };
+}
+function decorateGetReferencesAtPosition(ls, snapshotManager, logger) {
+    const getReferencesAtPosition = ls.getReferencesAtPosition;
+    ls.getReferencesAtPosition = (fileName, position) => {
+        const references = getReferencesAtPosition(fileName, position);
+        return references && mapReferences(references, snapshotManager, logger);
+    };
+}
+function mapReferences(references, snapshotManager, logger) {
+    return references
+        .map((reference) => {
+        const snapshot = snapshotManager.get(reference.fileName);
+        if (!(0, utils_js_1.isAstroFilePath)(reference.fileName) || !snapshot) {
+            return reference;
+        }
+        const textSpan = snapshot.getOriginalTextSpan(reference.textSpan);
+        if (!textSpan) {
+            return null;
+        }
+        logger.debug('Find references; map textSpan: changed', reference.textSpan, 'to', textSpan);
+        return {
+            ...reference,
+            textSpan,
+            // Spare the work for now
+            contextSpan: undefined,
+            originalTextSpan: undefined,
+            originalContextSpan: undefined,
+        };
+    })
+        .filter(utils_js_1.isNotNullOrUndefined);
+}

package/dist/language-service/implementation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateGetImplementation = void 0;
+const utils_js_1 = require("../utils.js");
+function decorateGetImplementation(ls, snapshotManager) {
+    const getImplementationAtPosition = ls.getImplementationAtPosition;
+    ls.getImplementationAtPosition = (fileName, position) => {
+        const implementation = getImplementationAtPosition(fileName, position);
+        return implementation
+            ?.map((impl) => {
+            if (!(0, utils_js_1.isAstroFilePath)(impl.fileName)) {
+                return impl;
+            }
+            const textSpan = snapshotManager.get(impl.fileName)?.getOriginalTextSpan(impl.textSpan);
+            if (!textSpan) {
+                return undefined;
+            }
+            return {
+                ...impl,
+                textSpan,
+                // Spare the work for now
+                contextSpan: undefined,
+                originalTextSpan: undefined,
+                originalContextSpan: undefined,
+            };
+        })
+            .filter(utils_js_1.isNotNullOrUndefined);
+    };
+}
+exports.decorateGetImplementation = decorateGetImplementation;

package/dist/language-service/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateLanguageService = exports.isPatched = void 0;
+const completions_js_1 = require("./completions.js");
+const definition_js_1 = require("./definition.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const file_references_js_1 = require("./file-references.js");
+const find_references_js_1 = require("./find-references.js");
+const implementation_js_1 = require("./implementation.js");
+const line_column_offset_js_1 = require("./line-column-offset.js");
+const rename_js_1 = require("./rename.js");
+const astroPluginPatchSymbol = Symbol('astroPluginPatchSymbol');
+function isPatched(ls) {
+    return ls[astroPluginPatchSymbol] === true;
+}
+exports.isPatched = isPatched;
+function decorateLanguageService(ls, snapshotManager, ts, logger) {
+    const proxy = new Proxy(ls, createProxyHandler());
+    (0, line_column_offset_js_1.decorateLineColumnOffset)(proxy, snapshotManager);
+    (0, rename_js_1.decorateRename)(proxy, snapshotManager, logger);
+    (0, diagnostics_js_1.decorateDiagnostics)(proxy, ts);
+    (0, find_references_js_1.decorateFindReferences)(proxy, snapshotManager, logger);
+    (0, completions_js_1.decorateCompletions)(proxy, logger);
+    (0, definition_js_1.decorateGetDefinition)(proxy, snapshotManager);
+    (0, implementation_js_1.decorateGetImplementation)(proxy, snapshotManager);
+    (0, file_references_js_1.decorateGetFileReferences)(proxy, snapshotManager);
+    return proxy;
+}
+exports.decorateLanguageService = decorateLanguageService;
+function createProxyHandler() {
+    const decorated = {};
+    return {
+        get(target, p) {
+            if (p === astroPluginPatchSymbol) {
+                return true;
+            }
+            return decorated[p] ?? target[p];
+        },
+        set(_, p, value) {
+            decorated[p] = value;
+            return true;
+        },
+    };
+}