first commit

web-app/node_modules/@volar/language-core/lib/editor.d.ts

@@ -0,0 +1,34 @@
+import type { CodeInformation, Mapper } from './types';
+export declare function isHoverEnabled(info: CodeInformation): boolean;
+export declare function isInlayHintsEnabled(info: CodeInformation): boolean;
+export declare function isCodeLensEnabled(info: CodeInformation): boolean;
+export declare function isMonikerEnabled(info: CodeInformation): boolean;
+export declare function isInlineValueEnabled(info: CodeInformation): boolean;
+export declare function isSemanticTokensEnabled(info: CodeInformation): boolean;
+export declare function isCallHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isTypeHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isRenameEnabled(info: CodeInformation): boolean;
+export declare function isDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isTypeDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isReferencesEnabled(info: CodeInformation): boolean;
+export declare function isImplementationEnabled(info: CodeInformation): boolean;
+export declare function isHighlightEnabled(info: CodeInformation): boolean;
+export declare function isSymbolsEnabled(info: CodeInformation): boolean;
+export declare function isFoldingRangesEnabled(info: CodeInformation): boolean;
+export declare function isSelectionRangesEnabled(info: CodeInformation): boolean;
+export declare function isLinkedEditingEnabled(info: CodeInformation): boolean;
+export declare function isColorEnabled(info: CodeInformation): boolean;
+export declare function isDocumentLinkEnabled(info: CodeInformation): boolean;
+export declare function isDiagnosticsEnabled(info: CodeInformation): boolean;
+export declare function isCodeActionsEnabled(info: CodeInformation): boolean;
+export declare function isFormattingEnabled(info: CodeInformation): boolean;
+export declare function isCompletionEnabled(info: CodeInformation): boolean;
+export declare function isAutoInsertEnabled(info: CodeInformation): boolean;
+export declare function isSignatureHelpEnabled(info: CodeInformation): boolean;
+export declare function shouldReportDiagnostics(info: CodeInformation, source: string | undefined, code: string | number | undefined): boolean;
+export declare function resolveRenameNewName(newName: string, info: CodeInformation): string;
+export declare function resolveRenameEditText(text: string, info: CodeInformation): string;
+export declare function findOverlapCodeRange(start: number, end: number, map: Mapper, filter: (data: CodeInformation) => boolean): {
+    start: number;
+    end: number;
+} | undefined;

