@ktjs/ts-plugin 0.1.4 → 0.1.6

package/dist/index.js

@@ -1,18 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const node_path_1 = __importDefault(require("node:path"));
-const DIAGNOSTIC_CANNOT_FIND_NAME = 2304;
-const IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-const KFOR_SINGLE_PATTERN = /^([A-Za-z_$][A-Za-z0-9_$]*)\s+(in|of)\s+([\s\S]+)$/;
-const KFOR_TUPLE_PATTERN = /^\(\s*([A-Za-z_$][A-Za-z0-9_$]*)(?:\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*))?(?:\s*,\s*([A-Za-z_$][A-Za-z0-9_$]*))?\s*\)\s+(in|of)\s+([\s\S]+)$/;
-const MEMBER_COMPLETION_PATTERN = /([A-Za-z_$][A-Za-z0-9_$]*(?:\s*(?:\.\s*[A-Za-z_$][A-Za-z0-9_$]*|\[\s*(?:'[^'\\]*(?:\\.[^'\\]*)*'|"[^"\\]*(?:\\.[^"\\]*)*"|\d+)\s*\]))*)\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)?$/;
+const ast_1 = require("./ast");
+const completion_1 = require("./completion");
+const constants_1 = require("./constants");
+const config_1 = require("./config");
+const identifiers_1 = require("./identifiers");
+const kfor_highlighting_1 = require("./kfor-highlighting");
+const scope_analysis_1 = require("./scope-analysis");
+const type_resolution_1 = require("./type-resolution");
 function init(modules) {
     const ts = modules.typescript;
     function create(info) {
         const languageService = info.languageService;
-        const config = resolveConfig(info.config);
+        const config = (0, config_1.resolveConfig)(info.config);
         const proxy = Object.create(null);
         for (const key of Object.keys(languageService)) {
             const member = languageService[key];
@@ -20,43 +19,67 @@ function init(modules) {
         }
         proxy.getSemanticDiagnostics = (fileName) => {
             const diagnostics = languageService.getSemanticDiagnostics(fileName);
-            if (!isJsxLikeFile(fileName)) {
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
                 return diagnostics;
             }
-            const analysis = getFileAnalysis(fileName, languageService, ts, config);
+            const analysis = (0, scope_analysis_1.getFileAnalysis)(fileName, languageService, ts, config);
             if (!analysis) {
                 return diagnostics;
             }
-            return diagnostics.filter((diag) => {
-                if (diag.code !== DIAGNOSTIC_CANNOT_FIND_NAME || diag.start == null || diag.length == null) {
+            return diagnostics.filter((diagnostic) => {
+                if (diagnostic.code !== constants_1.DIAGNOSTIC_CANNOT_FIND_NAME ||
+                    diagnostic.start == null ||
+                    diagnostic.length == null) {
                     return true;
                 }
-                const name = analysis.sourceFile.text.slice(diag.start, diag.start + diag.length).trim();
-                if (!isValidIdentifier(name)) {
+                const name = analysis.sourceFile.text.slice(diagnostic.start, diagnostic.start + diagnostic.length).trim();
+                if (!(0, identifiers_1.isValidIdentifier)(name)) {
                     return true;
                 }
-                return !isSuppressed(diag.start, name, analysis.scopes);
+                return !(0, scope_analysis_1.isSuppressed)(diagnostic.start, name, analysis.scopes);
             });
         };
+        proxy.getEncodedSemanticClassifications = (fileName, span, format) => {
+            const classifications = languageService.getEncodedSemanticClassifications(fileName, span, format);
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
+                return classifications;
+            }
+            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                return classifications;
+            }
+            return (0, kfor_highlighting_1.addKForSemanticClassifications)(classifications, sourceFile, span, format, ts, config);
+        };
+        proxy.getEncodedSyntacticClassifications = (fileName, span) => {
+            const classifications = languageService.getEncodedSyntacticClassifications(fileName, span);
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
+                return classifications;
+            }
+            const sourceFile = languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                return classifications;
+            }
+            return (0, kfor_highlighting_1.addKForSyntacticClassifications)(classifications, sourceFile, span, ts, config);
+        };
         proxy.getQuickInfoAtPosition = (fileName, position) => {
             const quickInfo = languageService.getQuickInfoAtPosition(fileName, position);
-            if (!isJsxLikeFile(fileName)) {
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
                 return quickInfo;
             }
-            const analysis = getFileAnalysis(fileName, languageService, ts, config);
+            const analysis = (0, scope_analysis_1.getFileAnalysis)(fileName, languageService, ts, config);
             if (!analysis) {
                 return quickInfo;
             }
-            const identifier = findIdentifierAtPosition(analysis.sourceFile, position, ts);
+            const identifier = (0, ast_1.findIdentifierAtPosition)(analysis.sourceFile, position, ts);
             if (!identifier) {
                 return quickInfo;
             }
-            const bindings = collectBindingsAtPosition(position, analysis.scopes);
+            const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
             const binding = bindings.get(identifier.text);
             if (!binding) {
                 return quickInfo;
             }
-            const typeText = formatTypeList(binding.types, analysis.checker, identifier, ts);
+            const typeText = (0, type_resolution_1.formatTypeList)(binding.types, analysis.checker, identifier, ts);
             return {
                 kind: ts.ScriptElementKind.localVariableElement,
                 kindModifiers: '',
@@ -69,35 +92,36 @@ function init(modules) {
         };
         proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
             const completions = languageService.getCompletionsAtPosition(fileName, position, options, formattingSettings);
-            if (!isJsxLikeFile(fileName)) {
+            if (!(0, config_1.isJsxLikeFile)(fileName)) {
                 return completions;
             }
-            const analysis = getFileAnalysis(fileName, languageService, ts, config);
+            const analysis = (0, scope_analysis_1.getFileAnalysis)(fileName, languageService, ts, config);
             if (!analysis) {
                 return completions;
             }
-            const bindings = collectBindingsAtPosition(position, analysis.scopes);
+            const bindings = (0, scope_analysis_1.collectBindingsAtPosition)(position, analysis.scopes);
             if (bindings.size === 0) {
                 return completions;
             }
-            const contextNode = findInnermostNode(analysis.sourceFile, normalizePosition(position, analysis.sourceFile), ts) || analysis.sourceFile;
-            const localBindings = createBindingTypeMap(bindings);
-            const memberContext = getMemberCompletionContext(analysis.sourceFile.text, position);
+            const contextNode = (0, ast_1.findInnermostNode)(analysis.sourceFile, (0, ast_1.normalizePosition)(position, analysis.sourceFile), ts) ||
+                analysis.sourceFile;
+            const localBindings = (0, completion_1.createBindingTypeMap)(bindings);
+            const memberContext = (0, completion_1.getMemberCompletionContext)(analysis.sourceFile.text, position);
             if (memberContext) {
-                const receiverTypes = resolveExpressionTypesFromText(memberContext.receiver, {
+                const receiverTypes = (0, type_resolution_1.resolveExpressionTypesFromText)(memberContext.receiver, {
                     checker: analysis.checker,
                     ts,
                     scopeNode: contextNode,
                     localBindings,
                 });
-                const memberEntries = createMemberCompletionEntries(receiverTypes, memberContext.prefix, analysis.checker, contextNode, ts);
+                const memberEntries = (0, completion_1.createMemberCompletionEntries)(receiverTypes, memberContext.prefix, analysis.checker, contextNode, ts);
                 if (memberEntries.length > 0) {
-                    return mergeCompletionInfo(completions, memberEntries, true);
+                    return (0, completion_1.mergeCompletionInfo)(completions, memberEntries, true);
                 }
             }
-            const aliasEntries = createAliasCompletionEntries(bindings, analysis.sourceFile.text, position, ts);
+            const aliasEntries = (0, completion_1.createAliasCompletionEntries)(bindings, analysis.sourceFile.text, position, ts);
             if (aliasEntries.length > 0) {
-                return mergeCompletionInfo(completions, aliasEntries, false);
+                return (0, completion_1.mergeCompletionInfo)(completions, aliasEntries, false);
             }
             return completions;
         };
@@ -105,608 +129,4 @@ function init(modules) {
     }
     return { create };
 }
-function resolveConfig(config) {
-    return {
-        forAttr: config?.forAttr || 'k-for',
-        itemAttr: config?.itemAttr || 'k-for-item',
-        indexAttr: config?.indexAttr || 'k-for-index',
-        itemName: config?.itemName || 'item',
-        indexName: config?.indexName || 'index',
-        allowOfKeyword: config?.allowOfKeyword !== false,
-    };
-}
-function isJsxLikeFile(fileName) {
-    const ext = node_path_1.default.extname(fileName).toLowerCase();
-    return ext === '.tsx' || ext === '.jsx';
-}
-function getFileAnalysis(fileName, languageService, ts, config) {
-    const program = languageService.getProgram();
-    if (!program) {
-        return undefined;
-    }
-    const sourceFile = program.getSourceFile(fileName);
-    if (!sourceFile) {
-        return undefined;
-    }
-    const checker = program.getTypeChecker();
-    const scopes = collectKForScopes(sourceFile, checker, ts, config);
-    if (scopes.length === 0) {
-        return undefined;
-    }
-    return { sourceFile, checker, scopes };
-}
-function collectKForScopes(sourceFile, checker, ts, config) {
-    const scopes = [];
-    const visit = (node) => {
-        if (ts.isJsxElement(node)) {
-            const forAttr = getJsxAttribute(node.openingElement, config.forAttr, ts);
-            if (forAttr) {
-                const bindings = resolveScopeBindings(node.openingElement, forAttr, checker, config, ts);
-                const start = node.openingElement.end;
-                const end = node.closingElement.getStart(sourceFile);
-                if (start < end && bindings.length > 0) {
-                    scopes.push({ start, end, bindings });
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sourceFile);
-    return scopes;
-}
-function resolveScopeBindings(opening, forAttr, checker, config, ts) {
-    const forExpression = getAttributeText(forAttr, ts);
-    if (forExpression !== undefined) {
-        const parsed = parseKForExpression(forExpression, config.allowOfKeyword);
-        if (parsed) {
-            const sourceTypes = resolveExpressionTypesFromText(parsed.source, {
-                checker,
-                ts,
-                scopeNode: opening,
-            });
-            return createBindings(parsed.aliases, sourceTypes, checker, opening, ts);
-        }
-    }
-    const itemName = getScopeName(opening, config.itemAttr, config.itemName, ts);
-    const indexName = getScopeName(opening, config.indexAttr, config.indexName, ts);
-    const aliases = uniqueIdentifiers([itemName, indexName]);
-    const sourceTypes = getLegacyForSourceTypes(forAttr, checker, ts);
-    return createBindings(aliases, sourceTypes, checker, opening, ts);
-}
-function createBindings(names, sourceTypes, checker, scopeNode, ts) {
-    if (names.length === 0) {
-        return [];
-    }
-    const inferred = inferBindingTypes(sourceTypes, names.length, checker, scopeNode, ts);
-    const bindings = [];
-    for (let i = 0; i < names.length; i++) {
-        bindings.push({
-            name: names[i],
-            types: inferred[i] || [],
-        });
-    }
-    return bindings;
-}
-function inferBindingTypes(sourceTypes, bindingCount, checker, scopeNode, ts) {
-    const slots = Array.from({ length: bindingCount }, () => []);
-    const candidates = expandUnionTypes(sourceTypes, ts);
-    for (let i = 0; i < candidates.length; i++) {
-        const sourceType = checker.getApparentType(candidates[i]);
-        const elementType = checker.getIndexTypeOfType(sourceType, ts.IndexKind.Number);
-        const stringValueType = elementType ? undefined : checker.getIndexTypeOfType(sourceType, ts.IndexKind.String);
-        const valueTypes = elementType ? [elementType] : stringValueType ? [stringValueType] : [];
-        if (valueTypes.length === 0) {
-            continue;
-        }
-        slots[0].push(...valueTypes);
-        if (bindingCount > 1) {
-            slots[1].push(elementType ? checker.getNumberType() : checker.getStringType());
-        }
-        if (bindingCount > 2) {
-            slots[2].push(checker.getNumberType());
-        }
-    }
-    for (let i = 0; i < slots.length; i++) {
-        slots[i] = uniqueTypes(slots[i], checker, scopeNode, ts);
-    }
-    return slots;
-}
-function expandUnionTypes(types, ts) {
-    const result = [];
-    for (let i = 0; i < types.length; i++) {
-        const type = types[i];
-        if (type.flags & ts.TypeFlags.Union) {
-            const union = type;
-            result.push(...union.types);
-            continue;
-        }
-        result.push(type);
-    }
-    return result;
-}
-function getLegacyForSourceTypes(forAttr, checker, ts) {
-    const expression = getAttributeExpression(forAttr, ts);
-    if (!expression || ts.isStringLiteralLike(expression)) {
-        return [];
-    }
-    return [checker.getTypeAtLocation(expression)];
-}
-function getAttributeExpression(attr, ts) {
-    if (!attr?.initializer || !ts.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
-        return undefined;
-    }
-    return attr.initializer.expression;
-}
-function resolveExpressionTypesFromText(raw, context) {
-    const value = raw.trim();
-    if (!value) {
-        return [];
-    }
-    const sourceFile = context.ts.createSourceFile('__k_for_expression.ts', `(${value});`, context.ts.ScriptTarget.Latest, true, context.ts.ScriptKind.TS);
-    if (sourceFile.statements.length === 0) {
-        return [];
-    }
-    const statement = sourceFile.statements[0];
-    if (!context.ts.isExpressionStatement(statement)) {
-        return [];
-    }
-    const types = resolveExpressionTypes(statement.expression, context);
-    return uniqueTypes(types, context.checker, context.scopeNode, context.ts);
-}
-function resolveExpressionTypes(expr, context) {
-    const ts = context.ts;
-    const target = unwrapExpression(expr, ts);
-    if (ts.isIdentifier(target)) {
-        return resolveIdentifierTypes(target.text, context);
-    }
-    if (ts.isPropertyAccessExpression(target)) {
-        const objectTypes = resolveExpressionTypes(target.expression, context);
-        return resolvePropertyTypes(objectTypes, target.name.text, context, false);
-    }
-    if (ts.isElementAccessExpression(target)) {
-        const objectTypes = resolveExpressionTypes(target.expression, context);
-        const arg = target.argumentExpression;
-        if (!arg) {
-            return [];
-        }
-        if (ts.isStringLiteralLike(arg)) {
-            return resolvePropertyTypes(objectTypes, arg.text, context, true);
-        }
-        if (ts.isNumericLiteral(arg)) {
-            return resolveNumericElementTypes(objectTypes, Number(arg.text), context);
-        }
-        return resolveIndexedTypes(objectTypes, context);
-    }
-    if (ts.isCallExpression(target)) {
-        const calleeTypes = resolveExpressionTypes(target.expression, context);
-        const result = [];
-        for (let i = 0; i < calleeTypes.length; i++) {
-            const signatures = context.checker.getSignaturesOfType(calleeTypes[i], ts.SignatureKind.Call);
-            for (let j = 0; j < signatures.length; j++) {
-                result.push(context.checker.getReturnTypeOfSignature(signatures[j]));
-            }
-        }
-        return uniqueTypes(result, context.checker, context.scopeNode, ts);
-    }
-    if (ts.isConditionalExpression(target)) {
-        const left = resolveExpressionTypes(target.whenTrue, context);
-        const right = resolveExpressionTypes(target.whenFalse, context);
-        return uniqueTypes([...left, ...right], context.checker, context.scopeNode, ts);
-    }
-    if (ts.isBinaryExpression(target) &&
-        (target.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
-            target.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-            target.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken)) {
-        const left = resolveExpressionTypes(target.left, context);
-        const right = resolveExpressionTypes(target.right, context);
-        return uniqueTypes([...left, ...right], context.checker, context.scopeNode, ts);
-    }
-    return [];
-}
-function unwrapExpression(expr, ts) {
-    let current = expr;
-    while (true) {
-        if (ts.isParenthesizedExpression(current)) {
-            current = current.expression;
-            continue;
-        }
-        if (ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isSatisfiesExpression(current)) {
-            current = current.expression;
-            continue;
-        }
-        if (ts.isNonNullExpression(current)) {
-            current = current.expression;
-            continue;
-        }
-        return current;
-    }
-}
-function resolveIdentifierTypes(name, context) {
-    const localTypes = context.localBindings?.get(name);
-    if (localTypes && localTypes.length > 0) {
-        return [...localTypes];
-    }
-    const symbol = resolveSymbolInScope(name, context);
-    if (!symbol) {
-        return [];
-    }
-    return [context.checker.getTypeOfSymbolAtLocation(symbol, context.scopeNode)];
-}
-function resolveSymbolInScope(name, context) {
-    const symbols = context.checker.getSymbolsInScope(context.scopeNode, context.ts.SymbolFlags.Value | context.ts.SymbolFlags.Alias);
-    for (let i = 0; i < symbols.length; i++) {
-        const symbol = symbols[i];
-        if (symbol.getName() !== name) {
-            continue;
-        }
-        if (symbol.flags & context.ts.SymbolFlags.Alias) {
-            const aliased = context.checker.getAliasedSymbol(symbol);
-            if (aliased.flags & context.ts.SymbolFlags.Value) {
-                return aliased;
-            }
-            continue;
-        }
-        if (symbol.flags & context.ts.SymbolFlags.Value) {
-            return symbol;
-        }
-    }
-    return undefined;
-}
-function resolvePropertyTypes(objectTypes, propertyName, context, allowStringIndexFallback) {
-    const result = [];
-    for (let i = 0; i < objectTypes.length; i++) {
-        const targetType = context.checker.getApparentType(objectTypes[i]);
-        const prop = context.checker.getPropertyOfType(targetType, propertyName);
-        if (prop) {
-            result.push(context.checker.getTypeOfSymbolAtLocation(prop, context.scopeNode));
-            continue;
-        }
-        if (allowStringIndexFallback) {
-            const stringIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.String);
-            if (stringIndexType) {
-                result.push(stringIndexType);
-            }
-        }
-    }
-    return uniqueTypes(result, context.checker, context.scopeNode, context.ts);
-}
-function resolveNumericElementTypes(objectTypes, index, context) {
-    const result = [];
-    const indexName = String(index);
-    for (let i = 0; i < objectTypes.length; i++) {
-        const targetType = context.checker.getApparentType(objectTypes[i]);
-        const property = context.checker.getPropertyOfType(targetType, indexName);
-        if (property) {
-            result.push(context.checker.getTypeOfSymbolAtLocation(property, context.scopeNode));
-        }
-        const numericIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.Number);
-        if (numericIndexType) {
-            result.push(numericIndexType);
-        }
-    }
-    return uniqueTypes(result, context.checker, context.scopeNode, context.ts);
-}
-function resolveIndexedTypes(objectTypes, context) {
-    const result = [];
-    for (let i = 0; i < objectTypes.length; i++) {
-        const targetType = context.checker.getApparentType(objectTypes[i]);
-        const stringIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.String);
-        if (stringIndexType) {
-            result.push(stringIndexType);
-        }
-        const numericIndexType = context.checker.getIndexTypeOfType(targetType, context.ts.IndexKind.Number);
-        if (numericIndexType) {
-            result.push(numericIndexType);
-        }
-    }
-    return uniqueTypes(result, context.checker, context.scopeNode, context.ts);
-}
-function createMemberCompletionEntries(types, prefix, checker, scopeNode, ts) {
-    if (types.length === 0) {
-        return [];
-    }
-    const entries = new Map();
-    const typeCandidates = uniqueTypes(types, checker, scopeNode, ts);
-    for (let i = 0; i < typeCandidates.length; i++) {
-        const props = checker.getPropertiesOfType(checker.getApparentType(typeCandidates[i]));
-        for (let j = 0; j < props.length; j++) {
-            const prop = props[j];
-            const name = prop.getName();
-            if (!isValidIdentifier(name) || name.startsWith('__@')) {
-                continue;
-            }
-            if (prefix && !name.startsWith(prefix)) {
-                continue;
-            }
-            if (entries.has(name)) {
-                continue;
-            }
-            entries.set(name, {
-                name,
-                kind: getCompletionKind(prop, ts),
-                kindModifiers: '',
-                sortText: '0',
-            });
-        }
-    }
-    return Array.from(entries.values()).sort((a, b) => a.name.localeCompare(b.name));
-}
-function createAliasCompletionEntries(bindings, text, position, ts) {
-    const prefix = getIdentifierPrefix(text, position);
-    if (prefix.isMemberAccess) {
-        return [];
-    }
-    const entries = [];
-    for (const binding of bindings.values()) {
-        if (prefix.text && !binding.name.startsWith(prefix.text)) {
-            continue;
-        }
-        entries.push({
-            name: binding.name,
-            kind: ts.ScriptElementKind.localVariableElement,
-            kindModifiers: '',
-            sortText: '0',
-        });
-    }
-    return entries;
-}
-function getCompletionKind(symbol, ts) {
-    const flags = symbol.flags;
-    if (flags & ts.SymbolFlags.Method) {
-        return ts.ScriptElementKind.memberFunctionElement;
-    }
-    if (flags & ts.SymbolFlags.Function) {
-        return ts.ScriptElementKind.functionElement;
-    }
-    if (flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor | ts.SymbolFlags.Property)) {
-        return ts.ScriptElementKind.memberVariableElement;
-    }
-    return ts.ScriptElementKind.memberVariableElement;
-}
-function mergeCompletionInfo(completions, extraEntries, forceMemberCompletion) {
-    if (!completions) {
-        return {
-            isGlobalCompletion: !forceMemberCompletion,
-            isMemberCompletion: forceMemberCompletion,
-            isNewIdentifierLocation: !forceMemberCompletion,
-            entries: extraEntries,
-        };
-    }
-    const seen = new Set();
-    for (let i = 0; i < completions.entries.length; i++) {
-        seen.add(completions.entries[i].name);
-    }
-    const merged = completions.entries.slice();
-    for (let i = 0; i < extraEntries.length; i++) {
-        const entry = extraEntries[i];
-        if (seen.has(entry.name)) {
-            continue;
-        }
-        seen.add(entry.name);
-        merged.push(entry);
-    }
-    return {
-        ...completions,
-        isMemberCompletion: completions.isMemberCompletion || forceMemberCompletion,
-        entries: merged,
-    };
-}
-function createBindingTypeMap(bindings) {
-    const map = new Map();
-    for (const binding of bindings.values()) {
-        map.set(binding.name, binding.types);
-    }
-    return map;
-}
-function getMemberCompletionContext(text, position) {
-    const sliceStart = Math.max(0, position - 200);
-    const snippet = text.slice(sliceStart, position);
-    const match = MEMBER_COMPLETION_PATTERN.exec(snippet);
-    if (!match) {
-        return undefined;
-    }
-    return {
-        receiver: match[1],
-        prefix: match[2] || '',
-    };
-}
-function getIdentifierPrefix(text, position) {
-    let start = position;
-    while (start > 0 && isIdentifierPart(text.charCodeAt(start - 1))) {
-        start--;
-    }
-    const prefix = text.slice(start, position);
-    const isMemberAccess = start > 0 && text.charCodeAt(start - 1) === 46;
-    return { text: prefix, isMemberAccess };
-}
-function isIdentifierPart(code) {
-    return ((code >= 65 && code <= 90) ||
-        (code >= 97 && code <= 122) ||
-        (code >= 48 && code <= 57) ||
-        code === 95 ||
-        code === 36);
-}
-function findIdentifierAtPosition(sourceFile, position, ts) {
-    const exact = findInnermostNode(sourceFile, normalizePosition(position, sourceFile), ts);
-    if (exact && ts.isIdentifier(exact)) {
-        return exact;
-    }
-    if (position > 0) {
-        const prev = findInnermostNode(sourceFile, normalizePosition(position - 1, sourceFile), ts);
-        if (prev && ts.isIdentifier(prev)) {
-            return prev;
-        }
-    }
-    return undefined;
-}
-function normalizePosition(position, sourceFile) {
-    const max = Math.max(sourceFile.text.length - 1, 0);
-    if (position < 0) {
-        return 0;
-    }
-    if (position > max) {
-        return max;
-    }
-    return position;
-}
-function findInnermostNode(node, position, ts) {
-    if (position < node.getFullStart() || position >= node.end) {
-        return undefined;
-    }
-    let match;
-    ts.forEachChild(node, (child) => {
-        const childMatch = findInnermostNode(child, position, ts);
-        if (childMatch) {
-            match = childMatch;
-        }
-    });
-    return match || node;
-}
-function collectBindingsAtPosition(position, scopes) {
-    const bindings = new Map();
-    for (let i = scopes.length - 1; i >= 0; i--) {
-        const scope = scopes[i];
-        if (position < scope.start || position >= scope.end) {
-            continue;
-        }
-        for (let j = 0; j < scope.bindings.length; j++) {
-            const binding = scope.bindings[j];
-            if (!bindings.has(binding.name)) {
-                bindings.set(binding.name, binding);
-            }
-        }
-    }
-    return bindings;
-}
-function formatTypeList(types, checker, scopeNode, ts) {
-    if (types.length === 0) {
-        return 'any';
-    }
-    const texts = new Set();
-    for (let i = 0; i < types.length; i++) {
-        texts.add(checker.typeToString(types[i], scopeNode, ts.TypeFormatFlags.NoTruncation));
-    }
-    return Array.from(texts).join(' | ');
-}
-function uniqueTypes(types, checker, scopeNode, ts) {
-    const seen = new Set();
-    const result = [];
-    for (let i = 0; i < types.length; i++) {
-        const type = types[i];
-        const text = checker.typeToString(type, scopeNode, ts.TypeFormatFlags.NoTruncation);
-        if (seen.has(text)) {
-            continue;
-        }
-        seen.add(text);
-        result.push(type);
-    }
-    return result;
-}
-function getScopeName(opening, attrName, fallback, ts) {
-    const attr = getJsxAttribute(opening, attrName, ts);
-    const raw = getAttributeText(attr, ts, true);
-    if (raw && isValidIdentifier(raw)) {
-        return raw;
-    }
-    return fallback;
-}
-function getJsxAttribute(opening, attrName, ts) {
-    const attrs = opening.attributes.properties;
-    for (let i = 0; i < attrs.length; i++) {
-        const attr = attrs[i];
-        if (!ts.isJsxAttribute(attr)) {
-            continue;
-        }
-        if (getAttributeName(attr.name) === attrName) {
-            return attr;
-        }
-    }
-    return undefined;
-}
-function getAttributeText(attr, ts, allowIdentifier = false) {
-    if (!attr || !attr.initializer) {
-        return undefined;
-    }
-    if (ts.isStringLiteral(attr.initializer)) {
-        return attr.initializer.text;
-    }
-    if (!ts.isJsxExpression(attr.initializer) || !attr.initializer.expression) {
-        return undefined;
-    }
-    const expr = attr.initializer.expression;
-    if (ts.isStringLiteralLike(expr)) {
-        return expr.text;
-    }
-    if (allowIdentifier && ts.isIdentifier(expr)) {
-        return expr.text;
-    }
-    return undefined;
-}
-function getAttributeName(name) {
-    if ('text' in name) {
-        return String(name.text);
-    }
-    return name.getText();
-}
-function isSuppressed(position, diagnosticName, scopes) {
-    for (let i = scopes.length - 1; i >= 0; i--) {
-        const scope = scopes[i];
-        if (position < scope.start || position >= scope.end) {
-            continue;
-        }
-        for (let j = 0; j < scope.bindings.length; j++) {
-            if (scope.bindings[j].name === diagnosticName) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function parseKForExpression(raw, allowOfKeyword) {
-    const value = raw.trim();
-    if (!value) {
-        return null;
-    }
-    const tupleMatch = KFOR_TUPLE_PATTERN.exec(value);
-    if (tupleMatch) {
-        const keyword = tupleMatch[4];
-        const source = tupleMatch[5]?.trim();
-        if ((!allowOfKeyword && keyword === 'of') || !source) {
-            return null;
-        }
-        return {
-            aliases: uniqueIdentifiers([tupleMatch[1], tupleMatch[2], tupleMatch[3]].filter(Boolean)),
-            source,
-        };
-    }
-    const singleMatch = KFOR_SINGLE_PATTERN.exec(value);
-    if (singleMatch) {
-        const keyword = singleMatch[2];
-        const source = singleMatch[3]?.trim();
-        if ((!allowOfKeyword && keyword === 'of') || !source) {
-            return null;
-        }
-        return {
-            aliases: uniqueIdentifiers([singleMatch[1]]),
-            source,
-        };
-    }
-    return null;
-}
-function isValidIdentifier(name) {
-    return IDENTIFIER_RE.test(name);
-}
-function uniqueIdentifiers(names) {
-    const seen = new Set();
-    const result = [];
-    for (let i = 0; i < names.length; i++) {
-        const name = names[i];
-        if (!isValidIdentifier(name) || seen.has(name)) {
-            continue;
-        }
-        seen.add(name);
-        result.push(name);
-    }
-    return result;
-}
 module.exports = init;