@reqlan/language 1.4.0

package/src/reqlan-path-references.ts

@@ -0,0 +1,140 @@
+/**
+ * Collects relative file path strings in .rq imports and embedded references, and rq: paths in comments.
+ */
+import type { Range } from 'vscode-languageserver';
+import { findCommentReferencesInText } from './reqlan-comment-resolver.js';
+import { findEmbeddedFileReferencesInText } from './reqlan-embedded-file-references.js';
+import { parseFileReferenceString } from './reqlan-file-references.js';
+import type { PathReference } from './file-path-rewrite.js';
+import { parseReqlanQuotedString, REQLAN_QUOTED_STRING_CAPTURE } from './reqlan-quoted-strings.js';
+
+const IMPORT_PATH_PATTERN = new RegExp(`(?:\\bfrom|\\bimport)\\s+(${REQLAN_QUOTED_STRING_CAPTURE})`, 'g');
+
+export function findImportPathReferencesInText(text: string, lineOffset = 0): PathReference[] {
+    const references: PathReference[] = [];
+    const lines = text.split(/\r?\n/);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+        const line = lines[lineIndex]!;
+        for (const match of line.matchAll(IMPORT_PATH_PATTERN)) {
+            const quoted = match[1]!;
+            const path = parseReqlanQuotedString(quoted);
+            const start = match.index! + match[0].indexOf(quoted);
+            references.push({
+                path,
+                range: {
+                    start: { line: lineOffset + lineIndex, character: start },
+                    end: { line: lineOffset + lineIndex, character: start + quoted.length }
+                }
+            });
+        }
+    }
+    return references;
+}
+
+export function findEmbeddedPathReferencesInText(text: string, lineOffset = 0): PathReference[] {
+    const references: PathReference[] = [];
+    for (const embedded of findEmbeddedFileReferencesInText(text, lineOffset)) {
+        const parsed = parseFileReferenceString(embedded.file);
+        if (!parsed.filePath) {
+            continue;
+        }
+        const quotedPattern = new RegExp(REQLAN_QUOTED_STRING_CAPTURE);
+        const embeddedText = text.slice(
+            textOffsetAtPosition(text, embedded.range.start),
+            textOffsetAtPosition(text, embedded.range.end)
+        );
+        const quotedMatch = quotedPattern.exec(embeddedText);
+        if (!quotedMatch) {
+            continue;
+        }
+        const quoted = quotedMatch[0];
+        const pathIndex = quotedMatch.index ?? embeddedText.indexOf(quoted);
+        const absoluteStart = textOffsetAtPosition(text, embedded.range.start) + pathIndex;
+        const startPos = offsetToPosition(text, absoluteStart);
+        references.push({
+            path: parsed.filePath,
+            range: {
+                start: startPos,
+                end: { line: startPos.line, character: startPos.character + quoted.length }
+            }
+        });
+    }
+    return references;
+}
+
+export function findCommentPathReferencesInText(text: string, lineOffset = 0): PathReference[] {
+    const references: PathReference[] = [];
+    for (const commentRef of findCommentReferencesInText(text, lineOffset)) {
+        if (!commentRef.path) {
+            continue;
+        }
+        const quotedPattern = new RegExp(REQLAN_QUOTED_STRING_CAPTURE);
+        const segmentStart = textOffsetAtPosition(text, commentRef.range.start);
+        const segmentEnd = textOffsetAtPosition(text, commentRef.range.end);
+        const segment = text.slice(segmentStart, segmentEnd);
+        const quotedMatch = quotedPattern.exec(segment);
+        if (!quotedMatch) {
+            continue;
+        }
+        const quoted = quotedMatch[0];
+        const pathIndex = quotedMatch.index ?? segment.indexOf(quoted);
+        const absoluteStart = segmentStart + pathIndex;
+        const startPos = offsetToPosition(text, absoluteStart);
+        references.push({
+            path: commentRef.path,
+            range: {
+                start: startPos,
+                end: { line: startPos.line, character: startPos.character + quoted.length }
+            }
+        });
+    }
+    return references;
+}
+
+export function findPathReferencesInMovedFile(text: string, isRqFile: boolean): PathReference[] {
+    const references = isRqFile
+        ? [...findImportPathReferencesInText(text), ...findEmbeddedPathReferencesInText(text)]
+        : findCommentPathReferencesInText(text);
+    return dedupePathReferences(references);
+}
+
+function dedupePathReferences(references: PathReference[]): PathReference[] {
+    const seen = new Set<string>();
+    const unique: PathReference[] = [];
+    for (const reference of references) {
+        const key = [
+            reference.range.start.line,
+            reference.range.start.character,
+            reference.range.end.line,
+            reference.range.end.character
+        ].join(':');
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(reference);
+    }
+    return unique;
+}
+
+function textOffsetAtLine(text: string, lineIndex: number): number {
+    const lines = text.split(/\r?\n/);
+    let offset = 0;
+    for (let index = 0; index < lineIndex; index++) {
+        offset += lines[index]!.length + 1;
+    }
+    return offset;
+}
+
+function textOffsetAtPosition(text: string, position: Range['start']): number {
+    return textOffsetAtLine(text, position.line) + position.character;
+}
+
+function offsetToPosition(text: string, offset: number): Range['start'] {
+    const before = text.slice(0, offset);
+    const lines = before.split(/\r?\n/);
+    return {
+        line: lines.length - 1,
+        character: lines[lines.length - 1]!.length
+    };
+}