web-app/node_modules/@volar/language-core/lib/editor.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHoverEnabled = isHoverEnabled;
+exports.isInlayHintsEnabled = isInlayHintsEnabled;
+exports.isCodeLensEnabled = isCodeLensEnabled;
+exports.isMonikerEnabled = isMonikerEnabled;
+exports.isInlineValueEnabled = isInlineValueEnabled;
+exports.isSemanticTokensEnabled = isSemanticTokensEnabled;
+exports.isCallHierarchyEnabled = isCallHierarchyEnabled;
+exports.isTypeHierarchyEnabled = isTypeHierarchyEnabled;
+exports.isRenameEnabled = isRenameEnabled;
+exports.isDefinitionEnabled = isDefinitionEnabled;
+exports.isTypeDefinitionEnabled = isTypeDefinitionEnabled;
+exports.isReferencesEnabled = isReferencesEnabled;
+exports.isImplementationEnabled = isImplementationEnabled;
+exports.isHighlightEnabled = isHighlightEnabled;
+exports.isSymbolsEnabled = isSymbolsEnabled;
+exports.isFoldingRangesEnabled = isFoldingRangesEnabled;
+exports.isSelectionRangesEnabled = isSelectionRangesEnabled;
+exports.isLinkedEditingEnabled = isLinkedEditingEnabled;
+exports.isColorEnabled = isColorEnabled;
+exports.isDocumentLinkEnabled = isDocumentLinkEnabled;
+exports.isDiagnosticsEnabled = isDiagnosticsEnabled;
+exports.isCodeActionsEnabled = isCodeActionsEnabled;
+exports.isFormattingEnabled = isFormattingEnabled;
+exports.isCompletionEnabled = isCompletionEnabled;
+exports.isAutoInsertEnabled = isAutoInsertEnabled;
+exports.isSignatureHelpEnabled = isSignatureHelpEnabled;
+exports.shouldReportDiagnostics = shouldReportDiagnostics;
+exports.resolveRenameNewName = resolveRenameNewName;
+exports.resolveRenameEditText = resolveRenameEditText;
+exports.findOverlapCodeRange = findOverlapCodeRange;
+function isHoverEnabled(info) {
+    return !!info.semantic;
+}
+function isInlayHintsEnabled(info) {
+    return !!info.semantic;
+}
+function isCodeLensEnabled(info) {
+    return !!info.semantic;
+}
+function isMonikerEnabled(info) {
+    return !!info.semantic;
+}
+function isInlineValueEnabled(info) {
+    return !!info.semantic;
+}
+function isSemanticTokensEnabled(info) {
+    return typeof info.semantic === 'object'
+        ? info.semantic.shouldHighlight?.() ?? true
+        : !!info.semantic;
+}
+function isCallHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+function isTypeHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+function isRenameEnabled(info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.shouldRename?.() ?? true
+        : !!info.navigation;
+}
+function isDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+function isTypeDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+function isReferencesEnabled(info) {
+    return !!info.navigation;
+}
+function isImplementationEnabled(info) {
+    return !!info.navigation;
+}
+function isHighlightEnabled(info) {
+    return !!info.navigation;
+}
+function isSymbolsEnabled(info) {
+    return !!info.structure;
+}
+function isFoldingRangesEnabled(info) {
+    return !!info.structure;
+}
+function isSelectionRangesEnabled(info) {
+    return !!info.structure;
+}
+function isLinkedEditingEnabled(info) {
+    return !!info.structure;
+}
+function isColorEnabled(info) {
+    return !!info.structure;
+}
+function isDocumentLinkEnabled(info) {
+    return !!info.structure;
+}
+function isDiagnosticsEnabled(info) {
+    return !!info.verification;
+}
+function isCodeActionsEnabled(info) {
+    return !!info.verification;
+}
+function isFormattingEnabled(info) {
+    return !!info.format;
+}
+function isCompletionEnabled(info) {
+    return !!info.completion;
+}
+function isAutoInsertEnabled(info) {
+    return !!info.completion;
+}
+function isSignatureHelpEnabled(info) {
+    return !!info.completion;
+}
+// should...
+function shouldReportDiagnostics(info, source, code) {
+    return typeof info.verification === 'object'
+        ? info.verification.shouldReport?.(source, code) ?? true
+        : !!info.verification;
+}
+//  resolve...
+function resolveRenameNewName(newName, info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.resolveRenameNewName?.(newName) ?? newName
+        : newName;
+}
+function resolveRenameEditText(text, info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.resolveRenameEditText?.(text) ?? text
+        : text;
+}
+function findOverlapCodeRange(start, end, map, filter) {
+    let mappedStart;
+    let mappedEnd;
+    for (const [mapped, mapping] of map.toGeneratedLocation(start)) {
+        if (filter(mapping.data)) {
+            mappedStart = mapped;
+            break;
+        }
+    }
+    for (const [mapped, mapping] of map.toGeneratedLocation(end)) {
+        if (filter(mapping.data)) {
+            mappedEnd = mapped;
+            break;
+        }
+    }
+    if (mappedStart === undefined || mappedEnd === undefined) {
+        for (const mapping of map.mappings) {
+            if (filter(mapping.data)) {
+                const mappingStart = mapping.sourceOffsets[0];
+                const mappingEnd = mapping.sourceOffsets[mapping.sourceOffsets.length - 1] + mapping.lengths[mapping.lengths.length - 1];
+                const overlap = getOverlapRange(start, end, mappingStart, mappingEnd);
+                if (overlap) {
+                    const curMappedStart = (overlap.start - mappingStart) + mapping.generatedOffsets[0];
+                    const lastGeneratedLength = (mapping.generatedLengths ?? mapping.lengths)[mapping.generatedOffsets.length - 1];
+                    const curMappedEndOffset = Math.min(overlap.end - mapping.sourceOffsets[mapping.sourceOffsets.length - 1], lastGeneratedLength);
+                    const curMappedEnd = mapping.generatedOffsets[mapping.generatedOffsets.length - 1] + curMappedEndOffset;
+                    mappedStart = mappedStart === undefined ? curMappedStart : Math.min(mappedStart, curMappedStart);
+                    mappedEnd = mappedEnd === undefined ? curMappedEnd : Math.max(mappedEnd, curMappedEnd);
+                }
+            }
+        }
+    }
+    if (mappedStart !== undefined && mappedEnd !== undefined) {
+        return {
+            start: mappedStart,
+            end: mappedEnd,
+        };
+    }
+}
+function getOverlapRange(range1Start, range1End, range2Start, range2End) {
+    const start = Math.max(range1Start, range2Start);
+    const end = Math.min(range1End, range2End);
+    if (start > end) {
+        return undefined;
+    }
+    return {
+        start,
+        end,
+    };
+}
+//# sourceMappingURL=editor.js.map

