@analogjs/language-server 0.1.6 → 0.2.0

package/out/index.js

@@ -1,24 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const languagePlugin_1 = require("./languagePlugin");
 const volar_service_emmet_1 = require("volar-service-emmet");
 const volar_service_html_1 = require("volar-service-html");
 const volar_service_css_1 = require("volar-service-css");
 const volar_service_typescript_1 = require("volar-service-typescript");
 const node_1 = require("@volar/language-server/node");
+const vscode_uri_1 = require("vscode-uri");
+const routeScanner_1 = require("./routeScanner");
+const routingPlugin_1 = require("./plugins/routingPlugin");
 const connection = (0, node_1.createConnection)();
 const server = (0, node_1.createServer)(connection);
 connection.listen();
 connection.onInitialize(params => {
     const tsdk = (0, node_1.loadTsdkByPath)(params.initializationOptions.typescript.tsdk, params.locale);
-    return server.initialize(params, (0, node_1.createTypeScriptProject)(tsdk.typescript, tsdk.diagnosticMessages, () => ({
-        languagePlugins: [languagePlugin_1.analogLanguagePlugin]
-    })), [
+    // Initialize route scanner with the first workspace folder
+    const workspaceFolders = params.workspaceFolders ?? [];
+    let scanner;
+    if (workspaceFolders.length > 0) {
+        const rootUri = vscode_uri_1.URI.parse(workspaceFolders[0].uri);
+        scanner = new routeScanner_1.RouteScanner(rootUri.fsPath);
+        scanner.scan();
+    }
+    const servicePlugins = [
         (0, volar_service_html_1.create)(),
         (0, volar_service_css_1.create)(),
         (0, volar_service_emmet_1.create)(),
         ...(0, volar_service_typescript_1.create)(tsdk.typescript),
-    ]);
+    ];
+    if (scanner) {
+        servicePlugins.push((0, routingPlugin_1.createRoutingPlugin)(scanner));
+    }
+    return server.initialize(params, (0, node_1.createTypeScriptProject)(tsdk.typescript, tsdk.diagnosticMessages, () => ({
+        languagePlugins: []
+    })), servicePlugins);
+});
+// Re-scan routes when watched files change
+connection.onDidChangeWatchedFiles(() => {
+    // Scanner re-scan is triggered by the file watcher
+    // This will be enhanced with incremental updates
 });
 connection.onInitialized(server.initialized);
 connection.onShutdown(server.shutdown);

package/out/plugins/routingPlugin.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageServicePlugin } from '@volar/language-service';
+import type { RouteScanner } from '../routeScanner';
+/**
+ * Creates a Volar language service plugin that provides
+ * route path completions and go-to-definition for Analog's file-based routing.
+ */
+export declare function createRoutingPlugin(scanner: RouteScanner): LanguageServicePlugin;

