@j0hanz/fetch-url-mcp 1.12.7 → 1.12.8

package/dist/http/native.js

@@ -1,23 +1,567 @@
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { readFileSync } from 'node:fs';
 import { createServer, } from 'node:http';
 import { createServer as createHttpsServer, } from 'node:https';
-import { hostname } from 'node:os';
+import { freemem, hostname, totalmem } from 'node:os';
+import { monitorEventLoopDelay, performance } from 'node:perf_hooks';
 import process from 'node:process';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
-import { composeCloseHandlers, config, createSessionStore, createSlotTracker, enableHttpMode, ensureSessionCapacity, logDebug, logError, logInfo, logWarn, registerMcpSessionOwnerKey, registerMcpSessionServer, reserveSessionSlot, runWithRequestContext, startSessionCleanupLoop, } from '../lib/core.js';
-import { Loggers } from '../lib/logger-names.js';
+import { Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { composeCloseHandlers, config, createSessionStore, createSlotTracker, enableHttpMode, ensureSessionCapacity, logDebug, logError, Loggers, logInfo, logWarn, registerMcpSessionOwnerKey, registerMcpSessionServer, reserveSessionSlot, resolveMcpSessionIdByServer, runWithRequestContext, serverVersion, startSessionCleanupLoop, unregisterMcpSessionServer, unregisterMcpSessionServerByServer, } from '../lib/core.js';
+import { getErrorMessage, toError } from '../lib/error/index.js';
 import { acceptsEventStream, acceptsJsonAndEventStream, isMcpRequestBody, } from '../lib/mcp-interop.js';
-import { applyHttpServerTuning, drainConnectionsOnShutdown, isObject, toError, } from '../lib/utils.js';
+import { createDefaultBlockList, normalizeIpForBlockList, } from '../lib/net/index.js';
+import { applyHttpServerTuning, drainConnectionsOnShutdown, isObject, } from '../lib/utils.js';
 import { createMcpServerForHttpSession } from '../server.js';
-import { buildAuthenticatedOwnerKey } from '../tasks/owner.js';
+import { buildAuthenticatedOwnerKey } from '../tasks/index.js';
+import { getTransformPoolStats } from '../transform/index.js';
 import { applyInsufficientScopeAuthHeaders, applyUnauthorizedAuthHeaders, assertHttpModeConfiguration, authService, buildAuthFingerprint, buildProtectedResourceMetadataDocument, corsPolicy, DEFAULT_MCP_PROTOCOL_VERSION, ensureMcpProtocolVersion, hostOriginPolicy, isInsufficientScopeError, isOAuthMetadataEnabled, isProtectedResourceMetadataPath, SUPPORTED_MCP_PROTOCOL_VERSIONS, } from './auth.js';
-import { disableEventLoopMonitoring, isVerboseHealthRequest, resetEventLoopMonitoring, sendHealthRouteResponse, shouldHandleHealthRoute, } from './health.js';
-import { buildRequestContext, createRequestAbortSignal, createTransportAdapter, DEFAULT_BODY_LIMIT_BYTES, drainRequest, findDuplicateSingleValueHeader, getHeaderValue, getMcpSessionId, isJsonBodyError, jsonBodyReader, registerInboundBlockList, sendEmpty, sendError, sendJson, } from './helpers.js';
-import { teardownSessionRegistration, teardownSessionResources, teardownUnregisteredSessionResources, } from './helpers.js';
 import { createRateLimitManagerImpl, } from './rate-limit.js';
+function abortControllerBestEffort(controller) {
+    if (!controller.signal.aborted)
+        controller.abort();
+}
+function destroyRequestBestEffort(req) {
+    try {
+        req.destroy();
+    }
+    catch {
+        // Best-effort only.
+    }
+}
+// ---------------------------------------------------------------------------
+// Response helpers
+// ---------------------------------------------------------------------------
+function setNoStoreHeaders(res) {
+    res.setHeader('X-Content-Type-Options', 'nosniff');
+    res.setHeader('Cache-Control', 'no-store');
+}
+export function sendJson(res, status, body) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    setNoStoreHeaders(res);
+    res.end(JSON.stringify(body));
+}
+export function sendEmpty(res, status) {
+    res.statusCode = status;
+    res.setHeader('Content-Length', '0');
+    res.end();
+}
+export function sendError(res, _code, message, status = 400, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- kept for call-site compat
+_id) {
+    sendJson(res, status, { error: message });
+}
+// ---------------------------------------------------------------------------
+// Request helpers
+// ---------------------------------------------------------------------------
+export function getHeaderValue(req, name) {
+    const val = req.headers[name];
+    if (!val)
+        return null;
+    return Array.isArray(val) ? (val[0] ?? null) : val;
+}
+export function getMcpSessionId(req) {
+    return (getHeaderValue(req, 'mcp-session-id') ??
+        getHeaderValue(req, 'x-mcp-session-id'));
+}
+const SINGLE_VALUE_HEADER_NAMES = [
+    'authorization',
+    'x-api-key',
+    'host',
+    'origin',
+    'content-length',
+    'mcp-protocol-version',
+    'mcp-session-id',
+    'x-mcp-session-id',
+];
+function hasDuplicateHeader(req, name) {
+    const values = req.headersDistinct[name];
+    return Array.isArray(values) && values.length > 1;
+}
+export function findDuplicateSingleValueHeader(req) {
+    for (const name of SINGLE_VALUE_HEADER_NAMES) {
+        if (hasDuplicateHeader(req, name))
+            return name;
+    }
+    return null;
+}
+export function drainRequest(req) {
+    if (req.readableEnded)
+        return;
+    try {
+        req.resume();
+    }
+    catch {
+        // Best-effort only.
+    }
+}
+// ---------------------------------------------------------------------------
+// Request abort signal
+// ---------------------------------------------------------------------------
+export function createRequestAbortSignal(req) {
+    const controller = new AbortController();
+    let cleanedUp = false;
+    const abortRequest = () => {
+        if (cleanedUp)
+            return;
+        abortControllerBestEffort(controller);
+    };
+    if (req.destroyed) {
+        abortRequest();
+        return {
+            signal: controller.signal,
+            cleanup: () => {
+                cleanedUp = true;
+            },
+        };
+    }
+    const onClose = () => {
+        // A normal close after a complete body should not be treated as cancellation.
+        if (req.complete)
+            return;
+        abortRequest();
+    };
+    const onError = () => {
+        abortRequest();
+    };
+    req.once('close', onClose);
+    req.once('error', onError);
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            cleanedUp = true;
+            req.removeListener('close', onClose);
+            req.removeListener('error', onError);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// IP & connection helpers
+// ---------------------------------------------------------------------------
+function normalizeRemoteAddress(address) {
+    if (!address)
+        return null;
+    const trimmed = address.trim();
+    if (!trimmed)
+        return null;
+    const normalized = normalizeIpForBlockList(trimmed);
+    if (normalized)
+        return normalized.ip;
+    return trimmed;
+}
+export function registerInboundBlockList(server) {
+    if (!config.server.http.blockPrivateConnections)
+        return;
+    const blockList = createDefaultBlockList();
+    server.on('connection', (socket) => {
+        const raw = socket.remoteAddress?.trim();
+        if (!raw)
+            return;
+        const normalized = normalizeIpForBlockList(raw);
+        if (!normalized)
+            return;
+        if (blockList.check(normalized.ip, normalized.family)) {
+            logWarn('Blocked inbound connection', {
+                remoteAddress: normalized.ip,
+                family: normalized.family,
+            }, Loggers.LOG_HTTP);
+            socket.destroy();
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// Request context builder
+// ---------------------------------------------------------------------------
+export function buildRequestContext(req, res, signal) {
+    const url = URL.parse(req.url ?? '', 'http://localhost');
+    if (!url) {
+        sendJson(res, 400, { error: 'Invalid request URL' });
+        return null;
+    }
+    return {
+        req,
+        res,
+        url,
+        method: req.method,
+        ip: normalizeRemoteAddress(req.socket.remoteAddress),
+        body: undefined,
+        ...(signal ? { signal } : {}),
+    };
+}
+// ---------------------------------------------------------------------------
+// Transport / MCP helpers
+// ---------------------------------------------------------------------------
+export async function closeTransportBestEffort(transport, context) {
+    try {
+        await transport.close();
+    }
+    catch (error) {
+        logWarn('Transport close failed', { context, error }, Loggers.LOG_HTTP);
+    }
+}
+export async function closeMcpServerBestEffort(server, context) {
+    try {
+        await server.close();
+    }
+    catch (error) {
+        logWarn('MCP server close failed', { context, error }, Loggers.LOG_HTTP);
+    }
+}
+export function createTransportAdapter(transportImpl) {
+    const noopOnClose = () => { };
+    const noopOnError = () => { };
+    const noopOnMessage = () => { };
+    const baseOnClose = transportImpl.onclose;
+    let oncloseHandler = noopOnClose;
+    let onerrorHandler = noopOnError;
+    let onmessageHandler = noopOnMessage;
+    return {
+        start: () => transportImpl.start(),
+        send: (message, options) => transportImpl.send(message, options),
+        close: () => transportImpl.close(),
+        get onclose() {
+            return oncloseHandler;
+        },
+        set onclose(handler) {
+            oncloseHandler = handler;
+            transportImpl.onclose = composeCloseHandlers(baseOnClose, handler);
+        },
+        get onerror() {
+            return onerrorHandler;
+        },
+        set onerror(handler) {
+            onerrorHandler = handler;
+            transportImpl.onerror = handler;
+        },
+        get onmessage() {
+            return onmessageHandler;
+        },
+        set onmessage(handler) {
+            onmessageHandler = handler;
+            transportImpl.onmessage = handler;
+        },
+    };
+}
+export class JsonBodyError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.name = 'JsonBodyError';
+        this.kind = kind;
+    }
+}
+export function isJsonBodyError(error) {
+    return error instanceof JsonBodyError;
+}
+export const DEFAULT_BODY_LIMIT_BYTES = 1024 * 1024;
+function isRequestReadAborted(req) {
+    return req.destroyed && !req.complete;
+}
+class JsonBodyReader {
+    async read(req, limit = DEFAULT_BODY_LIMIT_BYTES, signal) {
+        const contentType = getHeaderValue(req, 'content-type');
+        if (!contentType?.includes('application/json'))
+            return undefined;
+        const contentLengthHeader = getHeaderValue(req, 'content-length');
+        if (contentLengthHeader) {
+            const contentLength = Number.parseInt(contentLengthHeader, 10);
+            if (Number.isFinite(contentLength) && contentLength > limit) {
+                const error = new JsonBodyError('payload-too-large', 'Payload too large');
+                throw error;
+            }
+        }
+        if (signal?.aborted || isRequestReadAborted(req)) {
+            const error = new JsonBodyError('read-failed', 'Request aborted');
+            throw error;
+        }
+        const body = await this.readBody(req, limit, signal);
+        if (!body)
+            return undefined;
+        try {
+            return JSON.parse(body);
+        }
+        catch (err) {
+            const error = new JsonBodyError('invalid-json', getErrorMessage(err));
+            throw error;
+        }
+    }
+    async readBody(req, limit, signal) {
+        const abortListener = signal != null
+            ? () => {
+                destroyRequestBestEffort(req);
+            }
+            : null;
+        if (signal != null && abortListener) {
+            if (signal.aborted) {
+                abortListener();
+            }
+            else {
+                signal.addEventListener('abort', abortListener, { once: true });
+            }
+        }
+        try {
+            const { chunks, size } = await this.collectChunks(req, limit, signal);
+            if (chunks.length === 0)
+                return undefined;
+            const combined = new Uint8Array(size);
+            let offset = 0;
+            for (const chunk of chunks) {
+                combined.set(chunk, offset);
+                offset += chunk.byteLength;
+            }
+            const text = new TextDecoder().decode(combined);
+            return text;
+        }
+        finally {
+            if (signal && abortListener) {
+                try {
+                    signal.removeEventListener('abort', abortListener);
+                }
+                catch {
+                    // Best-effort cleanup.
+                }
+            }
+        }
+    }
+    async collectChunks(req, limit, signal) {
+        let size = 0;
+        const chunks = [];
+        const sink = new Writable({
+            write: (chunk, _encoding, callback) => {
+                try {
+                    if (signal?.aborted || isRequestReadAborted(req)) {
+                        callback(new JsonBodyError('read-failed', 'Request aborted'));
+                        return;
+                    }
+                    const buf = this.normalizeChunk(chunk);
+                    size += buf.byteLength;
+                    if (size > limit) {
+                        callback(new JsonBodyError('payload-too-large', 'Payload too large'));
+                        return;
+                    }
+                    chunks.push(buf);
+                    callback();
+                }
+                catch (err) {
+                    callback(toError(err));
+                }
+            },
+        });
+        try {
+            if (signal?.aborted || isRequestReadAborted(req)) {
+                const error = new JsonBodyError('read-failed', 'Request aborted');
+                throw error;
+            }
+            await pipeline(req, sink, signal ? { signal } : undefined);
+            return { chunks, size };
+        }
+        catch (err) {
+            if (err instanceof JsonBodyError)
+                throw err;
+            if (signal?.aborted || isRequestReadAborted(req)) {
+                const error = new JsonBodyError('read-failed', 'Request aborted');
+                throw error;
+            }
+            const error = new JsonBodyError('read-failed', getErrorMessage(err));
+            throw error;
+        }
+    }
+    normalizeChunk(chunk) {
+        if (typeof chunk === 'string') {
+            const encoded = new TextEncoder().encode(chunk);
+            return encoded;
+        }
+        return chunk;
+    }
+}
+export const jsonBodyReader = new JsonBodyReader();
+function unregisterSessionTaskScope(server) {
+    const sessionId = resolveMcpSessionIdByServer(server);
+    if (!sessionId)
+        return null;
+    unregisterMcpSessionServer(sessionId);
+    return sessionId;
+}
+async function closeSessionResources(session, options) {
+    const closeTasks = [];
+    if (options.closeTransportReason) {
+        closeTasks.push(closeTransportBestEffort(session.transport, options.closeTransportReason));
+    }
+    if (options.closeServerReason) {
+        closeTasks.push(closeMcpServerBestEffort(session.server, options.closeServerReason));
+    }
+    if (options.awaitClose && closeTasks.length > 0) {
+        await Promise.all(closeTasks);
+    }
+}
+export async function teardownSessionResources(session, options) {
+    unregisterSessionTaskScope(session.server);
+    if (options.unregisterByServer) {
+        unregisterMcpSessionServerByServer(session.server);
+    }
+    await closeSessionResources(session, options);
+}
+export async function teardownUnregisteredSessionResources(session, context) {
+    await closeSessionResources(session, {
+        closeTransportReason: context,
+        closeServerReason: context,
+        awaitClose: true,
+    });
+}
+export function teardownSessionRegistration(server) {
+    unregisterSessionTaskScope(server);
+}
+// --- health.ts ---
+// ---------------------------------------------------------------------------
+// Event-loop monitoring
+// ---------------------------------------------------------------------------
+const EVENT_LOOP_DELAY_RESOLUTION_MS = 20;
+const eventLoopDelay = monitorEventLoopDelay({
+    resolution: EVENT_LOOP_DELAY_RESOLUTION_MS,
+});
+let lastEventLoopUtilization = performance.eventLoopUtilization();
+export function resetEventLoopMonitoring() {
+    lastEventLoopUtilization = performance.eventLoopUtilization();
+    eventLoopDelay.reset();
+    eventLoopDelay.enable();
+}
+export function disableEventLoopMonitoring() {
+    eventLoopDelay.disable();
+}
+// ---------------------------------------------------------------------------
+// Stats helpers
+// ---------------------------------------------------------------------------
+function roundTo(value, precision) {
+    const factor = 10 ** precision;
+    return Math.round(value * factor) / factor;
+}
+function formatEventLoopUtilization(snapshot) {
+    return {
+        utilization: roundTo(snapshot.utilization, 4),
+        activeMs: Math.round(snapshot.active),
+        idleMs: Math.round(snapshot.idle),
+    };
+}
+function toMs(valueNs) {
+    return roundTo(valueNs / 1_000_000, 3);
+}
+function getEventLoopStats() {
+    const current = performance.eventLoopUtilization();
+    const delta = performance.eventLoopUtilization(current, lastEventLoopUtilization);
+    lastEventLoopUtilization = current;
+    return {
+        utilization: {
+            total: formatEventLoopUtilization(current),
+            sinceLast: formatEventLoopUtilization(delta),
+        },
+        delay: {
+            minMs: toMs(eventLoopDelay.min),
+            maxMs: toMs(eventLoopDelay.max),
+            meanMs: toMs(eventLoopDelay.mean),
+            stddevMs: toMs(eventLoopDelay.stddev),
+            p50Ms: toMs(eventLoopDelay.percentile(50)),
+            p95Ms: toMs(eventLoopDelay.percentile(95)),
+            p99Ms: toMs(eventLoopDelay.percentile(99)),
+        },
+    };
+}
+function buildHealthResponse(store, includeDiagnostics) {
+    const base = {
+        status: 'ok',
+        version: serverVersion,
+        uptime: Math.floor(process.uptime()),
+        timestamp: new Date().toISOString(),
+    };
+    if (!includeDiagnostics)
+        return base;
+    const poolStats = getTransformPoolStats();
+    return {
+        ...base,
+        os: {
+            hostname: hostname(),
+            platform: process.platform,
+            arch: process.arch,
+            memoryFree: freemem(),
+            memoryTotal: totalmem(),
+        },
+        process: {
+            pid: process.pid,
+            ppid: process.ppid,
+            memory: process.memoryUsage(),
+            cpu: process.cpuUsage(),
+            resource: process.resourceUsage(),
+            ...(typeof process.availableMemory === 'function'
+                ? { availableMemory: process.availableMemory() }
+                : {}),
+            ...(typeof process.constrainedMemory === 'function'
+                ? { constrainedMemory: process.constrainedMemory() }
+                : {}),
+        },
+        perf: getEventLoopStats(),
+        ...(typeof process.getActiveResourcesInfo === 'function'
+            ? { activeResources: process.getActiveResourcesInfo() }
+            : {}),
+        stats: {
+            activeSessions: store.size(),
+            workerPool: poolStats ?? {
+                queueDepth: 0,
+                activeWorkers: 0,
+                capacity: 0,
+            },
+        },
+    };
+}
+function sendHealth(store, res, includeDiagnostics) {
+    res.setHeader('Cache-Control', 'no-store');
+    sendJson(res, 200, buildHealthResponse(store, includeDiagnostics));
+}
+// ---------------------------------------------------------------------------
+// Health route helpers
+// ---------------------------------------------------------------------------
+export function isVerboseHealthRequest(ctx) {
+    const value = ctx.url.searchParams.get('verbose');
+    if (!value)
+        return false;
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true';
+}
+function isHealthRoute(ctx) {
+    return ctx.method === 'GET' && ctx.url.pathname === '/health';
+}
+function isVerboseHealthRoute(ctx) {
+    return isHealthRoute(ctx) && isVerboseHealthRequest(ctx);
+}
+function ensureHealthAuthIfNeeded(ctx, authPresent) {
+    if (!isVerboseHealthRoute(ctx))
+        return true;
+    if (!config.security.allowRemote)
+        return true;
+    if (authPresent)
+        return true;
+    sendJson(ctx.res, 401, {
+        error: 'Authentication required for verbose health metrics',
+    });
+    return false;
+}
+function resolveHealthDiagnosticsMode(ctx, authPresent) {
+    return (isVerboseHealthRoute(ctx) && (authPresent || !config.security.allowRemote));
+}
+export function shouldHandleHealthRoute(ctx) {
+    return isHealthRoute(ctx);
+}
+export function sendHealthRouteResponse(store, ctx, authPresent) {
+    if (!shouldHandleHealthRoute(ctx))
+        return false;
+    if (!ensureHealthAuthIfNeeded(ctx, authPresent))
+        return true;
+    const includeDiagnostics = resolveHealthDiagnosticsMode(ctx, authPresent);
+    sendHealth(store, ctx.res, includeDiagnostics);
+    return true;
+}
 function resolveRequestedProtocolVersion(body) {
     if (!isObject(body))
         return DEFAULT_MCP_PROTOCOL_VERSION;

package/dist/http/rate-limit.d.ts

@@ -1,4 +1,4 @@
-import { type RequestContext } from './helpers.js';
+import { type RequestContext } from './native.js';
 interface RateLimitConfig {
     maxRequests: number;
     windowMs: number;

package/dist/http/rate-limit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/http/rate-limit.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,cAAc,EAAY,MAAM,cAAc,CAAC;AAY7D,UAAU,eAAe;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;IACpC,IAAI,IAAI,IAAI,CAAC;CACd;AA+FD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,GACvB,oBAAoB,CAGtB"}
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/http/rate-limit.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAY,MAAM,aAAa,CAAC;AAY5D,UAAU,eAAe;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC;IACpC,IAAI,IAAI,IAAI,CAAC;CACd;AA+FD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,eAAe,GACvB,oBAAoB,CAGtB"}

package/dist/http/rate-limit.js

@@ -1,8 +1,7 @@
-import { logWarn } from '../lib/core.js';
-import { Loggers } from '../lib/logger-names.js';
-import { isAbortError } from '../lib/utils.js';
+import { Loggers, logWarn } from '../lib/core.js';
+import { isAbortError } from '../lib/error/index.js';
 import { startAbortableIntervalLoop } from '../lib/utils.js';
-import { sendJson } from './helpers.js';
+import { sendJson } from './native.js';
 // ---------------------------------------------------------------------------
 // Rate limiter
 // ---------------------------------------------------------------------------

package/dist/index.d.ts

@@ -1,3 +1,20 @@
 #!/usr/bin/env node
+interface CliValues {
+    readonly stdio: boolean;
+    readonly http: boolean;
+    readonly help: boolean;
+    readonly version: boolean;
+}
+interface CliParseSuccess {
+    readonly ok: true;
+    readonly values: CliValues;
+}
+interface CliParseFailure {
+    readonly ok: false;
+    readonly message: string;
+}
+type CliParseResult = CliParseSuccess | CliParseFailure;
+export declare function renderCliUsage(): string;
+export declare function parseCliArgs(args: readonly string[]): CliParseResult;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAUA,UAAU,SAAS;IACjB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;CAC5B;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,KAAK,cAAc,GAAG,eAAe,GAAG,eAAe,CAAC;AA2CxD,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,cAAc,CA2BpE"}