web-app/node_modules/@volar/language-core/lib/editorFeatures.d.ts

@@ -0,0 +1,28 @@
+import type { CodeInformation } from './types';
+export declare function isHoverEnabled(info: CodeInformation): boolean;
+export declare function isInlayHintsEnabled(info: CodeInformation): boolean;
+export declare function isCodeLensEnabled(info: CodeInformation): boolean;
+export declare function isMonikerEnabled(info: CodeInformation): boolean;
+export declare function isInlineValueEnabled(info: CodeInformation): boolean;
+export declare function isSemanticTokensEnabled(info: CodeInformation): boolean;
+export declare function isCallHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isTypeHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isRenameEnabled(info: CodeInformation): boolean;
+export declare function isDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isTypeDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isReferencesEnabled(info: CodeInformation): boolean;
+export declare function isImplementationEnabled(info: CodeInformation): boolean;
+export declare function isHighlightEnabled(info: CodeInformation): boolean;
+export declare function isSymbolsEnabled(info: CodeInformation): boolean;
+export declare function isFoldingRangesEnabled(info: CodeInformation): boolean;
+export declare function isSelectionRangesEnabled(info: CodeInformation): boolean;
+export declare function isLinkedEditingEnabled(info: CodeInformation): boolean;
+export declare function isColorEnabled(info: CodeInformation): boolean;
+export declare function isDocumentLinkEnabled(info: CodeInformation): boolean;
+export declare function isDiagnosticsEnabled(info: CodeInformation): boolean;
+export declare function isCodeActionsEnabled(info: CodeInformation): boolean;
+export declare function isFormattingEnabled(info: CodeInformation): boolean;
+export declare function isCompletionEnabled(info: CodeInformation): boolean;
+export declare function isAutoInsertEnabled(info: CodeInformation): boolean;
+export declare function isSignatureHelpEnabled(info: CodeInformation): boolean;
+export declare function shouldReportDiagnostics(info: CodeInformation, source: string | undefined, code: string | number | undefined): boolean;

