@esportsplus/typescript 0.29.6 → 0.31.1

package/build/compiler/sourcemap.js

@@ -0,0 +1,265 @@
+const BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const CLASS_OTHER = 2;
+const CLASS_SPACE = 1;
+const CLASS_WORD = 0;
+let inverse = buildInverse();
+function buildInverse() {
+    let table = new Int8Array(128).fill(-1);
+    for (let i = 0, n = BASE64.length; i < n; i++) {
+        table[BASE64.charCodeAt(i)] = i;
+    }
+    return table;
+}
+function charClass(code) {
+    if ((code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 36 || code === 95) {
+        return CLASS_WORD;
+    }
+    if (code === 9 || code === 10 || code === 13 || code === 32) {
+        return CLASS_SPACE;
+    }
+    return CLASS_OTHER;
+}
+function decodeVlqArray(segment) {
+    let out = [], i = 0, n = segment.length;
+    while (i < n) {
+        let digit = 0, result = 0, shift = 0;
+        do {
+            digit = inverse[segment.charCodeAt(i)];
+            i++;
+            result += (digit & 31) << shift;
+            shift += 5;
+        } while (digit & 32);
+        out.push((result & 1) ? -(result >>> 1) : (result >>> 1));
+    }
+    return out;
+}
+function encodeVlq(value) {
+    let out = '', vlq = value < 0 ? ((-value) << 1) | 1 : value << 1;
+    do {
+        let digit = vlq & 31;
+        vlq >>>= 5;
+        if (vlq > 0) {
+            digit |= 32;
+        }
+        out += BASE64[digit];
+    } while (vlq > 0);
+    return out;
+}
+function lineStarts(text) {
+    let starts = [0];
+    for (let i = 0, n = text.length; i < n; i++) {
+        if (text.charCodeAt(i) === 10) {
+            starts.push(i + 1);
+        }
+    }
+    return starts;
+}
+function offsetToLineCol(starts, offset) {
+    let hi = starts.length - 1, line = 0, lo = 0;
+    while (lo <= hi) {
+        let mid = (lo + hi) >> 1;
+        if (starts[mid] <= offset) {
+            line = mid;
+            lo = mid + 1;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return { column: offset - starts[line], line };
+}
+function rawToSegments(raw) {
+    let name = 0, origColumn = 0, origLine = 0, source = 0;
+    return raw.map((line) => {
+        let genColumn = 0;
+        return line.map((values) => {
+            genColumn += values[0];
+            let segment = { genColumn };
+            if (values.length >= 4) {
+                source += values[1];
+                origLine += values[2];
+                origColumn += values[3];
+                segment.originalColumn = origColumn;
+                segment.originalLine = origLine;
+                segment.source = source;
+                if (values.length >= 5) {
+                    name += values[4];
+                    segment.name = name;
+                }
+            }
+            return segment;
+        });
+    });
+}
+function resolveGeneration(anchors, offset) {
+    let found = anchors[0], hi = anchors.length - 1, lo = 0;
+    while (lo <= hi) {
+        let mid = (lo + hi) >> 1, anchor = anchors[mid];
+        if (offset < anchor.afterStart) {
+            hi = mid - 1;
+        }
+        else {
+            found = anchor;
+            lo = mid + 1;
+        }
+    }
+    if (found.identity) {
+        return found.beforeStart + (offset - found.afterStart);
+    }
+    return found.beforeStart;
+}
+function resolveOffset(mapping, offset) {
+    let generations = mapping.generations, result = offset;
+    for (let i = generations.length - 1; i >= 0; i--) {
+        result = resolveGeneration(generations[i], result);
+    }
+    return result;
+}
+function resolveOffsets(mapping) {
+    const cursors = mapping.generations.map(() => 0);
+    return (offset) => {
+        let result = offset;
+        for (let i = mapping.generations.length - 1; i >= 0; i--) {
+            const anchors = mapping.generations[i];
+            while (cursors[i] + 1 < anchors.length &&
+                result >= anchors[cursors[i] + 1].afterStart) {
+                cursors[i] += 1;
+            }
+            const anchor = anchors[cursors[i]];
+            result = anchor.identity
+                ? anchor.beforeStart + (result - anchor.afterStart)
+                : anchor.beforeStart;
+        }
+        return result;
+    };
+}
+function segmentAt(starts, offset, genColumn) {
+    let position = offsetToLineCol(starts, offset);
+    return { genColumn, originalColumn: position.column, originalLine: position.line, source: 0 };
+}
+function segmentsToRaw(segments) {
+    let name = 0, origColumn = 0, origLine = 0, source = 0;
+    return segments.map((line) => {
+        let genColumn = 0;
+        return line.map((segment) => {
+            let values = [segment.genColumn - genColumn];
+            genColumn = segment.genColumn;
+            if (segment.source !== undefined && segment.originalLine !== undefined && segment.originalColumn !== undefined) {
+                values.push(segment.source - source, segment.originalLine - origLine, segment.originalColumn - origColumn);
+                origColumn = segment.originalColumn;
+                origLine = segment.originalLine;
+                source = segment.source;
+                if (segment.name !== undefined) {
+                    values.push(segment.name - name);
+                    name = segment.name;
+                }
+            }
+            return values;
+        });
+    });
+}
+const buildGeneration = (beforeText, edits) => {
+    let afterCursor = 0, anchors = [], beforeCursor = 0, ordered = [...edits].sort((a, b) => a.start - b.start);
+    for (let i = 0, n = ordered.length; i < n; i++) {
+        let edit = ordered[i];
+        if (edit.start > beforeCursor) {
+            let length = edit.start - beforeCursor;
+            anchors.push({ afterEnd: afterCursor + length, afterStart: afterCursor, beforeStart: beforeCursor, identity: true });
+            afterCursor += length;
+        }
+        let inserted = edit.newText.length;
+        if (inserted > 0) {
+            anchors.push({ afterEnd: afterCursor + inserted, afterStart: afterCursor, beforeStart: edit.start, identity: false });
+            afterCursor += inserted;
+        }
+        beforeCursor = edit.end;
+    }
+    if (beforeCursor < beforeText.length) {
+        anchors.push({ afterEnd: afterCursor + (beforeText.length - beforeCursor), afterStart: afterCursor, beforeStart: beforeCursor, identity: true });
+    }
+    if (anchors.length === 0) {
+        anchors.push({ afterEnd: 0, afterStart: 0, beforeStart: 0, identity: true });
+    }
+    return anchors;
+};
+const composeEmittedMap = (map, mapping, transformedText, originalText) => {
+    let oStarts = lineStarts(originalText), segments = rawToSegments(decode(map.mappings)), tStarts = lineStarts(transformedText);
+    for (let i = 0, n = segments.length; i < n; i++) {
+        let line = segments[i];
+        for (let j = 0, m = line.length; j < m; j++) {
+            let segment = line[j];
+            if (segment.originalLine === undefined || segment.originalColumn === undefined) {
+                continue;
+            }
+            let base = segment.originalLine < tStarts.length ? tStarts[segment.originalLine] : transformedText.length, position = offsetToLineCol(oStarts, resolveOffset(mapping, base + segment.originalColumn));
+            segment.originalColumn = position.column;
+            segment.originalLine = position.line;
+        }
+    }
+    let composed = {
+        mappings: encode(segmentsToRaw(segments)),
+        names: map.names ?? [],
+        sources: map.sources,
+        version: 3
+    };
+    if (map.file !== undefined) {
+        composed.file = map.file;
+    }
+    if (map.sourceRoot !== undefined) {
+        composed.sourceRoot = map.sourceRoot;
+    }
+    return composed;
+};
+const decode = (mappings) => {
+    if (mappings === '') {
+        return [];
+    }
+    return mappings.split(';').map((line) => {
+        if (line === '') {
+            return [];
+        }
+        return line.split(',').map((segment) => decodeVlqArray(segment));
+    });
+};
+const encode = (decoded) => {
+    let lines = [];
+    for (let i = 0, n = decoded.length; i < n; i++) {
+        let parts = [], segments = decoded[i];
+        for (let j = 0, m = segments.length; j < m; j++) {
+            let encoded = '', values = segments[j];
+            for (let k = 0, o = values.length; k < o; k++) {
+                encoded += encodeVlq(values[k]);
+            }
+            parts.push(encoded);
+        }
+        lines.push(parts.join(','));
+    }
+    return lines.join(';');
+};
+const originalPositionFor = (mapping, transformedText, originalText, line, column) => {
+    let tStarts = lineStarts(transformedText), base = line < tStarts.length ? tStarts[line] : transformedText.length;
+    return offsetToLineCol(lineStarts(originalText), resolveOffset(mapping, base + column));
+};
+const toSourceMapV3 = (mapping, transformedText, originalText, source) => {
+    let oStarts = lineStarts(originalText), resolve = resolveOffsets(mapping), segments = [], tStarts = lineStarts(transformedText);
+    for (let line = 0, n = tStarts.length; line < n; line++) {
+        let end = line + 1 < n ? tStarts[line + 1] - 1 : transformedText.length, previous = resolve(tStarts[line]), start = tStarts[line];
+        let row = [segmentAt(oStarts, previous, 0)];
+        for (let offset = start + 1; offset < end; offset++) {
+            let current = charClass(transformedText.charCodeAt(offset));
+            if (current !== CLASS_OTHER && current === charClass(transformedText.charCodeAt(offset - 1))) {
+                continue;
+            }
+            let resolved = resolve(offset);
+            if (resolved === previous) {
+                continue;
+            }
+            previous = resolved;
+            row.push(segmentAt(oStarts, resolved, offset - start));
+        }
+        segments.push(row);
+    }
+    return { mappings: encode(segmentsToRaw(segments)), names: [], sources: [source], version: 3 };
+};
+export default { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, resolveOffset, toSourceMapV3 };
+export { buildGeneration, composeEmittedMap, decode, encode, originalPositionFor, resolveOffset, toSourceMapV3 };

package/build/compiler/types.d.ts

@@ -1,4 +1,5 @@
-import type ts from 'typescript';
+import type { Node, SourceFile } from 'typescript/unstable/ast';
+import type { Checker, Program } from 'typescript/unstable/sync';
 type ImportIntent = {
     add?: string[];
     namespace?: string;
@@ -18,16 +19,16 @@ type Replacement = Range & {
     newText: string;
 };
 type ReplacementIntent = {
-    generate: (sourceFile: ts.SourceFile) => string;
-    node: ts.Node;
+    generate: (sourceFile: SourceFile) => string;
+    node: Node;
 };
 type SharedContext = Map<string, unknown>;
 type TransformContext = {
-    checker: ts.TypeChecker;
+    checker: Checker;
     code: string;
-    program: ts.Program;
+    program: Program;
     shared: SharedContext;
-    sourceFile: ts.SourceFile;
+    sourceFile: SourceFile;
 };
 type TransformResult = {
     imports?: ImportIntent[];

package/build/compiler/uid.d.ts

@@ -1,2 +1,5 @@
-declare const _default: (name: string) => string;
-export default _default;
+declare function uid(name: string): string;
+declare namespace uid {
+    var scope: (root: string, fileName: string, code: string) => void;
+}
+export default uid;

package/build/compiler/uid.js

@@ -1,5 +1,34 @@
-import { uuid } from '@esportsplus/utilities';
-let i = 0, namespace = uuid().replace(/[^A-Za-z0-9]/g, '');
-export default (name) => {
-    return name + '_' + namespace + (i++).toString(36);
+import path from 'path';
+const BACKSLASH_REGEX = /\\/g;
+const FNV_OFFSET_BASIS = 2166136261;
+const FNV_PRIME = 16777619;
+const NAMESPACE_WIDTH = 7;
+const UNSCOPED_NAMESPACE = 'u';
+let counter = 0, namespace = UNSCOPED_NAMESPACE;
+function derive(id, code) {
+    let candidate = format(id), salt = 0;
+    while (code.includes(candidate)) {
+        salt++;
+        candidate = format(id + '#' + salt);
+    }
+    return candidate;
+}
+function format(id) {
+    return hash(id).toString(36).padStart(NAMESPACE_WIDTH, '0');
+}
+function hash(value) {
+    let h = FNV_OFFSET_BASIS;
+    for (let i = 0, n = value.length; i < n; i++) {
+        h ^= value.charCodeAt(i);
+        h = Math.imul(h, FNV_PRIME);
+    }
+    return h >>> 0;
+}
+const uid = (name) => {
+    return name + '_' + namespace + (counter++).toString(36);
 };
+uid.scope = (root, fileName, code) => {
+    counter = 0;
+    namespace = derive(path.relative(root, fileName).replace(BACKSLASH_REGEX, '/') || fileName, code);
+};
+export default uid;

package/build/index.d.ts

@@ -1 +1 @@
-export { default as ts } from 'typescript';
+export * as ts from './ts.js';

package/build/index.js

@@ -1 +1 @@
-export { default as ts } from 'typescript';
+export * as ts from './ts.js';

package/build/jsonc.d.ts

@@ -0,0 +1,2 @@
+declare const stripJsonc: (text: string) => string;
+export { stripJsonc };

package/build/jsonc.js

@@ -0,0 +1,85 @@
+const stripJsonc = (text) => {
+    let escaped = false, inBlockComment = false, inLineComment = false, inString = false, stripped = '';
+    for (let i = 0, n = text.length; i < n; i++) {
+        let char = text[i], next = text[i + 1];
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+                stripped += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            stripped += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            stripped += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        stripped += char;
+    }
+    escaped = false;
+    inString = false;
+    let result = '';
+    for (let i = 0, n = stripped.length; i < n; i++) {
+        let char = stripped[i];
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === ',') {
+            let j = i + 1;
+            while (j < n && /\s/.test(stripped[j])) {
+                j++;
+            }
+            if (stripped[j] === ']' || stripped[j] === '}') {
+                continue;
+            }
+        }
+        result += char;
+    }
+    return result;
+};
+export { stripJsonc };

package/build/lsp/bin.d.ts

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

package/build/lsp/bin.js

@@ -0,0 +1,2 @@
+import { startServer } from './server.js';
+startServer();

package/build/lsp/diagnostics.d.ts

@@ -0,0 +1,10 @@
+import { DiagnosticSeverity } from 'vscode-languageserver/node';
+import type { CodeAction, Diagnostic as LspDiagnostic, Hover } from 'vscode-languageserver/node';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { Diagnostic as AnalyzeDiagnostic } from '../probe/kernel/types.js';
+export type DocumentResolver = (fileName: string) => TextDocument | undefined;
+declare function toLspDiagnostic(diagnostic: AnalyzeDiagnostic, severity: DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): LspDiagnostic;
+declare function groupByFile(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, severity: DiagnosticSeverity, resolve: DocumentResolver, uriOf: (fileName: string) => string): Map<string, LspDiagnostic[]>;
+declare function hoverAt(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, offset: number, document: TextDocument): Hover | undefined;
+declare function codeActionsAt(diagnostics: ReadonlyArray<AnalyzeDiagnostic>, startOffset: number, endOffset: number, document: TextDocument, uriOf: (fileName: string) => string): CodeAction[];
+export { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt, toLspDiagnostic };

package/build/lsp/diagnostics.js

@@ -0,0 +1,69 @@
+import { CodeActionKind, DiagnosticSeverity, MarkupKind } from 'vscode-languageserver/node';
+function rangeOf(location, document) {
+    if (document) {
+        return { start: document.positionAt(location.pos), end: document.positionAt(location.end) };
+    }
+    let start = { line: Math.max(0, location.line - 1), character: Math.max(0, location.column - 1) };
+    return { start, end: { line: start.line, character: start.character + 1 } };
+}
+function relatedOf(diagnostic, resolve, uriOf) {
+    return diagnostic.related.map((related) => ({
+        location: { range: rangeOf(related.location, resolve(related.location.fileName)), uri: uriOf(related.location.fileName) },
+        message: related.message,
+    }));
+}
+function toLspDiagnostic(diagnostic, severity, resolve, uriOf) {
+    return {
+        code: diagnostic.channel,
+        message: diagnostic.message,
+        range: rangeOf(diagnostic.location, resolve(diagnostic.location.fileName)),
+        relatedInformation: relatedOf(diagnostic, resolve, uriOf),
+        severity,
+        source: 'analyze',
+    };
+}
+function groupByFile(diagnostics, severity, resolve, uriOf) {
+    let grouped = new Map();
+    for (let i = 0, n = diagnostics.length; i < n; i++) {
+        let diagnostic = diagnostics[i], fileName = diagnostic.location.fileName, list = grouped.get(fileName);
+        if (!list) {
+            list = [];
+            grouped.set(fileName, list);
+        }
+        list.push(toLspDiagnostic(diagnostic, severity, resolve, uriOf));
+    }
+    return grouped;
+}
+function hoverAt(diagnostics, offset, document) {
+    let hits = diagnostics.filter((diagnostic) => offset >= diagnostic.location.pos && offset <= diagnostic.location.end);
+    if (hits.length === 0) {
+        return undefined;
+    }
+    let lines = [];
+    for (let i = 0, n = hits.length; i < n; i++) {
+        let diagnostic = hits[i];
+        lines.push(`**${diagnostic.channel}** — ${diagnostic.message}`);
+        for (let related of diagnostic.related) {
+            lines.push(`- ${related.message}`);
+        }
+    }
+    return { contents: { kind: MarkupKind.Markdown, value: lines.join('\n\n') }, range: rangeOf(hits[0].location, document) };
+}
+function codeActionsAt(diagnostics, startOffset, endOffset, document, uriOf) {
+    let actions = [];
+    for (let diagnostic of diagnostics) {
+        if (diagnostic.location.end < startOffset || diagnostic.location.pos > endOffset) {
+            continue;
+        }
+        for (let fix of diagnostic.fixes ?? []) {
+            let changes = {};
+            for (let edit of fix.edits) {
+                let uri = uriOf(edit.fileName), range = { start: document.positionAt(edit.pos), end: document.positionAt(edit.end) };
+                (changes[uri] ??= []).push({ newText: edit.newText, range });
+            }
+            actions.push({ edit: { changes }, kind: CodeActionKind.QuickFix, title: fix.title });
+        }
+    }
+    return actions;
+}
+export { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt, toLspDiagnostic };

package/build/lsp/index.d.ts

@@ -0,0 +1,2 @@
+export { createServer, startServer } from './server.js';
+export { AnalyzeWorkspace } from './workspace.js';

package/build/lsp/index.js

@@ -0,0 +1,2 @@
+export { createServer, startServer } from './server.js';
+export { AnalyzeWorkspace } from './workspace.js';

package/build/lsp/server.d.ts

@@ -0,0 +1,4 @@
+import type { Connection } from 'vscode-languageserver/node';
+declare function createServer(connection: Connection): void;
+declare function startServer(): void;
+export { createServer, startServer };

package/build/lsp/server.js

@@ -0,0 +1,130 @@
+import * as NodeFS from 'node:fs';
+import * as NodePath from 'node:path';
+import { CodeActionKind, createConnection, ProposedFeatures, StreamMessageReader, StreamMessageWriter, TextDocuments, TextDocumentSyncKind } from 'vscode-languageserver/node';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { codeActionsAt, DiagnosticSeverity, groupByFile, hoverAt } from './diagnostics.js';
+import { AnalyzeWorkspace } from './workspace.js';
+function pathKey(fileName) {
+    let resolved = NodePath.resolve(fileName);
+    return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+function findTsconfig(rootDir) {
+    let candidate = NodePath.join(rootDir, 'tsconfig.json');
+    return NodeFS.existsSync(candidate) ? candidate : undefined;
+}
+function rootFromInitialize(params) {
+    let folder = params.workspaceFolders?.[0]?.uri ?? params.rootUri ?? undefined;
+    return folder ? fileURLToPath(folder) : undefined;
+}
+function createServer(connection) {
+    let analyzed = new Map(), documents = new TextDocuments(TextDocument), pending = new Set(), published = new Set(), timer, workspace;
+    function runAnalysis() {
+        timer = undefined;
+        if (!workspace || !workspace.config) {
+            return;
+        }
+        let changed = [...pending];
+        pending.clear();
+        try {
+            workspace.refresh(changed);
+        }
+        catch (error) {
+            connection.console.error(`analyze: snapshot refresh failed — ${error.message}`);
+            return;
+        }
+        let result = workspace.analyze();
+        if (!result) {
+            return;
+        }
+        analyzed = new Map();
+        for (let diagnostic of result.diagnostics) {
+            let key = pathKey(diagnostic.location.fileName), list = analyzed.get(key);
+            if (!list) {
+                list = [];
+                analyzed.set(key, list);
+            }
+            list.push(diagnostic);
+        }
+        let openByPath = new Map(documents.all().map((document) => [pathKey(fileURLToPath(document.uri)), document])), resolve = (fileName) => openByPath.get(pathKey(fileName)), severity = workspace.config.severity === 'warning' ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error, uriOf = (fileName) => openByPath.get(pathKey(fileName))?.uri ?? pathToFileURL(fileName).toString(), grouped = groupByFile(result.diagnostics, severity, resolve, uriOf), next = new Set();
+        for (let [fileName, diagnostics] of grouped) {
+            let uri = uriOf(fileName);
+            next.add(uri);
+            connection.sendDiagnostics({ diagnostics, uri });
+        }
+        for (let uri of published) {
+            if (!next.has(uri)) {
+                connection.sendDiagnostics({ diagnostics: [], uri });
+            }
+        }
+        published = next;
+    }
+    function schedule(changed) {
+        for (let i = 0, n = changed.length; i < n; i++) {
+            pending.add(changed[i]);
+        }
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(runAnalysis, 300);
+    }
+    connection.onInitialize((params) => {
+        let root = rootFromInitialize(params);
+        if (root) {
+            let tsconfig = findTsconfig(root);
+            if (tsconfig) {
+                workspace = new AnalyzeWorkspace(tsconfig);
+            }
+        }
+        return {
+            capabilities: {
+                codeActionProvider: { codeActionKinds: [CodeActionKind.QuickFix] },
+                hoverProvider: true,
+                textDocumentSync: TextDocumentSyncKind.Incremental,
+            },
+        };
+    });
+    connection.onInitialized(() => {
+        if (workspace) {
+            schedule([]);
+        }
+    });
+    connection.onShutdown(() => {
+        workspace?.dispose();
+        workspace = undefined;
+    });
+    connection.onHover((params) => {
+        let document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        let diagnostics = analyzed.get(pathKey(fileURLToPath(params.textDocument.uri)));
+        return diagnostics ? hoverAt(diagnostics, document.offsetAt(params.position), document) ?? null : null;
+    });
+    connection.onCodeAction((params) => {
+        let document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return [];
+        }
+        let target = pathKey(fileURLToPath(params.textDocument.uri)), diagnostics = analyzed.get(target);
+        if (!diagnostics) {
+            return [];
+        }
+        let uriOf = (fileName) => (pathKey(fileName) === target ? params.textDocument.uri : pathToFileURL(fileName).toString());
+        return codeActionsAt(diagnostics, document.offsetAt(params.range.start), document.offsetAt(params.range.end), document, uriOf);
+    });
+    documents.onDidOpen((event) => schedule([fileURLToPath(event.document.uri)]));
+    documents.onDidSave((event) => {
+        let fileName = fileURLToPath(event.document.uri);
+        if (workspace && NodePath.basename(fileName) === 'tsconfig.json') {
+            workspace.reloadConfig();
+        }
+        schedule([fileName]);
+    });
+    documents.listen(connection);
+    connection.listen();
+}
+function startServer() {
+    createServer(createConnection(ProposedFeatures.all, new StreamMessageReader(process.stdin), new StreamMessageWriter(process.stdout)));
+}
+export { createServer, startServer };