@myagentroam/node 0.12.0 → 0.12.1

package/dist/code-navigation/index.js

@@ -0,0 +1,2 @@
+export { fileSpecifierParser, hyphenSeparatesNavigationSymbol, isNavigationSymbol, navigationLanguageForPath, navigationLanguages, navigationSymbolAt } from './registry.js';
+export { rangeAtColumn } from './source-ranges.js';

package/dist/code-navigation/languages/c-family.js

@@ -0,0 +1,9 @@
+import { createCPreprocessorFileSpecifierParser } from './c-preprocessor.js';
+export const cFamilyFileSpecifierParser = createCPreprocessorFileSpecifierParser('c-family');
+export const cFamilyNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'c-family',
+    parser: cFamilyFileSpecifierParser,
+    suffixes: ['.h', '.m'],
+    fallbackForAmbiguousSuffix: true
+};

package/dist/code-navigation/languages/c-preprocessor.js

@@ -0,0 +1,30 @@
+import { rangeAtColumn, sourceLineAt } from '../source-ranges.js';
+export function createCPreprocessorFileSpecifierParser(languageId) {
+    return {
+        find(source, position) {
+            const line = preprocessorDirectiveAt(source, position);
+            const match = /^\s*#\s*(?:include|import)\s*(?:\\\s*)*(?:"([^"\r\n]+)"|<([^>\r\n]+)>)/iu.exec(line.text);
+            const value = match?.[1] ?? match?.[2];
+            return rangeAtColumn(line.text, line.column, match, value, {
+                languageId,
+                extractorId: `${languageId}.include`,
+                kind: 'include'
+            }, line.from);
+        }
+    };
+}
+function preprocessorDirectiveAt(source, position) {
+    const current = sourceLineAt(source, position);
+    let from = current.from;
+    while (from > 0) {
+        const previous = sourceLineAt(source, from - 1);
+        if (!previous.text.trimEnd().endsWith('\\'))
+            break;
+        from = previous.from;
+    }
+    return {
+        text: source.slice(from, current.from + current.text.length),
+        column: position - from,
+        from
+    };
+}

package/dist/code-navigation/languages/c.js

@@ -0,0 +1,8 @@
+import { createCPreprocessorFileSpecifierParser } from './c-preprocessor.js';
+export const cFileSpecifierParser = createCPreprocessorFileSpecifierParser('c');
+export const cNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'c',
+    parser: cFileSpecifierParser,
+    suffixes: ['.c']
+};

package/dist/code-navigation/languages/cpp.js

@@ -0,0 +1,10 @@
+import { createCPreprocessorFileSpecifierParser } from './c-preprocessor.js';
+export const cppFileSpecifierParser = createCPreprocessorFileSpecifierParser('cpp');
+export const cppNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'cpp',
+    parser: cppFileSpecifierParser,
+    suffixes: ['.cc', '.cpp', '.cxx', '.h', '.hh', '.hpp', '.hxx'],
+    probe: (source) => !/(?:@\s*(?:interface|implementation|protocol|class|import)\b|#\s*import\b)/u.test(source) &&
+        /(?:\b(?:namespace|template|constexpr|decltype)\b|\bstd\s*::|(?<!@)\bclass\s+\w+)/u.test(source)
+};

package/dist/code-navigation/languages/csharp.js

@@ -0,0 +1,18 @@
+import { rangeAtColumn, sourceLineAt } from '../source-ranges.js';
+const usingDirective = /^\s*(?:global\s+)?using\s+(?:(?:static\s+)|(?:[\p{L}_][\p{L}\p{N}_]*\s*=\s*))?([\p{L}_\p{Nl}][\p{L}\p{Nl}\p{Nd}\p{Pc}\p{Mn}\p{Mc}]*(?:\.[\p{L}_\p{Nl}][\p{L}\p{Nl}\p{Nd}\p{Pc}\p{Mn}\p{Mc}]*)*)\s*;/u;
+function find(source, position) {
+    const line = sourceLineAt(source, position);
+    const match = usingDirective.exec(line.text);
+    return rangeAtColumn(line.text, line.column, match, match?.[1], {
+        languageId: 'csharp',
+        extractorId: 'csharp.using',
+        kind: 'namespace'
+    }, line.from);
+}
+export const csharpFileSpecifierParser = { find };
+export const csharpNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'csharp',
+    parser: csharpFileSpecifierParser,
+    suffixes: ['.cs']
+};