web-app/node_modules/@volar/language-core/lib/editorFeatures.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHoverEnabled = isHoverEnabled;
+exports.isInlayHintsEnabled = isInlayHintsEnabled;
+exports.isCodeLensEnabled = isCodeLensEnabled;
+exports.isMonikerEnabled = isMonikerEnabled;
+exports.isInlineValueEnabled = isInlineValueEnabled;
+exports.isSemanticTokensEnabled = isSemanticTokensEnabled;
+exports.isCallHierarchyEnabled = isCallHierarchyEnabled;
+exports.isTypeHierarchyEnabled = isTypeHierarchyEnabled;
+exports.isRenameEnabled = isRenameEnabled;
+exports.isDefinitionEnabled = isDefinitionEnabled;
+exports.isTypeDefinitionEnabled = isTypeDefinitionEnabled;
+exports.isReferencesEnabled = isReferencesEnabled;
+exports.isImplementationEnabled = isImplementationEnabled;
+exports.isHighlightEnabled = isHighlightEnabled;
+exports.isSymbolsEnabled = isSymbolsEnabled;
+exports.isFoldingRangesEnabled = isFoldingRangesEnabled;
+exports.isSelectionRangesEnabled = isSelectionRangesEnabled;
+exports.isLinkedEditingEnabled = isLinkedEditingEnabled;
+exports.isColorEnabled = isColorEnabled;
+exports.isDocumentLinkEnabled = isDocumentLinkEnabled;
+exports.isDiagnosticsEnabled = isDiagnosticsEnabled;
+exports.isCodeActionsEnabled = isCodeActionsEnabled;
+exports.isFormattingEnabled = isFormattingEnabled;
+exports.isCompletionEnabled = isCompletionEnabled;
+exports.isAutoInsertEnabled = isAutoInsertEnabled;
+exports.isSignatureHelpEnabled = isSignatureHelpEnabled;
+exports.shouldReportDiagnostics = shouldReportDiagnostics;
+function isHoverEnabled(info) {
+    return !!info.semantic;
+}
+function isInlayHintsEnabled(info) {
+    return !!info.semantic;
+}
+function isCodeLensEnabled(info) {
+    return !!info.semantic;
+}
+function isMonikerEnabled(info) {
+    return !!info.semantic;
+}
+function isInlineValueEnabled(info) {
+    return !!info.semantic;
+}
+function isSemanticTokensEnabled(info) {
+    return typeof info.semantic === 'object'
+        ? info.semantic.shouldHighlight?.() ?? true
+        : !!info.semantic;
+}
+function isCallHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+function isTypeHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+function isRenameEnabled(info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.shouldRename?.() ?? true
+        : !!info.navigation;
+}
+function isDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+function isTypeDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+function isReferencesEnabled(info) {
+    return !!info.navigation;
+}
+function isImplementationEnabled(info) {
+    return !!info.navigation;
+}
+function isHighlightEnabled(info) {
+    return !!info.navigation;
+}
+function isSymbolsEnabled(info) {
+    return !!info.structure;
+}
+function isFoldingRangesEnabled(info) {
+    return !!info.structure;
+}
+function isSelectionRangesEnabled(info) {
+    return !!info.structure;
+}
+function isLinkedEditingEnabled(info) {
+    return !!info.structure;
+}
+function isColorEnabled(info) {
+    return !!info.structure;
+}
+function isDocumentLinkEnabled(info) {
+    return !!info.structure;
+}
+function isDiagnosticsEnabled(info) {
+    return !!info.verification;
+}
+function isCodeActionsEnabled(info) {
+    return !!info.verification;
+}
+function isFormattingEnabled(info) {
+    return !!info.format;
+}
+function isCompletionEnabled(info) {
+    return !!info.completion;
+}
+function isAutoInsertEnabled(info) {
+    return !!info.completion;
+}
+function isSignatureHelpEnabled(info) {
+    return !!info.completion;
+}
+// should...
+function shouldReportDiagnostics(info, source, code) {
+    return typeof info.verification === 'object'
+        ? info.verification.shouldReport?.(source, code) ?? true
+        : !!info.verification;
+}
+//# sourceMappingURL=editorFeatures.js.map

web-app/node_modules/@volar/language-core/lib/linkedCodeMap.d.ts

@@ -0,0 +1,4 @@
+import { SourceMap } from '@volar/source-map';
+export declare class LinkedCodeMap extends SourceMap<any> {
+    getLinkedOffsets(start: number): Generator<number, void, unknown>;
+}

web-app/node_modules/@volar/language-core/lib/linkedCodeMap.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkedCodeMap = void 0;
+const source_map_1 = require("@volar/source-map");
+class LinkedCodeMap extends source_map_1.SourceMap {
+    *getLinkedOffsets(start) {
+        for (const mapped of this.toGeneratedLocation(start)) {
+            yield mapped[0];
+        }
+        for (const mapped of this.toSourceLocation(start)) {
+            yield mapped[0];
+        }
+    }
+}
+exports.LinkedCodeMap = LinkedCodeMap;
+//# sourceMappingURL=linkedCodeMap.js.map

web-app/node_modules/@volar/language-core/lib/types.d.ts