package/src/reqlan-path-resolve.ts

@@ -0,0 +1,346 @@
+/**
+ * Resolves document-relative and import-root-aliased paths (default `@/`).
+ * rq:["../../../reqlan rq/extension/configuration.rq".configuration_location]
+ * rq:["../../../reqlan rq/extension/configuration.rq".configuration_import_roots]
+ * rq:["../../../reqlan rq/language/imports.rq".configuration_import_root_alias]
+ */
+import type { FileSystemProvider, LangiumDocument, URI } from 'langium';
+import { URI as UriCtor, UriUtils } from 'langium';
+
+export const DEFAULT_IMPORT_ROOT_ALIAS = '@';
+export const RQCONFIG_FILENAME = '.rqconfig.json';
+
+export interface ImportRootMapping {
+    alias: string;
+    /** Absolute URI of that alias’s import-root directory, when set. */
+    rootUri?: URI;
+}
+
+export type RqExportScope = 'workspace' | 'currentFile';
+export type RqExportRuntimeMode = 'interactive' | 'document' | 'print';
+export type RqExportClusterStrategy = 'deterministic' | 'hybrid';
+
+export interface RqHtmlExportConfig {
+    printEntryFileName?: string;
+    includeRequirementsPage?: boolean;
+    includeGraphPage?: boolean;
+    runtimeMode?: RqExportRuntimeMode;
+    clusterStrategy?: RqExportClusterStrategy;
+    includeIdeaPages?: boolean;
+    includeFilePages?: boolean;
+    includeCodeFilePages?: boolean;
+    includeClusterPages?: boolean;
+    includePrintPages?: boolean;
+}
+
+export interface RqExportConfig {
+    outputFolder?: string;
+    templateId?: string;
+    scope?: RqExportScope;
+    html?: RqHtmlExportConfig;
+}
+
+export interface RqConfig {
+    importRoots: ImportRootMapping[];
+    export?: RqExportConfig;
+}
+
+export interface PathResolveContext {
+    /** Workspace folders that contain documents (longest match wins). */
+    workspaceFolderUris?: readonly URI[];
+    /** Explicit workspace folder for tests; preferred over list lookup when set. */
+    workspaceFolderUri?: URI;
+    fileSystem?: FileSystemProvider;
+    /**
+     * Preloaded config. `undefined` loads nearest `.rqconfig.json` when fileSystem is set.
+     * `null` skips loading and uses defaults only.
+     */
+    config?: RqConfig | null;
+}
+
+export function defaultRqConfig(): RqConfig {
+    return { importRoots: [{ alias: DEFAULT_IMPORT_ROOT_ALIAS }] };
+}
+
+export function matchImportRootAlias(path: string, alias: string): string | undefined {
+    if (!alias || !path.startsWith(alias)) {
+        return undefined;
+    }
+    const afterAlias = path.slice(alias.length);
+    if (!afterAlias.startsWith('/')) {
+        return undefined;
+    }
+    return afterAlias.slice(1);
+}
+
+/** Longest matching alias wins when several mappings could apply. */
+export function matchImportRootMapping(
+    path: string,
+    mappings: readonly ImportRootMapping[]
+): { mapping: ImportRootMapping; remainder: string } | undefined {
+    const ordered = [...mappings]
+        .filter(mapping => mapping.alias.length > 0)
+        .sort((left, right) => right.alias.length - left.alias.length);
+    for (const mapping of ordered) {
+        const remainder = matchImportRootAlias(path, mapping.alias);
+        if (remainder !== undefined) {
+            return { mapping, remainder };
+        }
+    }
+    return undefined;
+}
+
+export function findWorkspaceFolderUri(
+    documentUri: URI,
+    folderUris: readonly URI[] | undefined
+): URI | undefined {
+    if (!folderUris || folderUris.length === 0) {
+        return undefined;
+    }
+    const documentPath = documentUri.toString();
+    let best: URI | undefined;
+    let bestLength = -1;
+    for (const folder of folderUris) {
+        const folderPath = folder.path.endsWith('/')
+            ? folder.toString()
+            : `${folder.toString()}/`;
+        const folderBase = folder.toString();
+        if (documentPath === folderBase || documentPath.startsWith(folderPath)) {
+            const length = folderBase.length;
+            if (length > bestLength) {
+                best = folder;
+                bestLength = length;
+            }
+        }
+    }
+    return best;
+}
+
+export function loadApplyingRqConfig(
+    startDirUri: URI,
+    fileSystem: FileSystemProvider
+): RqConfig | undefined {
+    let dir = startDirUri;
+    for (;;) {
+        const configUri = UriUtils.joinPath(dir, RQCONFIG_FILENAME);
+        if (fileSystem.existsSync(configUri) && !fileSystem.statSync(configUri).isDirectory) {
+            return parseRqConfig(configUri, fileSystem);
+        }
+        const parent = UriUtils.dirname(dir);
+        if (UriUtils.equals(parent, dir)) {
+            return undefined;
+        }
+        dir = parent;
+    }
+}
+
+function parseRqConfig(configUri: URI, fileSystem: FileSystemProvider): RqConfig | undefined {
+    let raw: unknown;
+    try {
+        raw = JSON.parse(fileSystem.readFileSync(configUri));
+    } catch {
+        return undefined;
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw as Record<string, unknown>;
+    const importRoots = parseImportRoots(record.importRoots, configUri);
+    if (record.importRoots !== undefined && importRoots === undefined) {
+        return undefined;
+    }
+    const parsedExport = parseExportConfig(record.export, UriUtils.dirname(configUri));
+    const config: RqConfig = {
+        importRoots: importRoots ?? defaultRqConfig().importRoots
+    };
+    if (parsedExport) {
+        config.export = parsedExport;
+    }
+    return config;
+}
+
+function parseImportRootEntry(entry: unknown, configDir: URI): ImportRootMapping | undefined {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return undefined;
+    }
+    const record = entry as Record<string, unknown>;
+    if (typeof record.alias !== 'string' || record.alias.length === 0) {
+        return undefined;
+    }
+    const mapping: ImportRootMapping = { alias: record.alias };
+    if (typeof record.root === 'string' && record.root.length > 0) {
+        mapping.rootUri = isAbsoluteUriOrPath(record.root)
+            ? toDirectoryUri(record.root)
+            : UriUtils.resolvePath(configDir, record.root);
+    }
+    return mapping;
+}
+
+function parseImportRoots(raw: unknown, configUri: URI): ImportRootMapping[] | undefined {
+    if (raw === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(raw)) {
+        return undefined;
+    }
+    const configDir = UriUtils.dirname(configUri);
+    const importRoots: ImportRootMapping[] = [];
+    for (const entry of raw) {
+        const mapping = parseImportRootEntry(entry, configDir);
+        if (mapping) {
+            importRoots.push(mapping);
+        }
+    }
+    return importRoots.length > 0 ? importRoots : defaultRqConfig().importRoots;
+}
+
+function parseExportConfig(raw: unknown, configDir: URI): RqExportConfig | undefined {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw as Record<string, unknown>;
+    const config: RqExportConfig = {};
+
+    if (typeof record.outputFolder === 'string' && record.outputFolder.trim().length > 0) {
+        config.outputFolder = isAbsoluteUriOrPath(record.outputFolder)
+            ? toDirectoryUri(record.outputFolder).fsPath
+            : UriUtils.resolvePath(configDir, record.outputFolder).fsPath;
+    }
+    if (typeof record.templateId === 'string' && record.templateId.trim().length > 0) {
+        config.templateId = record.templateId.trim();
+    }
+    if (record.scope === 'workspace' || record.scope === 'currentFile') {
+        config.scope = record.scope;
+    }
+    const html = parseHtmlExportConfig(record.html);
+    if (html) {
+        config.html = html;
+    }
+
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+
+function parseHtmlExportConfig(raw: unknown): RqHtmlExportConfig | undefined {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const record = raw as Record<string, unknown>;
+    const config: RqHtmlExportConfig = {};
+    if (typeof record.printEntryFileName === 'string' && record.printEntryFileName.trim().length > 0) {
+        config.printEntryFileName = record.printEntryFileName.trim();
+    }
+    if (typeof record.includeRequirementsPage === 'boolean') {
+        config.includeRequirementsPage = record.includeRequirementsPage;
+    }
+    if (typeof record.includeGraphPage === 'boolean') {
+        config.includeGraphPage = record.includeGraphPage;
+    }
+    if (record.runtimeMode === 'interactive' || record.runtimeMode === 'document' || record.runtimeMode === 'print') {
+        config.runtimeMode = record.runtimeMode;
+    }
+    if (record.clusterStrategy === 'deterministic' || record.clusterStrategy === 'hybrid') {
+        config.clusterStrategy = record.clusterStrategy;
+    }
+    if (typeof record.includeIdeaPages === 'boolean') {
+        config.includeIdeaPages = record.includeIdeaPages;
+    }
+    if (typeof record.includeFilePages === 'boolean') {
+        config.includeFilePages = record.includeFilePages;
+    }
+    if (typeof record.includeCodeFilePages === 'boolean') {
+        config.includeCodeFilePages = record.includeCodeFilePages;
+    }
+    if (typeof record.includeClusterPages === 'boolean') {
+        config.includeClusterPages = record.includeClusterPages;
+    }
+    if (typeof record.includePrintPages === 'boolean') {
+        config.includePrintPages = record.includePrintPages;
+    }
+    return Object.keys(config).length > 0 ? config : undefined;
+}
+
+function isAbsoluteUriOrPath(value: string): boolean {
+    return /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value) || value.startsWith('/');
+}
+
+function toDirectoryUri(value: string): URI {
+    if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(value)) {
+        return UriCtor.parse(value);
+    }
+    return UriCtor.file(value);
+}
+
+export function resolveRqConfig(document: LangiumDocument, context?: PathResolveContext): RqConfig {
+    if (context?.config === null) {
+        return defaultRqConfig();
+    }
+    if (context?.config) {
+        return context.config;
+    }
+    if (context?.fileSystem) {
+        const loaded = loadApplyingRqConfig(UriUtils.dirname(document.uri), context.fileSystem);
+        if (loaded) {
+            return loaded;
+        }
+    }
+    return defaultRqConfig();
+}
+
+export function resolveImportRootUri(
+    document: LangiumDocument,
+    context: PathResolveContext | undefined,
+    mapping: ImportRootMapping
+): URI | undefined {
+    if (mapping.rootUri) {
+        return mapping.rootUri;
+    }
+    if (context?.workspaceFolderUri) {
+        return context.workspaceFolderUri;
+    }
+    return findWorkspaceFolderUri(document.uri, context?.workspaceFolderUris);
+}
+
+/**
+ * Resolves a path string against the document directory, or against an import root when aliased.
+ */
+export function resolveDocumentPathUri(
+    path: string,
+    document: LangiumDocument,
+    context?: PathResolveContext
+): URI {
+    const config = resolveRqConfig(document, context);
+    const matched = matchImportRootMapping(path, config.importRoots);
+    if (!matched) {
+        return UriUtils.resolvePath(UriUtils.dirname(document.uri), path);
+    }
+    const importRoot = resolveImportRootUri(document, context, matched.mapping);
+    if (!importRoot) {
+        return UriUtils.resolvePath(UriUtils.dirname(document.uri), path);
+    }
+    return UriUtils.resolvePath(importRoot, matched.remainder);
+}
+
+export function workspaceFolderUrisFromManager(
+    folders: ReadonlyArray<{ uri: string }> | undefined
+): URI[] {
+    if (!folders) {
+        return [];
+    }
+    return folders.map(folder => UriCtor.parse(folder.uri));
+}
+
+export function pathResolveContextFromServices(services: {
+    shared: {
+        workspace: {
+            WorkspaceManager: { workspaceFolders?: ReadonlyArray<{ uri: string }> };
+            FileSystemProvider: FileSystemProvider;
+        };
+    };
+}): PathResolveContext {
+    return {
+        fileSystem: services.shared.workspace.FileSystemProvider,
+        workspaceFolderUris: workspaceFolderUrisFromManager(
+            services.shared.workspace.WorkspaceManager.workspaceFolders
+        )
+    };
+}