package/dist/code-navigation/languages/css.js

@@ -0,0 +1,7 @@
+import { createStylesheetFileSpecifierParser } from './stylesheet-reference.js';
+export const cssNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'css',
+    parser: createStylesheetFileSpecifierParser('css'),
+    suffixes: ['.css']
+};

package/dist/code-navigation/languages/ecmascript.js

@@ -0,0 +1,44 @@
+const staticImport = /(?:^|[;\r\n])\s*import\s+(?:(?:[^;'"`]*?)\s+from\s+)?(['"])([A-Za-z0-9_@./$-]+)\1/dgu;
+const staticExport = /(?:^|[;\r\n])\s*export\s+[^;'"`]*?\s+from\s+(['"])([A-Za-z0-9_@./$-]+)\1/dgu;
+function find(line, column) {
+    for (const [extractorId, expression] of [
+        ['ecmascript.dynamic-module', /\bimport\s*\(\s*(['"])([A-Za-z0-9_@./$-]+)\1\s*\)/dgu],
+        ['ecmascript.require', /\brequire\s*\(\s*(['"])([A-Za-z0-9_@./$-]+)\1\s*\)/dgu],
+        [
+            'typescript.reference-path',
+            /\/\/\/\s*<reference\s+path\s*=\s*(['"])([A-Za-z0-9_@./$-]+)\1\s*\/?>/dgu
+        ],
+        [
+            'ecmascript.import-meta-url',
+            /\bnew\s+URL\s*\(\s*(['"])(\.[A-Za-z0-9_@./$-]*)\1\s*,\s*import\.meta\.url\s*\)/dgu
+        ],
+        ['ecmascript.static-module', staticImport],
+        ['ecmascript.static-module', staticExport]
+    ]) {
+        for (const match of line.matchAll(expression)) {
+            const value = match[2];
+            const range = match.indices?.[2];
+            if (value === undefined || range === undefined)
+                continue;
+            const [from, to] = range;
+            if (column < from || column >= to)
+                continue;
+            return {
+                value,
+                from,
+                to,
+                languageId: 'ecmascript',
+                extractorId,
+                kind: value.startsWith('.') ? 'relative-file' : 'module'
+            };
+        }
+    }
+    return undefined;
+}
+export const ecmascriptFileSpecifierParser = { find };
+export const ecmascriptNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'ecmascript',
+    parser: ecmascriptFileSpecifierParser,
+    suffixes: ['.js', '.jsx', '.ts', '.tsx', '.mts', '.cts']
+};

package/dist/code-navigation/languages/file-target.js

@@ -0,0 +1,9 @@
+export function localWorkspaceFileTarget(value) {
+    if (value.length === 0 ||
+        /^[a-z][a-z\d+.-]*:/iu.test(value) ||
+        value.startsWith('/') ||
+        value.includes('?'))
+        return undefined;
+    const path = value.slice(0, value.indexOf('#') < 0 ? value.length : value.indexOf('#'));
+    return path.length === 0 || path.includes('\\') ? undefined : path;
+}

package/dist/code-navigation/languages/go.js

@@ -0,0 +1,32 @@
+import { rangeAtColumn, sourceLineAt } from '../source-ranges.js';
+const importPath = /^\s*(?:[._]|[\p{L}_][\p{L}\p{N}_]*)?\s*"([^"\r\n]+)"\s*;?\s*$/u;
+const singleImport = /^\s*import\s+(?:[._]|[\p{L}_][\p{L}\p{N}_]*)?\s*"([^"\r\n]+)"\s*;?\s*$/u;
+function find(source, position) {
+    const line = sourceLineAt(source, position);
+    const match = singleImport.exec(line.text) ??
+        (isWithinImportBlock(source, line.from) ? importPath.exec(line.text) : null);
+    return rangeAtColumn(line.text, line.column, match, match?.[1], {
+        languageId: 'go',
+        extractorId: 'go.import',
+        kind: 'module'
+    }, line.from);
+}
+function isWithinImportBlock(source, lineStart) {
+    let withinImportBlock = false;
+    for (const line of source.slice(0, lineStart).split(/\r?\n/u)) {
+        if (/^\s*import\s*\(\s*(?:\/\/.*)?$/u.test(line)) {
+            withinImportBlock = true;
+            continue;
+        }
+        if (withinImportBlock && /^\s*\)\s*(?:\/\/.*)?$/u.test(line))
+            withinImportBlock = false;
+    }
+    return withinImportBlock;
+}
+export const goFileSpecifierParser = { find };
+export const goNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'go',
+    parser: goFileSpecifierParser,
+    suffixes: ['.go']
+};

package/dist/code-navigation/languages/html.js

@@ -0,0 +1,7 @@
+import { createMarkupFileSpecifierParser } from './markup-reference.js';
+export const htmlNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'html',
+    parser: createMarkupFileSpecifierParser('html'),
+    suffixes: ['.html', '.htm']
+};

package/dist/code-navigation/languages/jvm.js

@@ -0,0 +1,17 @@
+import { rangeAtColumn, sourceLineAt } from '../source-ranges.js';
+function find(source, position) {
+    const line = sourceLineAt(source, position);
+    const match = /^\s*import\s+(?:static\s+)?([\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)+)\s*;?/u.exec(line.text);
+    return rangeAtColumn(line.text, line.column, match, match?.[1], {
+        languageId: 'jvm',
+        extractorId: 'jvm.import',
+        kind: 'namespace'
+    }, line.from);
+}
+export const jvmFileSpecifierParser = { find };
+export const jvmNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'jvm',
+    parser: jvmFileSpecifierParser,
+    suffixes: ['.java', '.kt', '.kts']
+};

package/dist/code-navigation/languages/less.js

@@ -0,0 +1,7 @@
+import { createStylesheetFileSpecifierParser } from './stylesheet-reference.js';
+export const lessNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'less',
+    parser: createStylesheetFileSpecifierParser('less'),
+    suffixes: ['.less']
+};

package/dist/code-navigation/languages/markdown.js

@@ -0,0 +1,113 @@
+const inlineLink = /!?\[[^\]\r\n]*\]\(\s*(?:<([^>\r\n]+)>|([^)\s\r\n]+))(?:\s+[^)\r\n]*)?\s*\)/gu;
+const referenceLink = /!?\[([^\]\r\n]+)\]\[([^\]\r\n]*)\]/gu;
+const referenceDefinition = /^[ \t]{0,3}\[([^\]\r\n]+)\]:\s*(?:<([^>\r\n]+)>|([^ \t\r\n]+))/gmu;
+const autolink = /<([^\s<>"'=]+)>/gu;
+const htmlAttribute = /(?:^|[\s<])(?:href|src)\s*=\s*(["'])([^"'\r\n]+)\1/giu;
+function find(source, position) {
+    if (position < 0 || position >= source.length || isWithinFencedCode(source, position))
+        return undefined;
+    const definitions = referenceDefinitions(source);
+    for (const match of source.matchAll(inlineLink)) {
+        const value = match[1] ?? match[2];
+        const reference = fileReferenceAt(source, position, match.index ?? 0, match[0], value, 'markdown.inline');
+        if (reference !== undefined)
+            return reference;
+    }
+    for (const match of source.matchAll(referenceLink)) {
+        const label = normalizeLabel(match[2] === '' ? match[1] : match[2]);
+        const target = definitions.get(label);
+        if (target === undefined)
+            continue;
+        const reference = fileReferenceAt(source, position, match.index ?? 0, match[0], target, 'markdown.reference');
+        if (reference !== undefined)
+            return reference;
+    }
+    for (const match of source.matchAll(autolink)) {
+        if (!isLocalAutolinkTarget(match[1]))
+            continue;
+        const reference = fileReferenceAt(source, position, match.index ?? 0, match[0], match[1], 'markdown.autolink');
+        if (reference !== undefined)
+            return reference;
+    }
+    for (const match of source.matchAll(htmlAttribute)) {
+        const reference = fileReferenceAt(source, position, match.index ?? 0, match[0], match[2], 'markdown.html-attribute');
+        if (reference !== undefined)
+            return reference;
+    }
+    return undefined;
+}
+function isLocalAutolinkTarget(value) {
+    return value !== undefined && /[./#]/u.test(value);
+}
+function fileReferenceAt(source, position, matchOffset, text, target, extractorId) {
+    if (target === undefined || position < matchOffset || position >= matchOffset + text.length)
+        return undefined;
+    const parsed = parseTarget(target);
+    if (parsed === undefined)
+        return undefined;
+    return {
+        value: parsed.path,
+        from: matchOffset,
+        to: matchOffset + text.length,
+        languageId: 'markdown',
+        extractorId,
+        kind: 'relative-file',
+        ...(parsed.anchor === undefined ? {} : { anchor: parsed.anchor })
+    };
+}
+function parseTarget(target) {
+    if (target.length === 0 ||
+        /^[a-z][a-z\d+.-]*:/iu.test(target) ||
+        target.startsWith('/') ||
+        target.includes('?'))
+        return undefined;
+    const hash = target.indexOf('#');
+    const path = hash < 0 ? target : target.slice(0, hash);
+    const anchor = hash < 0 ? undefined : target.slice(hash + 1);
+    if (anchor === '' && hash >= 0)
+        return undefined;
+    if (path === '' && anchor !== undefined)
+        return { path: '.', anchor };
+    if (path === '' || path.includes('\\'))
+        return undefined;
+    return { path, ...(anchor === undefined ? {} : { anchor }) };
+}
+function referenceDefinitions(source) {
+    const definitions = new Map();
+    for (const match of source.matchAll(referenceDefinition)) {
+        const label = match[1];
+        const target = match[2] ?? match[3];
+        if (label !== undefined && target !== undefined)
+            definitions.set(normalizeLabel(label), target);
+    }
+    return definitions;
+}
+function normalizeLabel(value) {
+    return value.trim().replace(/\s+/gu, ' ').toLowerCase();
+}
+function isWithinFencedCode(source, position) {
+    let marker;
+    let length = 0;
+    for (const line of source.slice(0, position).split('\n')) {
+        const match = /^[ \t]*(`{3,}|~{3,})/u.exec(line);
+        if (match === null)
+            continue;
+        const fence = match[1];
+        if (marker === undefined) {
+            marker = fence[0];
+            length = fence.length;
+        }
+        else if (fence[0] === marker && fence.length >= length) {
+            marker = undefined;
+            length = 0;
+        }
+    }
+    return marker !== undefined;
+}
+export const markdownFileSpecifierParser = { find };
+export const markdownNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'markdown',
+    parser: markdownFileSpecifierParser,
+    suffixes: ['.md', '.markdown']
+};

package/dist/code-navigation/languages/markup-reference.js

@@ -0,0 +1,27 @@
+import { localWorkspaceFileTarget } from './file-target.js';
+const markupAttribute = /(?:^|[\s<])(?:src|href)\s*=\s*(["'])([^"'\r\n]+)\1/giu;
+export function createMarkupFileSpecifierParser(languageId) {
+    return {
+        find: (source, position) => findMarkupReference(source, position, languageId)
+    };
+}
+export function findMarkupReference(source, position, languageId) {
+    for (const match of source.matchAll(markupAttribute)) {
+        const value = match[2];
+        if (value === undefined)
+            continue;
+        const target = localWorkspaceFileTarget(value);
+        const from = (match.index ?? 0) + match[0].indexOf(value);
+        if (target === undefined || position < from || position >= from + value.length)
+            continue;
+        return {
+            value: target,
+            from,
+            to: from + value.length,
+            languageId,
+            extractorId: `${languageId}.attribute`,
+            kind: 'relative-file'
+        };
+    }
+    return undefined;
+}

package/dist/code-navigation/languages/objective-c.js

@@ -0,0 +1,11 @@
+import { createCPreprocessorFileSpecifierParser } from './c-preprocessor.js';
+const objectiveCSyntax = /(?:@\s*(?:interface|implementation|protocol|class|import)\b|#\s*import\b)/u;
+export const objectiveCFileSpecifierParser = createCPreprocessorFileSpecifierParser('objective-c');
+export const objectiveCNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'objective-c',
+    parser: objectiveCFileSpecifierParser,
+    suffixes: ['.m', '.h'],
+    probe: (source) => objectiveCSyntax.test(source) &&
+        !/(?:\b(?:namespace|template)\b|\bstd\s*::|(?<!@)\bclass\s+\w+)/u.test(source)
+};

package/dist/code-navigation/languages/objective-cpp.js

@@ -0,0 +1,10 @@
+import { createCPreprocessorFileSpecifierParser } from './c-preprocessor.js';
+export const objectiveCppFileSpecifierParser = createCPreprocessorFileSpecifierParser('objective-cpp');
+export const objectiveCppNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'objective-cpp',
+    parser: objectiveCppFileSpecifierParser,
+    suffixes: ['.mm', '.h'],
+    probe: (source) => /(?:@\s*(?:interface|implementation|protocol|class|import)\b|#\s*import\b)/u.test(source) &&
+        /(?:\b(?:namespace|template)\b|\bstd\s*::|(?<!@)\bclass\s+\w+)/u.test(source)
+};

package/dist/code-navigation/languages/python.js

@@ -0,0 +1,17 @@
+import { rangeAtColumn, sourceLineAt } from '../source-ranges.js';
+function find(source, position) {
+    const line = sourceLineAt(source, position);
+    const match = /^\s*(?:from\s+((?:(?:\.+)?[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*)|\.+)\s+import\b|import\s+([\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*))/u.exec(line.text);
+    return rangeAtColumn(line.text, line.column, match, match?.[1] ?? match?.[2], {
+        languageId: 'python',
+        extractorId: 'python.import',
+        kind: (match?.[1] ?? match?.[2] ?? '').startsWith('.') ? 'relative-file' : 'namespace'
+    }, line.from);
+}
+export const pythonFileSpecifierParser = { find };
+export const pythonNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'python',
+    parser: pythonFileSpecifierParser,
+    suffixes: ['.py', '.pyw']
+};

package/dist/code-navigation/languages/rust.js

@@ -0,0 +1,18 @@
+import { rangeAtColumn, sourceLineAt } from '../source-ranges.js';
+function find(source, position) {
+    const line = sourceLineAt(source, position);
+    const match = /^\s*(?:#\s*\[\s*path\s*=\s*["']([^"']+)["']\s*\]\s*)?(?:pub(?:\([^)]*\))?\s+)?mod\s+([A-Za-z_][A-Za-z0-9_]*)\s*;/u.exec(line.text);
+    const value = match?.[1] ?? match?.[2];
+    return rangeAtColumn(line.text, line.column, match, value, {
+        languageId: 'rust',
+        extractorId: match?.[1] === undefined ? 'rust.module' : 'rust.path-module',
+        kind: match?.[1] === undefined ? 'module' : 'relative-file'
+    }, line.from);
+}
+export const rustFileSpecifierParser = { find };
+export const rustNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: true,
+    id: 'rust',
+    parser: rustFileSpecifierParser,
+    suffixes: ['.rs']
+};

package/dist/code-navigation/languages/sass.js

@@ -0,0 +1,7 @@
+import { createStylesheetFileSpecifierParser } from './stylesheet-reference.js';
+export const sassNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'sass',
+    parser: createStylesheetFileSpecifierParser('sass'),
+    suffixes: ['.sass']
+};

package/dist/code-navigation/languages/scss.js

@@ -0,0 +1,7 @@
+import { createStylesheetFileSpecifierParser } from './stylesheet-reference.js';
+export const scssNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'scss',
+    parser: createStylesheetFileSpecifierParser('scss'),
+    suffixes: ['.scss']
+};

package/dist/code-navigation/languages/stylesheet-reference.js

@@ -0,0 +1,37 @@
+import { localWorkspaceFileTarget } from './file-target.js';
+const stylesheetImport = /@(?:import|use|forward)\b(?:\s+\([^)]*\))?\s+(?:url\(\s*)?(["'])([^"'\r\n]+)\1\s*\)?/giu;
+const stylesheetUrl = /\burl\(\s*(["']?)([^"'()\s\r\n]+)\1\s*\)/giu;
+export function createStylesheetFileSpecifierParser(languageId) {
+    return {
+        find: (source, position) => findStylesheetReference(source, position, languageId)
+    };
+}
+export function findStylesheetReference(source, position, languageId) {
+    for (const [expression, extractor] of [
+        [stylesheetImport, 'import'],
+        [stylesheetUrl, 'url']
+    ]) {
+        expression.lastIndex = 0;
+        for (const match of source.matchAll(expression)) {
+            const value = match[2];
+            if (value === undefined)
+                continue;
+            const target = localWorkspaceFileTarget(value);
+            const from = (match.index ?? 0) + match[0].indexOf(value);
+            if (target === undefined ||
+                position < from ||
+                position >= from + value.length ||
+                (extractor === 'url' && /^\s*@(?:import|use|forward)\b/iu.test(match[0])))
+                continue;
+            return {
+                value: target,
+                from,
+                to: from + value.length,
+                languageId,
+                extractorId: `${languageId}.${extractor}`,
+                kind: 'relative-file'
+            };
+        }
+    }
+    return undefined;
+}

package/dist/code-navigation/languages/vue.js

@@ -0,0 +1,75 @@
+import { ecmascriptFileSpecifierParser } from './ecmascript.js';
+import { findMarkupReference } from './markup-reference.js';
+import { findStylesheetReference } from './stylesheet-reference.js';
+const scriptBlock = /<script\b[^>]*>([\s\S]*?)<\/script\s*>/giu;
+const styleBlock = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/giu;
+const styleLanguage = /\blang\s*=\s*(["'])([^"'\r\n]+)\1/iu;
+function find(source, position) {
+    return (findMarkupReference(source, position, 'vue') ??
+        findEmbeddedReference(source, position, scriptBlock, ecmascriptFileSpecifierParser) ??
+        findStyleReference(source, position) ??
+        findReferenceWithoutBlockBoundary(source, position));
+}
+function findReferenceWithoutBlockBoundary(source, position) {
+    const ecmascript = ecmascriptFileSpecifierParser.find(source, position);
+    if (ecmascript !== undefined)
+        return ecmascript;
+    const lineFrom = source.lastIndexOf('\n', Math.max(0, position - 1)) + 1;
+    const stylesheetLanguage = /^[ \t]*@(?:use|forward)\b/iu.test(source.slice(lineFrom, position))
+        ? 'scss'
+        : 'vue';
+    return findStylesheetReference(source, position, stylesheetLanguage);
+}
+function findEmbeddedReference(source, position, expression, parser) {
+    expression.lastIndex = 0;
+    for (const block of source.matchAll(expression)) {
+        const content = block[1] ?? '';
+        const contentFrom = (block.index ?? 0) + block[0].indexOf(content);
+        if (position < contentFrom || position >= contentFrom + content.length)
+            continue;
+        const reference = parser.find(content, position - contentFrom);
+        if (reference === undefined)
+            continue;
+        return {
+            ...reference,
+            from: contentFrom + reference.from,
+            to: contentFrom + reference.to
+        };
+    }
+    return undefined;
+}
+function findStyleReference(source, position) {
+    styleBlock.lastIndex = 0;
+    for (const block of source.matchAll(styleBlock)) {
+        const content = block[1] ?? '';
+        const contentFrom = (block.index ?? 0) + block[0].indexOf(content);
+        if (position < contentFrom || position >= contentFrom + content.length)
+            continue;
+        const languageId = styleBlockLanguage(block[0]);
+        if (languageId === undefined)
+            continue;
+        const reference = findStylesheetReference(content, position - contentFrom, languageId);
+        if (reference === undefined)
+            continue;
+        return {
+            ...reference,
+            from: contentFrom + reference.from,
+            to: contentFrom + reference.to
+        };
+    }
+    return undefined;
+}
+function styleBlockLanguage(block) {
+    const openingTag = block.slice(0, block.indexOf('>') + 1);
+    const value = styleLanguage.exec(openingTag)?.[2]?.toLowerCase();
+    if (value === undefined || value === 'css')
+        return 'css';
+    return value === 'scss' || value === 'sass' || value === 'less' ? value : undefined;
+}
+export const vueFileSpecifierParser = { find };
+export const vueNavigationSyntaxDefinition = {
+    hyphenSeparatesSymbol: false,
+    id: 'vue',
+    parser: vueFileSpecifierParser,
+    suffixes: ['.vue']
+};

package/dist/code-navigation/registry.js

@@ -0,0 +1,72 @@
+import { cNavigationSyntaxDefinition } from './languages/c.js';
+import { cFamilyNavigationSyntaxDefinition } from './languages/c-family.js';
+import { cppNavigationSyntaxDefinition } from './languages/cpp.js';
+import { csharpNavigationSyntaxDefinition } from './languages/csharp.js';
+import { cssNavigationSyntaxDefinition } from './languages/css.js';
+import { ecmascriptNavigationSyntaxDefinition } from './languages/ecmascript.js';
+import { goNavigationSyntaxDefinition } from './languages/go.js';
+import { htmlNavigationSyntaxDefinition } from './languages/html.js';
+import { jvmNavigationSyntaxDefinition } from './languages/jvm.js';
+import { lessNavigationSyntaxDefinition } from './languages/less.js';
+import { markdownNavigationSyntaxDefinition } from './languages/markdown.js';
+import { objectiveCNavigationSyntaxDefinition } from './languages/objective-c.js';
+import { objectiveCppNavigationSyntaxDefinition } from './languages/objective-cpp.js';
+import { pythonNavigationSyntaxDefinition } from './languages/python.js';
+import { rustNavigationSyntaxDefinition } from './languages/rust.js';
+import { sassNavigationSyntaxDefinition } from './languages/sass.js';
+import { scssNavigationSyntaxDefinition } from './languages/scss.js';
+import { vueNavigationSyntaxDefinition } from './languages/vue.js';
+const languages = [
+    cssNavigationSyntaxDefinition,
+    ecmascriptNavigationSyntaxDefinition,
+    goNavigationSyntaxDefinition,
+    htmlNavigationSyntaxDefinition,
+    jvmNavigationSyntaxDefinition,
+    csharpNavigationSyntaxDefinition,
+    lessNavigationSyntaxDefinition,
+    markdownNavigationSyntaxDefinition,
+    pythonNavigationSyntaxDefinition,
+    sassNavigationSyntaxDefinition,
+    scssNavigationSyntaxDefinition,
+    cNavigationSyntaxDefinition,
+    cppNavigationSyntaxDefinition,
+    objectiveCNavigationSyntaxDefinition,
+    objectiveCppNavigationSyntaxDefinition,
+    cFamilyNavigationSyntaxDefinition,
+    rustNavigationSyntaxDefinition,
+    vueNavigationSyntaxDefinition
+];
+export function navigationLanguageForPath(path, source) {
+    const normalized = path.toLowerCase();
+    const candidates = languages.filter((language) => language.suffixes.some((suffix) => normalized.endsWith(suffix)));
+    if (candidates.length <= 1)
+        return candidates[0];
+    const probed = source === undefined ? [] : candidates.filter((candidate) => candidate.probe?.(source));
+    if (probed.length === 1)
+        return probed[0];
+    return candidates.find((candidate) => candidate.fallbackForAmbiguousSuffix);
+}
+export function fileSpecifierParser(path, source) {
+    return navigationLanguageForPath(path, source)?.parser;
+}
+export function navigationLanguages() {
+    return languages;
+}
+export function navigationSymbolAt(path, source, position) {
+    const expression = hyphenSeparatesNavigationSymbol(path)
+        ? /[\p{L}_$][\p{L}\p{N}_$]*/gu
+        : /-*[\p{L}_$][\p{L}\p{N}_$-]*/gu;
+    for (const candidate of source.matchAll(expression)) {
+        const value = candidate[0];
+        const from = candidate.index ?? 0;
+        if (position >= from && position < from + value.length)
+            return { value, from, to: from + value.length };
+    }
+    return undefined;
+}
+export function isNavigationSymbol(path, value) {
+    return (value.length > 0 && value.length <= 512 && navigationSymbolAt(path, value, 0)?.value === value);
+}
+export function hyphenSeparatesNavigationSymbol(path) {
+    return navigationLanguageForPath(path)?.hyphenSeparatesSymbol ?? false;
+}

package/dist/code-navigation/source-ranges.js

@@ -0,0 +1,17 @@
+export function rangeAtColumn(line, column, match, value, metadata, offset = 0) {
+    if (match === null || value === undefined || match.index === undefined)
+        return undefined;
+    const from = match.index + match[0].indexOf(value);
+    return column >= from && column < from + value.length
+        ? { value, from: offset + from, to: offset + from + value.length, ...metadata }
+        : undefined;
+}
+export function sourceLineAt(source, position) {
+    const from = source.lastIndexOf('\n', Math.max(0, position - 1)) + 1;
+    const to = source.indexOf('\n', position);
+    return {
+        text: source.slice(from, to < 0 ? source.length : to),
+        column: position - from,
+        from
+    };
+}