@@ -0,0 +1,155 @@
+import type { Mapping } from '@volar/source-map';
+import type { LinkedCodeMap } from './linkedCodeMap';
+export interface Mapper {
+    mappings: Mapping<CodeInformation>[];
+    toSourceRange(start: number, end: number, fallbackToAnyMatch: boolean, filter?: (data: CodeInformation) => boolean): Generator<readonly [number, number, Mapping<CodeInformation>, Mapping<CodeInformation>]>;
+    toGeneratedRange(start: number, end: number, fallbackToAnyMatch: boolean, filter?: (data: CodeInformation) => boolean): Generator<readonly [number, number, Mapping<CodeInformation>, Mapping<CodeInformation>]>;
+    toSourceLocation(generatedOffset: number, filter?: (data: CodeInformation) => boolean): Generator<readonly [number, Mapping<CodeInformation>]>;
+    toGeneratedLocation(sourceOffset: number, filter?: (data: CodeInformation) => boolean): Generator<readonly [number, Mapping<CodeInformation>]>;
+}
+export type MapperFactory = (mappings: Mapping<CodeInformation>[]) => Mapper;
+export interface Language<T = unknown> {
+    mapperFactory: MapperFactory;
+    plugins: LanguagePlugin<T>[];
+    scripts: {
+        get(id: T, includeFsFiles?: boolean, shouldRegister?: boolean): SourceScript<T> | undefined;
+        set(id: T, snapshot: IScriptSnapshot, languageId?: string, plugins?: LanguagePlugin<T>[]): SourceScript<T> | undefined;
+        delete(id: T): void;
+        fromVirtualCode(virtualCode: VirtualCode): SourceScript<T>;
+    };
+    maps: {
+        get(virtualCode: VirtualCode, sourceScript: SourceScript<T>): Mapper;
+        forEach(virtualCode: VirtualCode): Generator<[sourceScript: SourceScript<T>, map: Mapper]>;
+    };
+    linkedCodeMaps: {
+        get(virtualCode: VirtualCode): LinkedCodeMap | undefined;
+    };
+}
+export interface SourceScript<T = unknown> {
+    id: T;
+    languageId: string;
+    snapshot: IScriptSnapshot;
+    targetIds: Set<T>;
+    associatedIds: Set<T>;
+    associatedOnly: boolean;
+    isAssociationDirty?: boolean;
+    generated?: {
+        root: VirtualCode;
+        languagePlugin: LanguagePlugin<T>;
+        embeddedCodes: Map<string, VirtualCode>;
+    };
+}
+export type CodeMapping = Mapping<CodeInformation>;
+export interface VirtualCode {
+    id: string;
+    languageId: string;
+    snapshot: IScriptSnapshot;
+    mappings: CodeMapping[];
+    associatedScriptMappings?: Map<unknown, CodeMapping[]>;
+    embeddedCodes?: VirtualCode[];
+    linkedCodeMappings?: Mapping[];
+}
+/**
+ * CodeInformation is a configuration object attached to each CodeMapping (between source code and generated code,
+ * e.g. between the template code in a .vue file and the type-checkable TS code generated from it) that
+ * determines what code/language features are expected to be available for the mapping.
+ *
+ * Due to the dynamic nature of code generation and the fact that, for example, things like Code Actions
+ * and auto-complete shouldn't be triggerable on certain "in-between" regions of generated code, we need
+ * a way to shut off certain features in certain regions, while leaving them enabled in others.
+ */
+export interface CodeInformation {
+    /** virtual code is expected to support verification, where verification includes:
+     *
+     * - diagnostics (syntactic, semantic, and others, such as those generated by the TypeScript language service on generated TS code)
+     * - code actions (refactorings, quick fixes,etc.)
+     */
+    verification?: boolean | {
+        /**
+         * when present, `shouldReport` callback is invoked to determine whether a diagnostic
+         * raised in the generated code should be propagated back to the original source code.
+         * Note that when this callback is present, diagnostic processing (e.g. typechecking) will
+         * still be performed, but the results will not be reported back to the original source code. */
+        shouldReport?(source: string | undefined, code: string | number | undefined): boolean;
+    };
+    /** virtual code is expected to support assisted completion */
+    completion?: boolean | {
+        isAdditional?: boolean;
+        onlyImport?: boolean;
+    };
+    /** virtual code is expected correctly reflect semantic of the source code. Specifically this controls the following langauge features:
+     *
+     * - hover
+     * - inlay hints
+     * - code lens
+     * - semantic tokens
+     * - others
+     *
+     * Note that semantic diagnostics (e.g. TS type-checking) are covered by the `verification` property above.
+     */
+    semantic?: boolean | {
+        shouldHighlight?(): boolean;
+    };
+    /** virtual code is expected correctly reflect reference relationships of the source code */
+    navigation?: boolean | {
+        shouldRename?(): boolean;
+        resolveRenameNewName?(newName: string): string;
+        resolveRenameEditText?(newText: string): string;
+    };
+    /** virtual code is expected correctly reflect the structural information of the source code */
+    structure?: boolean;
+    /** virtual code is expected correctly reflect the format information of the source code */
+    format?: boolean;
+}
+export interface LanguagePlugin<T = unknown, K extends VirtualCode = VirtualCode> {
+    /**
+     * For files that are not opened in the IDE, the language ID will not be synchronized to the language server, so a hook is needed to parse the language ID of files that are known extension but not opened in the IDE.
+     */
+    getLanguageId(scriptId: T): string | undefined;
+    /**
+     * Generate a virtual code.
+     */
+    createVirtualCode?(scriptId: T, languageId: string, snapshot: IScriptSnapshot, ctx: CodegenContext<T>): K | undefined;
+    /**
+     * Incremental update a virtual code. If not provide, call createVirtualCode again.
+     */
+    updateVirtualCode?(scriptId: T, virtualCode: K, newSnapshot: IScriptSnapshot, ctx: CodegenContext<T>): K | undefined;
+    /**
+     * Cleanup a virtual code.
+     */
+    disposeVirtualCode?(scriptId: T, virtualCode: K): void;
+    /**
+     * Some file types should not be parsed or processed as TypeScript files,
+     * as they are used only as sources for generated files.
+     *
+     * This functionality is required only in TS plugin mode.
+     */
+    isAssociatedFileOnly?(scriptId: T, languageId: string): boolean;
+}
+export interface CodegenContext<T = unknown> {
+    getAssociatedScript(scriptId: T): SourceScript<T> | undefined;
+}
+export interface IScriptSnapshot {
+    /** Gets a portion of the script snapshot specified by [start, end). */
+    getText(start: number, end: number): string;
+    /** Gets the length of this script snapshot. */
+    getLength(): number;
+    /**
+     * Gets the TextChangeRange that describe how the text changed between this text and
+     * an older version.  This information is used by the incremental parser to determine
+     * what sections of the script need to be re-parsed.  'undefined' can be returned if the
+     * change range cannot be determined.  However, in that case, incremental parsing will
+     * not happen and the entire document will be re - parsed.
+     */
+    getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
+    /** Releases all resources held by this script snapshot */
+    dispose?(): void;
+}
+export interface TextChangeRange {
+    span: TextSpan;
+    newLength: number;
+}
+export interface TextSpan {
+    start: number;
+    length: number;
+}