package/src/reqlan-quoted-strings.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared helpers for reqlan double- and single-quoted string literals.
+ */
+
+/** Capturing group for one quoted string (double or single). */
+export const REQLAN_QUOTED_STRING_CAPTURE = '(?:"(?:\\\\.|[^"\\\\])*"|\'(?:\\\\.|[^\'\\\\])*\')';
+
+export const REQLAN_QUOTED_STRING_PATTERN = new RegExp(REQLAN_QUOTED_STRING_CAPTURE, 'g');
+
+export function reqlanStringDelimiter(text: string): '"' | "'" | undefined {
+    if (text.startsWith('"')) {
+        return '"';
+    }
+    if (text.startsWith("'")) {
+        return "'";
+    }
+    return undefined;
+}
+
+export function unquoteReqlanString(text: string): string {
+    const delimiter = reqlanStringDelimiter(text);
+    if (!delimiter || !text.endsWith(delimiter)) {
+        return text;
+    }
+    return text.slice(1, -1).replace(/\\(.)/g, '$1');
+}
+
+export function parseReqlanQuotedString(quoted: string): string {
+    return unquoteReqlanString(quoted);
+}

package/src/reqlan-reference-at-position.ts

@@ -0,0 +1,154 @@
+/**
+ * Locates file path references at a cursor position and resolves them to files, folders, or missing paths.
+ */
+import type { CstNode, FileSystemProvider, LangiumDocument, LangiumDocuments } from 'langium';
+import { CstUtils, GrammarUtils } from 'langium';
+import type { Position, LocationLink } from 'vscode-languageserver';
+import {
+    findCommentReferencePartAt,
+    resolveCommentDefinitionLinks,
+    resolveFileUri
+} from './reqlan-comment-resolver.js';
+import { findEmbeddedFileReferenceAt } from './reqlan-embedded-file-references.js';
+import {
+    classifyReferenceUri,
+    listFolderFileNames,
+    resolveEmbeddedFileReferenceLink,
+    resolveFileReferenceLink,
+    type ReferenceResolution,
+    type ResolvedFileLink
+} from './reqlan-file-link-resolver.js';
+import {
+    isFileReference,
+    isFileSymbolReference,
+    type FileReference,
+    type FileSymbolReference
+} from './generated/ast.js';
+import type { PathResolveContext } from './reqlan-path-resolve.js';
+
+export const REQLAN_OPEN_FOLDER_COMMAND = 'reqlan.openFolderReference';
+export const REQLAN_FILE_REFERENCE_AT_REQUEST = 'reqlan/fileReferenceAt';
+export const REQLAN_COMMENT_DEFINITION_REQUEST = 'reqlan/commentDefinition';
+
+export function folderReferenceCommandTarget(folderUri: string): string {
+    return `command:${REQLAN_OPEN_FOLDER_COMMAND}?${encodeURIComponent(JSON.stringify([folderUri]))}`;
+}
+
+export function findFileReferenceAtPosition(
+    document: LangiumDocument,
+    position: Position,
+    documents: LangiumDocuments,
+    fileSystem: FileSystemProvider,
+    context?: PathResolveContext
+): ResolvedFileLink | undefined {
+    const pathContext = { ...context, fileSystem: context?.fileSystem ?? fileSystem };
+    const commentPart = findCommentReferencePartAt(document, position);
+    if (commentPart?.property === 'path' && commentPart.reference.path) {
+        return resolvePathReference(
+            document,
+            commentPart.reference.path,
+            commentPart.reference.range,
+            documents,
+            fileSystem,
+            pathContext
+        );
+    }
+    const embeddedReference = findEmbeddedFileReferenceAt(document, position);
+    if (embeddedReference) {
+        return resolveEmbeddedFileReferenceLink(embeddedReference, document, documents, fileSystem, pathContext);
+    }
+    const fileReference = findFileReferenceNodeAtPosition(document, position);
+    if (fileReference) {
+        return resolveFileReferenceLink(fileReference.node, documents, fileSystem, pathContext);
+    }
+    return undefined;
+}
+
+function resolvePathReference(
+    document: LangiumDocument,
+    path: string,
+    sourceRange: ResolvedFileLink['sourceRange'],
+    documents: LangiumDocuments,
+    fileSystem: FileSystemProvider,
+    context?: PathResolveContext
+): ResolvedFileLink | undefined {
+    const targetUri = resolveFileUri(path, document, context);
+    const resolution = classifyReferenceUri(targetUri, documents, fileSystem);
+    if (resolution === 'missing') {
+        return undefined;
+    }
+    if (resolution === 'folder') {
+        return {
+            sourceRange,
+            targetUri: targetUri.toString(),
+            resolution,
+            folderFiles: listFolderFileNames(fileSystem, targetUri)
+        };
+    }
+    const targetDocument = documents.getDocument(targetUri);
+    const target = targetDocument?.parseResult.value.$cstNode;
+    if (!targetDocument || !target) {
+        return undefined;
+    }
+    return {
+        sourceRange,
+        targetUri: targetDocument.textDocument.uri,
+        targetRange: target.range,
+        resolution: 'file'
+    };
+}
+
+function findFileReferenceNodeAtPosition(
+    document: LangiumDocument,
+    position: Position
+): { node: FileReference | FileSymbolReference; pathNode: CstNode } | undefined {
+    const root = document.parseResult.value.$cstNode;
+    if (!root) {
+        return undefined;
+    }
+    const offset = document.textDocument.offsetAt(position);
+    let current: CstNode | undefined = CstUtils.findLeafNodeAtOffset(root, offset);
+    while (current) {
+        const assignment = GrammarUtils.findAssignment(current);
+        const container = current.astNode;
+        if ((isFileReference(container) || isFileSymbolReference(container)) && assignment?.feature === 'file') {
+            const pathNode = GrammarUtils.findNodeForProperty(container.$cstNode, 'file');
+            if (pathNode) {
+                return { node: container, pathNode };
+            }
+        }
+        current = current.container;
+    }
+    return undefined;
+}
+
+export interface FileReferenceAtRequestResult {
+    sourceRange: ResolvedFileLink['sourceRange'];
+    targetUri: string;
+    resolution: ReferenceResolution;
+    folderFiles?: string[];
+}
+
+export function findCommentDefinitionAtPosition(
+    document: LangiumDocument,
+    position: Position,
+    documents: LangiumDocuments,
+    context?: PathResolveContext
+): LocationLink[] | undefined {
+    const commentPart = findCommentReferencePartAt(document, position);
+    if (commentPart?.property !== 'idea') {
+        return undefined;
+    }
+    return resolveCommentDefinitionLinks(commentPart.reference, document, documents, context);
+}
+
+export function fileReferenceAtRequestResult(
+    link: ResolvedFileLink
+): FileReferenceAtRequestResult {
+    return {
+        sourceRange: link.sourceRange,
+        targetUri: link.targetUri,
+        resolution: link.resolution ?? 'file',
+        folderFiles: link.folderFiles
+    };
+}