package/out/plugins/routingPlugin.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoutingPlugin = void 0;
+const vscode = __importStar(require("vscode-languageserver-protocol"));
+const vscode_uri_1 = require("vscode-uri");
+/**
+ * Check if a position is inside a string literal and return the string content.
+ * Handles both single and double quoted strings.
+ */
+function getStringAtPosition(document, position) {
+    const line = document.getText(vscode.Range.create(position.line, 0, position.line + 1, 0));
+    const offset = position.character;
+    // Find the string boundaries around the cursor
+    let start = -1;
+    let end = -1;
+    let quote = '';
+    for (let i = offset - 1; i >= 0; i--) {
+        if ((line[i] === '"' || line[i] === "'") && (i === 0 || line[i - 1] !== '\\')) {
+            start = i;
+            quote = line[i];
+            break;
+        }
+    }
+    if (start === -1 || !quote)
+        return undefined;
+    for (let i = offset; i < line.length; i++) {
+        if (line[i] === quote && line[i - 1] !== '\\') {
+            end = i;
+            break;
+        }
+    }
+    if (end === -1)
+        return undefined;
+    const value = line.substring(start + 1, end);
+    const range = vscode.Range.create(position.line, start + 1, position.line, end);
+    return { value, range };
+}
+/**
+ * Check if the string at position is in a routing context.
+ * Looks for routerLink, navigate, navigateByUrl, route(), etc.
+ */
+function isRoutingContext(document, position) {
+    const line = document.getText(vscode.Range.create(position.line, 0, position.line + 1, 0));
+    // Check for common routing patterns in the line
+    return /routerLink|\.navigate\(|\.navigateByUrl\(|route\(|injectNavigate|injectNavigateByUrl|routerLink\s*=/.test(line);
+}
+/**
+ * Creates a Volar language service plugin that provides
+ * route path completions and go-to-definition for Analog's file-based routing.
+ */
+function createRoutingPlugin(scanner) {
+    return {
+        name: 'analog-routing',
+        capabilities: {
+            completionProvider: {
+                triggerCharacters: ["'", '"', '/'],
+            },
+            definitionProvider: true,
+        },
+        create() {
+            return {
+                provideCompletionItems(document, position) {
+                    if (!isRoutingContext(document, position)) {
+                        return undefined;
+                    }
+                    const stringInfo = getStringAtPosition(document, position);
+                    if (!stringInfo)
+                        return undefined;
+                    const routes = scanner.getRoutes();
+                    if (routes.length === 0)
+                        return undefined;
+                    const items = routes
+                        .filter((route) => !route.isCatchAll)
+                        .map((route) => {
+                        const item = {
+                            label: route.urlPath,
+                            kind: vscode.CompletionItemKind.File,
+                            detail: route.filePath.replace(/^.*\/src\//, 'src/'),
+                            sortText: route.params.length > 0 ? '1' : '0',
+                        };
+                        if (route.params.length > 0) {
+                            item.documentation = {
+                                kind: vscode.MarkupKind.Markdown,
+                                value: `**Parameters:** ${route.params.map((p) => '`:' + p + '`').join(', ')}`,
+                            };
+                        }
+                        if (route.serverFilePath) {
+                            const doc = item.documentation;
+                            const serverDetail = `\n\nHas server loader: \`${route.serverFilePath.replace(/^.*\/src\//, 'src/')}\``;
+                            if (typeof doc === 'object' && doc.kind === vscode.MarkupKind.Markdown) {
+                                doc.value += serverDetail;
+                            }
+                            else {
+                                item.documentation = {
+                                    kind: vscode.MarkupKind.Markdown,
+                                    value: serverDetail.trim(),
+                                };
+                            }
+                        }
+                        return item;
+                    });
+                    return {
+                        isIncomplete: false,
+                        items,
+                    };
+                },
+                provideDefinition(document, position) {
+                    const stringInfo = getStringAtPosition(document, position);
+                    if (!stringInfo)
+                        return undefined;
+                    const value = stringInfo.value;
+                    if (!value.startsWith('/'))
+                        return undefined;
+                    const matches = scanner.findByUrlString(value);
+                    if (matches.length === 0)
+                        return undefined;
+                    return matches.map((route) => vscode.LocationLink.create(vscode_uri_1.URI.file(route.filePath).toString(), vscode.Range.create(0, 0, 0, 0), vscode.Range.create(0, 0, 0, 0), stringInfo.range));
+                },
+            };
+        },
+    };
+}
+exports.createRoutingPlugin = createRoutingPlugin;
+//# sourceMappingURL=routingPlugin.js.map

package/out/routeScanner.d.ts

@@ -0,0 +1,41 @@
+export interface RouteInfo {
+    /** URL path, e.g. "/products/:productId" */
+    urlPath: string;
+    /** Absolute path to the .page.ts file */
+    filePath: string;
+    /** Absolute path to the paired .server.ts file, if it exists */
+    serverFilePath?: string;
+    /** Dynamic parameter names extracted from the path */
+    params: string[];
+    /** True if this route uses a catch-all pattern */
+    isCatchAll: boolean;
+}
+/**
+ * Scans the workspace for Analog page files and builds a route map.
+ */
+export declare class RouteScanner {
+    private routes;
+    private workspaceRoot;
+    constructor(workspaceRoot: string);
+    /**
+     * Perform initial scan of the pages directory.
+     */
+    scan(): void;
+    /**
+     * Get all discovered routes.
+     */
+    getRoutes(): RouteInfo[];
+    /**
+     * Find a route by its URL path.
+     */
+    findByUrlPath(urlPath: string): RouteInfo | undefined;
+    /**
+     * Get the paired .server.ts file for a .page.ts file, or vice versa.
+     */
+    getPairedFile(filePath: string): string | undefined;
+    /**
+     * Find routes whose URL path matches a given string (for go-to-definition).
+     * Matches both exact paths and parameterized patterns.
+     */
+    findByUrlString(urlString: string): RouteInfo[];
+}

package/out/routeScanner.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteScanner = void 0;
+const fs = __importStar(require("node:fs"));
+const tinyglobby_1 = require("tinyglobby");
+/**
+ * Converts a page filename to a raw path segment.
+ * Adapted from @analogjs/router routes.ts toRawPath().
+ */
+function toRawPath(filename) {
+    return filename
+        .replace(/^(?:[a-zA-Z]:[\\/])?(.*?)[\\/](?:routes|pages)[\\/]|(?:[\\/](?:app[\\/](?:routes|pages)|src[\\/]content)[\\/])|(\.page\.(js|ts)$)|(\.(ts|md)$)/g, '')
+        .replace(/\[\[\.\.\.([^\]]+)\]\]/g, '(opt-$1)')
+        .replace(/\[\.{3}.+\]/, '**')
+        .replace(/\[([^\]]+)\]/g, ':$1');
+}
+/**
+ * Converts a raw segment to a clean URL segment.
+ * Adapted from @analogjs/router routes.ts toSegment().
+ */
+function toSegment(rawSegment) {
+    return rawSegment
+        .replace(/index|\(.*?\)/g, '')
+        .replace(/\.|\/+/g, '/')
+        .replace(/^\/+|\/+$/g, '');
+}
+/**
+ * Convert a page file path to a URL path.
+ */
+function fileToUrlPath(filePath) {
+    const raw = toRawPath(filePath);
+    const segments = raw.split('/').map(toSegment).filter(Boolean);
+    return '/' + segments.join('/');
+}
+/**
+ * Extract dynamic parameter names from a URL path.
+ */
+function extractParams(urlPath) {
+    const params = [];
+    for (const match of urlPath.matchAll(/:([^/]+)/g)) {
+        params.push(match[1]);
+    }
+    return params;
+}
+/**
+ * Scans the workspace for Analog page files and builds a route map.
+ */
+class RouteScanner {
+    constructor(workspaceRoot) {
+        this.routes = [];
+        this.workspaceRoot = workspaceRoot;
+    }
+    /**
+     * Perform initial scan of the pages directory.
+     */
+    scan() {
+        const pageFiles = (0, tinyglobby_1.globSync)(['src/app/pages/**/*.page.ts'], {
+            cwd: this.workspaceRoot,
+            absolute: true,
+        });
+        this.routes = pageFiles.map((filePath) => {
+            const urlPath = fileToUrlPath(filePath);
+            const serverFilePath = filePath.replace(/\.page\.ts$/, '.server.ts');
+            const hasServer = fs.existsSync(serverFilePath);
+            return {
+                urlPath,
+                filePath,
+                serverFilePath: hasServer ? serverFilePath : undefined,
+                params: extractParams(urlPath),
+                isCatchAll: urlPath.includes('**'),
+            };
+        });
+    }
+    /**
+     * Get all discovered routes.
+     */
+    getRoutes() {
+        return this.routes;
+    }
+    /**
+     * Find a route by its URL path.
+     */
+    findByUrlPath(urlPath) {
+        return this.routes.find((r) => r.urlPath === urlPath);
+    }
+    /**
+     * Get the paired .server.ts file for a .page.ts file, or vice versa.
+     */
+    getPairedFile(filePath) {
+        if (filePath.endsWith('.page.ts')) {
+            const serverPath = filePath.replace(/\.page\.ts$/, '.server.ts');
+            return fs.existsSync(serverPath) ? serverPath : undefined;
+        }
+        if (filePath.endsWith('.server.ts')) {
+            const pagePath = filePath.replace(/\.server\.ts$/, '.page.ts');
+            return fs.existsSync(pagePath) ? pagePath : undefined;
+        }
+        return undefined;
+    }
+    /**
+     * Find routes whose URL path matches a given string (for go-to-definition).
+     * Matches both exact paths and parameterized patterns.
+     */
+    findByUrlString(urlString) {
+        const normalized = urlString.startsWith('/') ? urlString : '/' + urlString;
+        const exact = this.routes.filter((r) => r.urlPath === normalized);
+        if (exact.length > 0)
+            return exact;
+        // Try matching parameterized routes: "/products/123" against "/products/:productId"
+        return this.routes.filter((r) => {
+            if (r.isCatchAll)
+                return false;
+            const routeParts = r.urlPath.split('/');
+            const urlParts = normalized.split('/');
+            if (routeParts.length !== urlParts.length)
+                return false;
+            return routeParts.every((part, i) => part.startsWith(':') || part === urlParts[i]);
+        });
+    }
+}
+exports.RouteScanner = RouteScanner;
+//# sourceMappingURL=routeScanner.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@analogjs/language-server",
 	"description": "LSP server for AnalogJS Language Service",
-	"version": "0.1.6",
+	"version": "0.2.0",
 	"main": "out/index.js",
 	"license": "MIT",
 	"scripts": {
@@ -20,14 +20,16 @@
 		"analog-language-server": "./bin/analog-language-server.js"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.4.0",
-		"@volar/language-server": "~2.4.0",
-		"@volar/language-service": "~2.4.0",
-		"volar-service-css": "volar-2.4",
-		"volar-service-emmet": "volar-2.4",
-		"volar-service-html": "volar-2.4",
-		"volar-service-typescript": "volar-2.4",
-		"vscode-html-languageservice": "^5.2.0",
+		"@volar/language-core": "~2.4.28",
+		"@volar/language-server": "~2.4.28",
+		"@volar/language-service": "~2.4.28",
+		"volar-service-css": "0.0.70",
+		"volar-service-emmet": "0.0.70",
+		"volar-service-html": "0.0.70",
+		"volar-service-typescript": "0.0.70",
+		"tinyglobby": "^0.2.0",
+		"vscode-languageserver-protocol": "^3.17.5",
+		"vscode-languageserver-textdocument": "^1.0.11",
 		"vscode-uri": "^3.0.8"
 	},
 	"publishConfig": {

package/out/index.d.ts

@@ -1 +0,0 @@
-export {};

package/out/languagePlugin.d.ts

@@ -1,7 +0,0 @@
-import { type LanguagePlugin, type VirtualCode } from "@volar/language-core";
-import * as html from "vscode-html-languageservice";
-import { URI } from "vscode-uri";
-export declare const analogLanguagePlugin: LanguagePlugin<URI>;
-export interface AnalogVirtualCode extends VirtualCode {
-    htmlDocument: html.HTMLDocument;
-}

package/out/languagePlugin.js

@@ -1,251 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.analogLanguagePlugin = void 0;
-const language_core_1 = require("@volar/language-core");
-const html = __importStar(require("vscode-html-languageservice"));
-exports.analogLanguagePlugin = {
-    getLanguageId(uri) {
-        if (uri.path.endsWith(".analog") || uri.path.endsWith(".ag")) {
-            return "analog";
-        }
-    },
-    createVirtualCode(_uri, languageId, snapshot) {
-        if (languageId === "analog") {
-            return createAnalogCode(snapshot);
-        }
-    },
-    typescript: {
-        extraFileExtensions: [
-            {
-                extension: "analog",
-                isMixedContent: true,
-                scriptKind: 3,
-            },
-        ],
-        getServiceScript() {
-            return undefined;
-        },
-        getExtraServiceScripts(fileName, root) {
-            const scripts = [];
-            for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
-                if (code.languageId === "javascript") {
-                    scripts.push({
-                        fileName: fileName + "." + code.id + ".js",
-                        code,
-                        extension: ".js",
-                        scriptKind: 1,
-                    });
-                }
-                else if (code.languageId === "typescript") {
-                    scripts.push({
-                        fileName: fileName + "." + code.id + ".ts",
-                        code,
-                        extension: ".ts",
-                        scriptKind: 3,
-                    });
-                }
-                else if (code.languageId === "typescriptreact") {
-                    scripts.push({
-                        fileName: fileName + "." + code.id + ".tsx",
-                        code,
-                        extension: ".ts",
-                        scriptKind: 4,
-                    });
-                }
-            }
-            return scripts;
-        },
-    },
-};
-const htmlLs = html.getLanguageService();
-function createAnalogCode(snapshot) {
-    const document = html.TextDocument.create("", "html", 0, snapshot.getText(0, snapshot.getLength()));
-    const htmlDocument = htmlLs.parseHTMLDocument(document);
-    return {
-        id: "root",
-        languageId: "html",
-        snapshot,
-        mappings: [
-            {
-                sourceOffsets: [0],
-                generatedOffsets: [0],
-                lengths: [snapshot.getLength()],
-                data: {
-                    completion: true,
-                    format: true,
-                    navigation: true,
-                    semantic: true,
-                    structure: true,
-                    verification: true,
-                },
-            },
-        ],
-        embeddedCodes: [...createEmbeddedCodes()],
-        htmlDocument,
-    };
-    function* createEmbeddedCodes() {
-        let styles = 0;
-        let scripts = 0;
-        let langs = 0;
-        for (const root of htmlDocument.roots) {
-            if (root.tag === "style" &&
-                root.startTagEnd !== undefined &&
-                root.endTagStart !== undefined) {
-                const styleText = snapshot.getText(root.startTagEnd, root.endTagStart);
-                yield {
-                    id: "style_" + styles++,
-                    languageId: "css",
-                    snapshot: {
-                        getText: (start, end) => styleText.substring(start, end),
-                        getLength: () => styleText.length,
-                        getChangeRange: () => undefined,
-                    },
-                    mappings: [
-                        {
-                            sourceOffsets: [root.startTagEnd],
-                            generatedOffsets: [0],
-                            lengths: [styleText.length],
-                            data: {
-                                completion: true,
-                                format: true,
-                                navigation: true,
-                                semantic: true,
-                                structure: true,
-                                verification: true,
-                            },
-                        },
-                    ],
-                    embeddedCodes: [],
-                };
-            }
-            if (root.tag === "script" &&
-                root.startTagEnd !== undefined &&
-                root.endTagStart !== undefined) {
-                const text = snapshot.getText(root.startTagEnd, root.endTagStart).replace(/(with(((\n|\s)*).*)})/gm, function (_, _$1, $2) {
-                    // replace "with { analog: 'imports' }" with "/**with { analog: 'imports' }*/"
-                    // so its not evaluated inside the script tag
-                    return `/**${$2}*/`;
-                });
-                const lang = root.attributes?.lang;
-                const isTs = lang === "ts" || lang === '"ts"' || lang === "'ts'";
-                yield {
-                    id: "script_" + scripts++,
-                    languageId: isTs ? "typescript" : "javascript",
-                    snapshot: {
-                        getText: (start, end) => `${text.substring(start, end)}
-
-type AnalogComponentMetadata = Omit<import('@angular/core').Component, "template" |
-  "standalone" |
-  "changeDetection" |
-  "styles" |
-  "outputs" |
-  "inputs"> & { exposes?: any[] };
-
-/**
- * Defines additional metadata for the component such as the
- * selector, providers, and more.
- */
-declare function defineMetadata(metadata: AnalogComponentMetadata): void;
-
-/**
- * Defines the lifecycle hook(ngOnInit) that is called when the
- * component is initialized.
- */
-declare function onInit(initFn: () => void): void;
-
-/**
- * Defines the lifecycle hook(ngOnDestroy) that is called when the
- * component is destroyed.
- */
-declare function onDestroy(destroyFn: () => void): void;`,
-                        getLength: () => text.length,
-                        getChangeRange: () => undefined,
-                    },
-                    mappings: [
-                        {
-                            sourceOffsets: [root.startTagEnd],
-                            generatedOffsets: [0],
-                            lengths: [text.length],
-                            data: {
-                                completion: true,
-                                format: true,
-                                navigation: true,
-                                semantic: true,
-                                structure: true,
-                                verification: true,
-                            },
-                        },
-                    ],
-                    embeddedCodes: [],
-                };
-            }
-            if (root.tag === "template" &&
-                root.startTagEnd !== undefined &&
-                root.endTagStart !== undefined) {
-                const text = snapshot.getText(root.startTagEnd, root.endTagStart);
-                const lang = root.attributes?.lang;
-                const isMd = lang === "md" || lang === '"md"' || lang === "'md'";
-                yield {
-                    id: "lang_" + langs++,
-                    languageId: isMd ? "markdown" : "html",
-                    snapshot: {
-                        getText: (start, end) => text.substring(start, end),
-                        getLength: () => text.length,
-                        getChangeRange: () => undefined,
-                    },
-                    mappings: [
-                        {
-                            sourceOffsets: [root.startTagEnd],
-                            generatedOffsets: [0],
-                            lengths: [text.length],
-                            data: {
-                                completion: true,
-                                format: true,
-                                navigation: true,
-                                semantic: true,
-                                structure: true,
-                                verification: true,
-                            },
-                        },
-                    ],
-                    embeddedCodes: [
-                        {
-                            id: "lang_" + langs + "_ts",
-                            languageId: "typescript",
-                            snapshot: {
-                                getText: (_start, _end) => `increment();`,
-                                getLength: () => `void increment;`.length,
-                                getChangeRange: () => undefined,
-                            },
-                            mappings: []
-                        }
-                    ],
-                };
-            }
-        }
-    }
-}
-//# sourceMappingURL=languagePlugin.js.map