web-app/node_modules/@volar/language-core/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

web-app/node_modules/@volar/language-core/lib/utils.d.ts

@@ -0,0 +1,12 @@
+export declare class FileMap<T> extends Map<string, T> {
+    private caseSensitive;
+    private originalFileNames;
+    constructor(caseSensitive: boolean);
+    keys(): IterableIterator<string>;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    set(key: string, value: T): this;
+    delete(key: string): boolean;
+    clear(): void;
+    normalizeId(id: string): string;
+}

web-app/node_modules/@volar/language-core/lib/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileMap = void 0;
+class FileMap extends Map {
+    constructor(caseSensitive) {
+        super();
+        this.caseSensitive = caseSensitive;
+        this.originalFileNames = new Map();
+    }
+    keys() {
+        return this.originalFileNames.values();
+    }
+    get(key) {
+        return super.get(this.normalizeId(key));
+    }
+    has(key) {
+        return super.has(this.normalizeId(key));
+    }
+    set(key, value) {
+        this.originalFileNames.set(this.normalizeId(key), key);
+        return super.set(this.normalizeId(key), value);
+    }
+    delete(key) {
+        this.originalFileNames.delete(this.normalizeId(key));
+        return super.delete(this.normalizeId(key));
+    }
+    clear() {
+        this.originalFileNames.clear();
+        return super.clear();
+    }
+    normalizeId(id) {
+        return this.caseSensitive ? id : id.toLowerCase();
+    }
+}
+exports.FileMap = FileMap;
+//# sourceMappingURL=utils.js.map