@greppleai/grip 0.0.0-stage → 0.1.3

package/dist/core/lsp/config.js

@@ -0,0 +1,682 @@
+import { posix, win32 } from "node:path";
+import { normalizePortablePath, pathApi, pathFlavor, relativeWithin } from "./portable-path.js";
+const SERVER_KEYS = new Set([
+    "id",
+    "enabled",
+    "selectors",
+    "transport",
+    "lifecycle",
+    "workspace",
+    "pathMappings",
+    "initializationOptions",
+    "settings",
+    "clientInfo",
+    "locale",
+    "trace",
+    "features",
+    "priority",
+    "timeouts",
+]);
+const FEATURE_KEYS = ["diagnostics", "hover", "definition", "references", "rename", "codeActions"];
+const TIMEOUT_KEYS = ["connectMs", "initializeMs", "requestMs", "shutdownMs"];
+export function parseLspConfiguration(value) {
+    const diagnostics = [];
+    const object = parseObject(value, "$", diagnostics);
+    if (!object)
+        return { diagnostics };
+    rejectUnknownKeys(object, new Set(["enabled", "mode", "servers"]), "$", diagnostics);
+    const enabled = parseOptionalBoolean(object.enabled, "$.enabled", diagnostics);
+    const mode = parseOptionalEnum(object.mode, ["merge", "replace"], "$.mode", diagnostics);
+    const servers = parseServers(object.servers, diagnostics);
+    if (diagnostics.length > 0)
+        return { diagnostics };
+    return {
+        configuration: {
+            ...(enabled === undefined ? {} : { enabled }),
+            ...(mode === undefined ? {} : { mode }),
+            ...(servers === undefined ? {} : { servers }),
+        },
+        diagnostics,
+    };
+}
+function applyLspServerLayer(servers, layer) {
+    if (layer.mode === "replace")
+        servers.clear();
+    for (const server of layer.servers ?? []) {
+        if (server.enabled === false)
+            servers.delete(server.id);
+        else
+            servers.set(server.id, server);
+    }
+}
+/** Resolve already validated layers from lowest to highest precedence. */
+export function resolveLspConfiguration(layers) {
+    const servers = new Map();
+    let enabled = false;
+    let hasLayer = false;
+    for (const layer of layers) {
+        if (!layer)
+            continue;
+        if (!hasLayer)
+            enabled = layer.enabled ?? true;
+        hasLayer = true;
+        if (layer.enabled !== undefined)
+            enabled = layer.enabled;
+        applyLspServerLayer(servers, layer);
+    }
+    return { enabled: hasLayer && enabled, servers: [...servers.values()] };
+}
+function parseServers(value, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        addError(diagnostics, "$.servers", "must be an array");
+        return undefined;
+    }
+    const servers = [];
+    const ids = new Set();
+    for (const [index, entry] of value.entries()) {
+        const path = `$.servers[${index}]`;
+        const server = parseServer(entry, path, diagnostics);
+        if (!server)
+            continue;
+        if (ids.has(server.id))
+            addError(diagnostics, `${path}.id`, `duplicates server ID ${JSON.stringify(server.id)}`);
+        else
+            ids.add(server.id);
+        servers.push(server);
+    }
+    return servers;
+}
+function validateTransportLifecycle(transport, lifecycle, path, diagnostics) {
+    if (!transport || transport.type === "connection")
+        return;
+    const expectedLifecycle = transport.type === "spawn" ? "managed" : "attached";
+    if (lifecycle?.type === expectedLifecycle)
+        return;
+    addError(diagnostics, `${path}.lifecycle.type`, `must be '${expectedLifecycle}' when transport.type is '${transport.type}'`);
+}
+function parseServerId(value, path, diagnostics) {
+    const id = parseRequiredString(value, `${path}.id`, diagnostics);
+    if (!id || /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(id))
+        return id;
+    addError(diagnostics, `${path}.id`, "must start with an alphanumeric character and contain only letters, numbers, '.', '_' or '-'");
+    return id;
+}
+function createDisabledServerEntry(object, id, path, diagnostics) {
+    rejectUnknownKeys(object, new Set(["id", "enabled"]), path, diagnostics);
+    if (!id)
+        return undefined;
+    return { id, enabled: false };
+}
+function parseServer(value, path, diagnostics) {
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    const id = parseServerId(object.id, path, diagnostics);
+    const enabled = parseOptionalBoolean(object.enabled, `${path}.enabled`, diagnostics);
+    if (enabled === false)
+        return createDisabledServerEntry(object, id, path, diagnostics);
+    rejectUnknownKeys(object, SERVER_KEYS, path, diagnostics);
+    const selectors = parseSelectors(object.selectors, `${path}.selectors`, diagnostics);
+    const transport = parseTransport(object.transport, `${path}.transport`, diagnostics);
+    const lifecycle = parseLifecycle(object.lifecycle, `${path}.lifecycle`, diagnostics);
+    const workspace = parseWorkspace(object.workspace, `${path}.workspace`, diagnostics);
+    const pathMappings = parsePathMappings(object.pathMappings, `${path}.pathMappings`, diagnostics);
+    const initializationOptions = parseOptionalJson(object.initializationOptions, `${path}.initializationOptions`, diagnostics);
+    const settings = parseOptionalJson(object.settings, `${path}.settings`, diagnostics);
+    const clientInfo = parseClientInfo(object.clientInfo, `${path}.clientInfo`, diagnostics);
+    const locale = parseOptionalString(object.locale, `${path}.locale`, diagnostics);
+    const trace = parseOptionalEnum(object.trace, ["off", "messages", "verbose"], `${path}.trace`, diagnostics);
+    const features = parseFeatures(object.features, `${path}.features`, diagnostics);
+    const priority = parseOptionalInteger(object.priority, `${path}.priority`, diagnostics);
+    const timeouts = parseTimeouts(object.timeouts, `${path}.timeouts`, diagnostics);
+    validateTransportLifecycle(transport, lifecycle, path, diagnostics);
+    if (!id || !selectors || !transport || !lifecycle || !workspace)
+        return undefined;
+    return {
+        id,
+        ...(enabled === true ? { enabled: true } : {}),
+        selectors,
+        transport,
+        lifecycle,
+        workspace,
+        ...(pathMappings === undefined ? {} : { pathMappings }),
+        ...(initializationOptions === undefined ? {} : { initializationOptions }),
+        ...(settings === undefined ? {} : { settings }),
+        ...(clientInfo === undefined ? {} : { clientInfo }),
+        ...(locale === undefined ? {} : { locale }),
+        ...(trace === undefined ? {} : { trace }),
+        ...(features === undefined ? {} : { features }),
+        ...(priority === undefined ? {} : { priority }),
+        ...(timeouts === undefined ? {} : { timeouts }),
+    };
+}
+function registerSelectorSignature(signatures, signature, path, diagnostics) {
+    if (signatures.has(signature)) {
+        addError(diagnostics, path, "is ambiguous because another selector has the same scheme and pattern");
+    }
+    signatures.add(signature);
+}
+function parseSelectors(value, path, diagnostics) {
+    if (!Array.isArray(value) || value.length === 0) {
+        addError(diagnostics, path, "must be a non-empty array");
+        return undefined;
+    }
+    const selectors = [];
+    const signatures = new Set();
+    for (const [index, entry] of value.entries()) {
+        const itemPath = `${path}[${index}]`;
+        const object = parseObject(entry, itemPath, diagnostics);
+        if (!object)
+            continue;
+        rejectUnknownKeys(object, new Set(["languageId", "pattern", "scheme"]), itemPath, diagnostics);
+        const languageId = parseRequiredString(object.languageId, `${itemPath}.languageId`, diagnostics);
+        const pattern = parseRequiredString(object.pattern, `${itemPath}.pattern`, diagnostics);
+        const scheme = parseOptionalString(object.scheme, `${itemPath}.scheme`, diagnostics);
+        if (pattern && !isSafeRelativePath(pattern)) {
+            addError(diagnostics, `${itemPath}.pattern`, "must be a workspace-relative pattern without '..' segments");
+        }
+        if (!languageId || !pattern)
+            continue;
+        const signature = `${scheme ?? "file"}\u0000${pattern}`;
+        registerSelectorSignature(signatures, signature, itemPath, diagnostics);
+        selectors.push({ languageId, pattern, ...(scheme === undefined ? {} : { scheme }) });
+    }
+    return selectors;
+}
+function parseTransport(value, path, diagnostics) {
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    const type = parseRequiredString(object.type, `${path}.type`, diagnostics);
+    switch (type) {
+        case "spawn":
+            return parseSpawnTransport(object, path, diagnostics);
+        case "tcp":
+            return parseTcpTransport(object, path, diagnostics);
+        case "unix":
+            return parseUnixSocketTransport(object, path, diagnostics);
+        case "pipe":
+            return parseNamedPipeTransport(object, path, diagnostics);
+        case "connection":
+            return parseProgrammaticTransport(object, path, diagnostics);
+        default:
+            if (type)
+                addError(diagnostics, `${path}.type`, "must be one of 'spawn', 'tcp', 'unix', 'pipe', or 'connection'");
+            return undefined;
+    }
+}
+function parseSpawnTransport(object, path, diagnostics) {
+    rejectUnknownKeys(object, new Set(["type", "command", "args", "env", "cwd"]), path, diagnostics);
+    const command = parseRequiredString(object.command, `${path}.command`, diagnostics);
+    const args = parseOptionalStringArray(object.args, `${path}.args`, diagnostics);
+    const env = parseOptionalStringRecord(object.env, `${path}.env`, diagnostics);
+    const cwd = parseOptionalString(object.cwd, `${path}.cwd`, diagnostics);
+    return command
+        ? { type: "spawn", command, ...(args ? { args } : {}), ...(env ? { env } : {}), ...(cwd ? { cwd } : {}) }
+        : undefined;
+}
+function parseTcpTransport(object, path, diagnostics) {
+    rejectUnknownKeys(object, new Set(["type", "host", "port"]), path, diagnostics);
+    const host = parseRequiredString(object.host, `${path}.host`, diagnostics);
+    const port = parseOptionalInteger(object.port, `${path}.port`, diagnostics);
+    if (port === undefined)
+        addError(diagnostics, `${path}.port`, "is required and must be an integer");
+    else if (port < 1 || port > 65535)
+        addError(diagnostics, `${path}.port`, "must be between 1 and 65535");
+    return host && port !== undefined ? { type: "tcp", host, port } : undefined;
+}
+function parseUnixSocketTransport(object, path, diagnostics) {
+    rejectUnknownKeys(object, new Set(["type", "path"]), path, diagnostics);
+    const endpointPath = parseRequiredString(object.path, `${path}.path`, diagnostics);
+    if (endpointPath && !posix.isAbsolute(endpointPath) && !isSafeRelativePath(endpointPath)) {
+        addError(diagnostics, `${path}.path`, "must be absolute or a safe source-relative Unix socket path");
+    }
+    return endpointPath ? { type: "unix", path: endpointPath } : undefined;
+}
+function parseNamedPipeTransport(object, path, diagnostics) {
+    rejectUnknownKeys(object, new Set(["type", "path"]), path, diagnostics);
+    const endpointPath = parseRequiredString(object.path, `${path}.path`, diagnostics);
+    if (endpointPath && !isAbsoluteNamedPipe(endpointPath)) {
+        addError(diagnostics, `${path}.path`, "must be an absolute Windows named-pipe path such as \\\\.\\pipe\\server");
+    }
+    return endpointPath ? { type: "pipe", path: endpointPath } : undefined;
+}
+function parseProgrammaticTransport(object, path, diagnostics) {
+    rejectUnknownKeys(object, new Set(["type", "id"]), path, diagnostics);
+    const id = parseRequiredString(object.id, `${path}.id`, diagnostics);
+    return id ? { type: "connection", id } : undefined;
+}
+function parseLifecycle(value, path, diagnostics) {
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    const type = parseRequiredString(object.type, `${path}.type`, diagnostics);
+    if (type === "managed") {
+        rejectUnknownKeys(object, new Set(["type"]), path, diagnostics);
+        return { type };
+    }
+    if (type === "attached") {
+        rejectUnknownKeys(object, new Set(["type", "shutdown"]), path, diagnostics);
+        const shutdown = parseOptionalEnum(object.shutdown, ["disconnect", "protocol"], `${path}.shutdown`, diagnostics);
+        return { type, ...(shutdown === undefined ? {} : { shutdown }) };
+    }
+    if (type)
+        addError(diagnostics, `${path}.type`, "must be 'managed' or 'attached'");
+    return undefined;
+}
+function parseWorkspace(value, path, diagnostics) {
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    const type = parseRequiredString(object.type, `${path}.type`, diagnostics);
+    if (type === "session") {
+        rejectUnknownKeys(object, new Set(["type"]), path, diagnostics);
+        return { type };
+    }
+    if (type === "fixed") {
+        rejectUnknownKeys(object, new Set(["type", "path"]), path, diagnostics);
+        const fixedPath = parseRequiredString(object.path, `${path}.path`, diagnostics);
+        return fixedPath ? { type, path: fixedPath } : undefined;
+    }
+    if (type === "markers") {
+        rejectUnknownKeys(object, new Set(["type", "markers", "fallback", "stopAt"]), path, diagnostics);
+        const markers = parseRequiredUniqueRelativePaths(object.markers, `${path}.markers`, diagnostics);
+        const fallback = parseOptionalEnum(object.fallback, ["session", "none"], `${path}.fallback`, diagnostics);
+        const stopAt = parseOptionalString(object.stopAt, `${path}.stopAt`, diagnostics);
+        return markers
+            ? {
+                type,
+                markers,
+                ...(fallback === undefined ? {} : { fallback }),
+                ...(stopAt === undefined ? {} : { stopAt }),
+            }
+            : undefined;
+    }
+    if (type)
+        addError(diagnostics, `${path}.type`, "must be 'session', 'fixed', or 'markers'");
+    return undefined;
+}
+function parsePathMappingEntry(entry, index, path, diagnostics, state) {
+    const itemPath = `${path}[${index}]`;
+    const object = parseObject(entry, itemPath, diagnostics);
+    if (!object)
+        return;
+    rejectUnknownKeys(object, new Set(["agentRoot", "serverRootUri"]), itemPath, diagnostics);
+    const agentRoot = parseRequiredString(object.agentRoot, `${itemPath}.agentRoot`, diagnostics);
+    const serverRootUri = parseRequiredString(object.serverRootUri, `${itemPath}.serverRootUri`, diagnostics);
+    if (serverRootUri && !isAbsoluteFileUri(serverRootUri)) {
+        addError(diagnostics, `${itemPath}.serverRootUri`, "must be an absolute file URI without query or fragment components");
+    }
+    if (!agentRoot || !serverRootUri)
+        return;
+    const normalizedAgentRoot = normalizeAgentRoot(agentRoot);
+    const normalizedServerRoot = canonicalFileUri(serverRootUri);
+    if (state.agentRoots.has(normalizedAgentRoot))
+        addError(diagnostics, `${itemPath}.agentRoot`, "duplicates another mapping root");
+    if (normalizedServerRoot && state.serverRoots.has(normalizedServerRoot)) {
+        addError(diagnostics, `${itemPath}.serverRootUri`, "duplicates another mapping root");
+    }
+    state.agentRoots.add(normalizedAgentRoot);
+    if (normalizedServerRoot)
+        state.serverRoots.add(normalizedServerRoot);
+    state.mappings.push({ agentRoot, serverRootUri });
+}
+function validatePathMappingReversibility(mappings, path, diagnostics) {
+    for (let index = 0; index < mappings.length; index++) {
+        for (let previous = 0; previous < index; previous++) {
+            if (pathMappingsAreReversible(mappings[previous], mappings[index]))
+                continue;
+            addError(diagnostics, `${path}[${index}].agentRoot`, `overlaps mapping ${previous} without an equivalent server URI relationship`);
+            addError(diagnostics, `${path}[${index}].serverRootUri`, `overlaps mapping ${previous} without an equivalent agent path relationship`);
+        }
+    }
+}
+function parsePathMappings(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        addError(diagnostics, path, "must be an array");
+        return undefined;
+    }
+    const state = {
+        mappings: [],
+        agentRoots: new Set(),
+        serverRoots: new Set(),
+    };
+    for (const [index, entry] of value.entries()) {
+        parsePathMappingEntry(entry, index, path, diagnostics, state);
+    }
+    validatePathMappingReversibility(state.mappings, path, diagnostics);
+    return state.mappings;
+}
+function parseClientInfo(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    rejectUnknownKeys(object, new Set(["name", "version"]), path, diagnostics);
+    const name = parseRequiredString(object.name, `${path}.name`, diagnostics);
+    const version = parseOptionalString(object.version, `${path}.version`, diagnostics);
+    return name ? { name, ...(version === undefined ? {} : { version }) } : undefined;
+}
+function parseFeatures(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    rejectUnknownKeys(object, new Set(FEATURE_KEYS), path, diagnostics);
+    const features = {};
+    for (const key of FEATURE_KEYS) {
+        const setting = parseOptionalBoolean(object[key], `${path}.${key}`, diagnostics);
+        if (setting !== undefined)
+            features[key] = setting;
+    }
+    return features;
+}
+function parseTimeouts(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    rejectUnknownKeys(object, new Set(TIMEOUT_KEYS), path, diagnostics);
+    const timeouts = {};
+    for (const key of TIMEOUT_KEYS) {
+        const timeout = parseOptionalInteger(object[key], `${path}.${key}`, diagnostics);
+        if (timeout !== undefined) {
+            if (timeout < 0)
+                addError(diagnostics, `${path}.${key}`, "must be zero or a positive integer");
+            else
+                timeouts[key] = timeout;
+        }
+    }
+    return timeouts;
+}
+function parseOptionalJson(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    const result = parseJson(value, path, diagnostics, new Set());
+    return result.ok ? result.value : undefined;
+}
+function parseJsonArray(value, path, diagnostics, ancestors) {
+    ancestors.add(value);
+    const output = [];
+    let valid = true;
+    for (const [index, item] of value.entries()) {
+        const parsed = parseJson(item, `${path}[${index}]`, diagnostics, ancestors);
+        if (parsed.ok)
+            output.push(parsed.value);
+        else
+            valid = false;
+    }
+    ancestors.delete(value);
+    return valid ? { ok: true, value: output } : { ok: false };
+}
+function parseJsonObject(value, path, diagnostics, ancestors) {
+    ancestors.add(value);
+    const output = {};
+    let valid = true;
+    for (const [key, item] of Object.entries(value)) {
+        const parsed = parseJson(item, `${path}.${key}`, diagnostics, ancestors);
+        if (parsed.ok)
+            output[key] = parsed.value;
+        else
+            valid = false;
+    }
+    ancestors.delete(value);
+    return valid ? { ok: true, value: output } : { ok: false };
+}
+function parseJson(value, path, diagnostics, ancestors) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return { ok: true, value };
+    if (typeof value === "number") {
+        if (Number.isFinite(value))
+            return { ok: true, value };
+        addError(diagnostics, path, "must contain only finite JSON numbers");
+        return { ok: false };
+    }
+    if (typeof value !== "object") {
+        addError(diagnostics, path, "must be valid JSON data");
+        return { ok: false };
+    }
+    if (ancestors.has(value)) {
+        addError(diagnostics, path, "must not contain circular references");
+        return { ok: false };
+    }
+    return Array.isArray(value)
+        ? parseJsonArray(value, path, diagnostics, ancestors)
+        : parseJsonObject(value, path, diagnostics, ancestors);
+}
+function parseObject(value, path, diagnostics) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value))
+        return value;
+    addError(diagnostics, path, "must be an object");
+    return undefined;
+}
+function parseRequiredString(value, path, diagnostics) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        addError(diagnostics, path, "is required and must be a non-empty string");
+        return undefined;
+    }
+    return value;
+}
+function parseOptionalString(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    return parseRequiredString(value, path, diagnostics);
+}
+function parseOptionalBoolean(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean") {
+        addError(diagnostics, path, "must be a boolean");
+        return undefined;
+    }
+    return value;
+}
+function parseOptionalInteger(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isSafeInteger(value)) {
+        addError(diagnostics, path, "must be a safe integer");
+        return undefined;
+    }
+    return value;
+}
+function parseOptionalEnum(value, allowed, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "string" && allowed.includes(value))
+        return value;
+    addError(diagnostics, path, `must be one of ${allowed.map((item) => JSON.stringify(item)).join(", ")}`);
+    return undefined;
+}
+function parseOptionalStringArray(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value)) {
+        addError(diagnostics, path, "must be an array of strings");
+        return undefined;
+    }
+    const output = [];
+    for (const [index, item] of value.entries()) {
+        if (typeof item !== "string")
+            addError(diagnostics, `${path}[${index}]`, "must be a string");
+        else
+            output.push(item);
+    }
+    return output;
+}
+function parseOptionalStringRecord(value, path, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    const object = parseObject(value, path, diagnostics);
+    if (!object)
+        return undefined;
+    const output = {};
+    for (const [key, item] of Object.entries(object)) {
+        if (typeof item !== "string")
+            addError(diagnostics, `${path}.${key}`, "must be a string");
+        else
+            output[key] = item;
+    }
+    return output;
+}
+function parseRequiredUniqueRelativePaths(value, path, diagnostics) {
+    if (!Array.isArray(value) || value.length === 0) {
+        addError(diagnostics, path, "must be a non-empty array of relative paths");
+        return undefined;
+    }
+    const output = [];
+    const seen = new Set();
+    for (const [index, item] of value.entries()) {
+        const itemPath = `${path}[${index}]`;
+        const marker = parseRequiredString(item, itemPath, diagnostics);
+        if (!marker)
+            continue;
+        if (!isSafeRelativePath(marker))
+            addError(diagnostics, itemPath, "must be a relative path without '..' segments");
+        if (seen.has(marker))
+            addError(diagnostics, itemPath, "duplicates another marker");
+        else
+            seen.add(marker);
+        output.push(marker);
+    }
+    return output;
+}
+function rejectUnknownKeys(object, allowed, path, diagnostics) {
+    for (const key of Object.keys(object)) {
+        if (!allowed.has(key))
+            addError(diagnostics, `${path}.${key}`, "is not a recognized property");
+    }
+}
+function isSafeRelativePath(value) {
+    if (posix.isAbsolute(value) || win32.isAbsolute(value))
+        return false;
+    return !value.split(/[\\/]/).includes("..");
+}
+function agentRootRelation(left, right) {
+    const leftFlavor = pathFlavor(left);
+    const rightFlavor = pathFlavor(right);
+    if (leftFlavor !== rightFlavor)
+        return undefined;
+    const normalizedLeft = normalizePortablePath(left, leftFlavor);
+    const normalizedRight = normalizePortablePath(right, rightFlavor);
+    const comparableLeft = leftFlavor === "windows" ? normalizedLeft.toLowerCase() : normalizedLeft;
+    const comparableRight = rightFlavor === "windows" ? normalizedRight.toLowerCase() : normalizedRight;
+    if (comparableLeft === comparableRight) {
+        return { direction: "equal", relative: "", caseInsensitive: leftFlavor === "windows" };
+    }
+    const fromLeft = relativeWithin(normalizedLeft, normalizedRight);
+    if (fromLeft !== undefined) {
+        return {
+            direction: "left-parent",
+            relative: fromLeft.replace(/\\/g, "/"),
+            caseInsensitive: leftFlavor === "windows",
+        };
+    }
+    const fromRight = relativeWithin(normalizedRight, normalizedLeft);
+    return fromRight === undefined
+        ? undefined
+        : {
+            direction: "right-parent",
+            relative: fromRight.replace(/\\/g, "/"),
+            caseInsensitive: leftFlavor === "windows",
+        };
+}
+function serverRootRelation(leftValue, rightValue) {
+    if (!canonicalFileUri(leftValue) || !canonicalFileUri(rightValue))
+        return undefined;
+    const left = new URL(leftValue);
+    const right = new URL(rightValue);
+    if (left.hostname.toLowerCase() !== right.hostname.toLowerCase())
+        return undefined;
+    const leftSegments = left.pathname
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => decodeURIComponent(segment));
+    const rightSegments = right.pathname
+        .split("/")
+        .filter(Boolean)
+        .map((segment) => decodeURIComponent(segment));
+    const caseInsensitive = left.hostname.length > 0 ||
+        right.hostname.length > 0 ||
+        leftSegments[0]?.endsWith(":") === true ||
+        rightSegments[0]?.endsWith(":") === true;
+    const comparable = (segment) => (caseInsensitive ? segment.toLowerCase() : segment);
+    let shared = 0;
+    while (shared < leftSegments.length &&
+        shared < rightSegments.length &&
+        comparable(leftSegments[shared]) === comparable(rightSegments[shared])) {
+        shared++;
+    }
+    if (shared < Math.min(leftSegments.length, rightSegments.length))
+        return undefined;
+    if (leftSegments.length === rightSegments.length)
+        return { direction: "equal", relative: "", caseInsensitive };
+    return leftSegments.length < rightSegments.length
+        ? { direction: "left-parent", relative: rightSegments.slice(shared).join("/"), caseInsensitive }
+        : { direction: "right-parent", relative: leftSegments.slice(shared).join("/"), caseInsensitive };
+}
+function pathMappingsAreReversible(left, right) {
+    const agent = agentRootRelation(left.agentRoot, right.agentRoot);
+    const server = serverRootRelation(left.serverRootUri, right.serverRootUri);
+    if (!agent || !server)
+        return agent === undefined && server === undefined;
+    if (agent.direction !== server.direction)
+        return false;
+    return agent.caseInsensitive && server.caseInsensitive
+        ? agent.relative.toLowerCase() === server.relative.toLowerCase()
+        : agent.relative === server.relative;
+}
+function normalizeAgentRoot(value) {
+    const flavor = pathFlavor(value);
+    const api = pathApi(flavor);
+    const normalized = normalizePortablePath(value, flavor);
+    const root = api.parse(normalized).root;
+    const trailingSeparator = flavor === "windows" ? /[\\/]+$/ : /\/+$/;
+    const withoutTrailingSeparators = normalized === root ? normalized : normalized.replace(trailingSeparator, "");
+    return flavor === "windows" ? withoutTrailingSeparators.toLowerCase() : withoutTrailingSeparators;
+}
+function isAbsoluteNamedPipe(value) {
+    const lower = value.toLowerCase();
+    const prefixes = ["\\\\.\\pipe\\", "\\\\?\\pipe\\"];
+    return prefixes.some((prefix) => lower.startsWith(prefix) && value.length > prefix.length);
+}
+function canonicalFileUri(value) {
+    if (!/^file:\//i.test(value))
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "file:" || url.pathname.length === 0 || url.search !== "" || url.hash !== "")
+            return undefined;
+        const segments = url.pathname
+            .split("/")
+            .filter(Boolean)
+            .map((segment) => decodeURIComponent(segment));
+        if (segments.some((segment) => segment.includes("/") || segment === "." || segment === ".."))
+            return undefined;
+        if (url.hostname && segments.length === 0)
+            return undefined;
+        if (segments[0]?.endsWith(":") && segments.length === 1 && !url.pathname.endsWith("/"))
+            return undefined;
+        const driveRoot = segments[0]?.endsWith(":") && segments.length === 1;
+        url.pathname = `/${segments.map((segment) => encodeURIComponent(segment)).join("/")}${driveRoot ? "/" : ""}`;
+        url.hostname = url.hostname.toLowerCase();
+        return url.toString();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isAbsoluteFileUri(value) {
+    return canonicalFileUri(value) !== undefined;
+}
+function addError(diagnostics, path, message) {
+    diagnostics.push({ severity: "error", path, message });
+}
+//# sourceMappingURL=config.js.map