recker 1.0.2-0

package/dist/mcp/types.d.ts

@@ -0,0 +1,151 @@
+export interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: string | number;
+    method: string;
+    params?: Record<string, unknown> | unknown[];
+}
+export interface JsonRpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: string | number;
+    result?: T;
+    error?: JsonRpcError;
+}
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown> | unknown[];
+}
+export interface MCPServerInfo {
+    name: string;
+    version: string;
+    protocolVersion?: string;
+    capabilities?: MCPCapabilities;
+}
+export interface MCPCapabilities {
+    tools?: {
+        listChanged?: boolean;
+    };
+    resources?: {
+        subscribe?: boolean;
+        listChanged?: boolean;
+    };
+    prompts?: {
+        listChanged?: boolean;
+    };
+    sampling?: Record<string, unknown>;
+    logging?: Record<string, unknown>;
+}
+export interface MCPTool {
+    name: string;
+    description?: string;
+    inputSchema: {
+        type: 'object';
+        properties?: Record<string, unknown>;
+        required?: string[];
+        [key: string]: unknown;
+    };
+}
+export interface MCPToolCall {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export interface MCPToolResult {
+    content: MCPContent[];
+    isError?: boolean;
+}
+export interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface MCPResourceContent {
+    uri: string;
+    mimeType?: string;
+    text?: string;
+    blob?: string;
+}
+export interface MCPPrompt {
+    name: string;
+    description?: string;
+    arguments?: MCPPromptArgument[];
+}
+export interface MCPPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+export interface MCPPromptMessage {
+    role: 'user' | 'assistant';
+    content: MCPContent;
+}
+export type MCPContent = MCPTextContent | MCPImageContent | MCPResourceContent;
+export interface MCPTextContent {
+    type: 'text';
+    text: string;
+}
+export interface MCPImageContent {
+    type: 'image';
+    data: string;
+    mimeType: string;
+}
+export type MCPMethod = 'initialize' | 'ping' | 'tools/list' | 'tools/call' | 'resources/list' | 'resources/read' | 'resources/subscribe' | 'resources/unsubscribe' | 'prompts/list' | 'prompts/get' | 'sampling/createMessage' | 'logging/setLevel';
+export interface MCPInitializeRequest {
+    protocolVersion: string;
+    capabilities: Partial<MCPCapabilities>;
+    clientInfo: {
+        name: string;
+        version: string;
+    };
+}
+export interface MCPInitializeResponse {
+    protocolVersion: string;
+    capabilities: MCPCapabilities;
+    serverInfo: MCPServerInfo;
+}
+export interface MCPToolsListResponse {
+    tools: MCPTool[];
+}
+export interface MCPToolsCallRequest {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export interface MCPResourcesListResponse {
+    resources: MCPResource[];
+}
+export interface MCPResourcesReadRequest {
+    uri: string;
+}
+export interface MCPResourcesReadResponse {
+    contents: MCPResourceContent[];
+}
+export interface MCPPromptsListResponse {
+    prompts: MCPPrompt[];
+}
+export interface MCPPromptsGetRequest {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export interface MCPPromptsGetResponse {
+    description?: string;
+    messages: MCPPromptMessage[];
+}
+export type MCPNotification = 'notifications/initialized' | 'notifications/progress' | 'notifications/message' | 'notifications/resources/updated' | 'notifications/resources/list_changed' | 'notifications/tools/list_changed' | 'notifications/prompts/list_changed';
+export interface MCPProgressNotification {
+    progressToken: string | number;
+    progress: number;
+    total?: number;
+}
+export interface MCPTransportOptions {
+    endpoint: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    retries?: number;
+    transport?: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/mcp/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/mcp/types.ts"],"names":[],"mappings":"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"}

package/dist/mcp/types.js

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

package/dist/plugins/cache.d.ts

@@ -0,0 +1,10 @@
+import { CacheStorage, CacheStrategy, Plugin, ReckerRequest } from '../types/index.js';
+export interface CacheOptions {
+    storage?: CacheStorage;
+    strategy?: CacheStrategy;
+    ttl?: number;
+    methods?: string[];
+    keyGenerator?: (req: ReckerRequest) => string;
+}
+export declare function cache(options?: CacheOptions): Plugin;
+//# sourceMappingURL=cache.d.ts.map

package/dist/plugins/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/plugins/cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,aAAa,EAAc,MAAM,EAAE,aAAa,EAAkB,MAAM,mBAAmB,CAAC;AAInH,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,MAAM,CAAC;CAC/C;AAED,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CAgGxD"}

package/dist/plugins/cache.js

@@ -0,0 +1,72 @@
+import { HttpResponse } from '../core/response.js';
+import { MemoryStorage } from '../cache/memory-storage.js';
+export function cache(options = {}) {
+    const storage = options.storage || new MemoryStorage();
+    const strategy = options.strategy || 'cache-first';
+    const ttl = options.ttl || 60 * 1000;
+    const methods = options.methods || ['GET'];
+    const generateKey = options.keyGenerator || ((req) => {
+        return `${req.method}:${req.url}`;
+    });
+    const cacheMiddleware = async (req, next) => {
+        if (!methods.includes(req.method)) {
+            return next(req);
+        }
+        const key = generateKey(req);
+        if (strategy === 'network-only') {
+            return next(req);
+        }
+        const cachedEntry = await storage.get(key);
+        if (cachedEntry) {
+            if (strategy === 'cache-first' || strategy === 'stale-while-revalidate') {
+                const cachedResponse = new Response(cachedEntry.body, {
+                    status: cachedEntry.status,
+                    statusText: cachedEntry.statusText,
+                    headers: cachedEntry.headers,
+                });
+                const reckerResponse = new HttpResponse(cachedResponse);
+                if (strategy === 'stale-while-revalidate') {
+                    (async () => {
+                        try {
+                            const freshResponse = await next(req);
+                            if (freshResponse.ok) {
+                                const text = await freshResponse.text();
+                                const headers = {};
+                                freshResponse.headers.forEach((v, k) => headers[k] = v);
+                                await storage.set(key, {
+                                    status: freshResponse.status,
+                                    statusText: freshResponse.statusText,
+                                    headers: headers,
+                                    body: text,
+                                    timestamp: Date.now(),
+                                }, ttl);
+                            }
+                        }
+                        catch (err) {
+                            console.error('Background cache revalidation failed', err);
+                        }
+                    })();
+                }
+                return reckerResponse;
+            }
+        }
+        const response = await next(req);
+        if (response.ok) {
+            const clonedResponse = response.raw.clone();
+            const text = await clonedResponse.text();
+            const headers = {};
+            response.headers.forEach((v, k) => headers[k] = v);
+            await storage.set(key, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: headers,
+                body: text,
+                timestamp: Date.now(),
+            }, ttl);
+        }
+        return response;
+    };
+    return (client) => {
+        client.use(cacheMiddleware);
+    };
+}

package/dist/plugins/circuit-breaker.d.ts

@@ -0,0 +1,14 @@
+import { Plugin, ReckerResponse } from '../types/index.js';
+export interface CircuitBreakerOptions {
+    threshold?: number;
+    resetTimeout?: number;
+    shouldTrip?: (error: any, response?: ReckerResponse) => boolean;
+    onStateChange?: (state: CircuitState, service: string) => void;
+}
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+export declare class CircuitBreakerError extends Error {
+    service: string;
+    constructor(service: string);
+}
+export declare function circuitBreaker(options?: CircuitBreakerOptions): Plugin;
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/plugins/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/plugins/circuit-breaker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IAEpC,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC;IAEhE,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAChE;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAQ3D,qBAAa,mBAAoB,SAAQ,KAAK;IACzB,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAInC;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CA6G1E"}

package/dist/plugins/circuit-breaker.js

@@ -0,0 +1,100 @@
+export class CircuitBreakerError extends Error {
+    service;
+    constructor(service) {
+        super(`Circuit breaker is OPEN for ${service}`);
+        this.service = service;
+        this.name = 'CircuitBreakerError';
+    }
+}
+export function circuitBreaker(options = {}) {
+    const threshold = options.threshold || 5;
+    const resetTimeout = options.resetTimeout || 30000;
+    const circuits = new Map();
+    const getCircuitKey = (req) => {
+        try {
+            return new URL(req.url).hostname;
+        }
+        catch {
+            return 'unknown';
+        }
+    };
+    const shouldTrip = options.shouldTrip || ((err, res) => {
+        if (res)
+            return res.status >= 500;
+        return true;
+    });
+    return (client) => {
+        client.beforeRequest((req) => {
+            const key = getCircuitKey(req);
+            let stats = circuits.get(key);
+            if (!stats) {
+                stats = { failures: 0, lastFailureTime: 0, state: 'CLOSED' };
+                circuits.set(key, stats);
+            }
+            if (stats.state === 'OPEN') {
+                const now = Date.now();
+                if (now - stats.lastFailureTime > resetTimeout) {
+                    stats.state = 'HALF_OPEN';
+                    if (options.onStateChange)
+                        options.onStateChange('HALF_OPEN', key);
+                }
+                else {
+                    throw new CircuitBreakerError(key);
+                }
+            }
+        });
+        client.afterResponse((req, res) => {
+            const key = getCircuitKey(req);
+            const stats = circuits.get(key);
+            if (!stats)
+                return;
+            const isFailure = shouldTrip(null, res);
+            if (isFailure) {
+                handleFailure(stats, key);
+            }
+            else {
+                handleSuccess(stats, key);
+            }
+        });
+        client.onError((err, req) => {
+            if (err instanceof CircuitBreakerError) {
+                throw err;
+            }
+            const key = getCircuitKey(req);
+            const stats = circuits.get(key);
+            if (!stats)
+                return;
+            const isFailure = shouldTrip(err, undefined);
+            if (isFailure) {
+                handleFailure(stats, key);
+            }
+        });
+        function handleSuccess(stats, key) {
+            if (stats.state === 'HALF_OPEN') {
+                stats.state = 'CLOSED';
+                stats.failures = 0;
+                if (options.onStateChange)
+                    options.onStateChange('CLOSED', key);
+            }
+            else if (stats.state === 'CLOSED') {
+                stats.failures = 0;
+            }
+        }
+        function handleFailure(stats, key) {
+            stats.failures++;
+            stats.lastFailureTime = Date.now();
+            if (stats.state === 'HALF_OPEN') {
+                stats.state = 'OPEN';
+                if (options.onStateChange)
+                    options.onStateChange('OPEN', key);
+            }
+            else if (stats.state === 'CLOSED') {
+                if (stats.failures >= threshold) {
+                    stats.state = 'OPEN';
+                    if (options.onStateChange)
+                        options.onStateChange('OPEN', key);
+                }
+            }
+        }
+    };
+}

package/dist/plugins/compression.d.ts

@@ -0,0 +1,5 @@
+import { Middleware, CompressionOptions } from '../types/index.js';
+export type CompressionAlgorithm = 'gzip' | 'deflate' | 'br';
+export declare function compression(options?: CompressionOptions): Middleware;
+export declare function createCompressionMiddleware(config: boolean | CompressionOptions): Middleware | null;
+//# sourceMappingURL=compression.d.ts.map

package/dist/plugins/compression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/plugins/compression.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAMnE,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAiI7D,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,UAAU,CAoExE;AAKD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,OAAO,GAAG,kBAAkB,GACnC,UAAU,GAAG,IAAI,CAUnB"}

package/dist/plugins/compression.js

@@ -0,0 +1,128 @@
+import { gzip, deflate, brotliCompress } from 'node:zlib';
+import { promisify } from 'node:util';
+const gzipAsync = promisify(gzip);
+const deflateAsync = promisify(deflate);
+const brotliAsync = promisify(brotliCompress);
+function isCompressible(contentType) {
+    if (!contentType)
+        return true;
+    const compressibleTypes = [
+        'text/',
+        'application/json',
+        'application/xml',
+        'application/javascript',
+        'application/x-www-form-urlencoded'
+    ];
+    return compressibleTypes.some(type => contentType.includes(type));
+}
+function getBodySize(body) {
+    if (!body)
+        return 0;
+    if (typeof body === 'string') {
+        return Buffer.byteLength(body, 'utf8');
+    }
+    if (body instanceof Buffer) {
+        return body.length;
+    }
+    if (body instanceof ArrayBuffer) {
+        return body.byteLength;
+    }
+    if (body instanceof Blob) {
+        return body.size;
+    }
+    if (typeof body === 'object') {
+        try {
+            return Buffer.byteLength(JSON.stringify(body), 'utf8');
+        }
+        catch {
+            return 0;
+        }
+    }
+    return 0;
+}
+function toBuffer(body) {
+    if (!body)
+        return null;
+    if (Buffer.isBuffer(body)) {
+        return body;
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body);
+    }
+    if (typeof body === 'object') {
+        try {
+            return Buffer.from(JSON.stringify(body), 'utf8');
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+async function compress(data, algorithm) {
+    switch (algorithm) {
+        case 'gzip':
+            return await gzipAsync(data);
+        case 'deflate':
+            return await deflateAsync(data);
+        case 'br':
+            return await brotliAsync(data);
+        default:
+            throw new Error(`Unsupported compression algorithm: ${algorithm}`);
+    }
+}
+export function compression(options = {}) {
+    const { algorithm = 'gzip', threshold = 1024, force = false, methods = ['POST', 'PUT', 'PATCH'] } = options;
+    return async (req, next) => {
+        const shouldCompress = methods.includes(req.method);
+        if (!shouldCompress || !req.body) {
+            return next(req);
+        }
+        if (req.headers.has('Content-Encoding')) {
+            return next(req);
+        }
+        const contentType = req.headers.get('Content-Type');
+        if (!isCompressible(contentType)) {
+            return next(req);
+        }
+        const bodySize = getBodySize(req.body);
+        if (!force && bodySize < threshold) {
+            return next(req);
+        }
+        const buffer = toBuffer(req.body);
+        if (!buffer) {
+            return next(req);
+        }
+        try {
+            const compressed = await compress(buffer, algorithm);
+            if (!force && compressed.length >= buffer.length) {
+                return next(req);
+            }
+            const newHeaders = new Headers(req.headers);
+            newHeaders.set('Content-Encoding', algorithm);
+            newHeaders.set('Content-Length', compressed.length.toString());
+            const compressedReq = {
+                ...req,
+                body: compressed,
+                headers: newHeaders
+            };
+            return next(compressedReq);
+        }
+        catch (error) {
+            console.error('Compression failed:', error);
+            return next(req);
+        }
+    };
+}
+export function createCompressionMiddleware(config) {
+    if (!config) {
+        return null;
+    }
+    if (config === true) {
+        return compression();
+    }
+    return compression(config);
+}

package/dist/plugins/cookie-jar.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from '../types/index.js';
+export interface CookieJarOptions {
+    store?: Map<string, string>;
+}
+export declare function cookieJar(options?: CookieJarOptions): Plugin;
+//# sourceMappingURL=cookie-jar.d.ts.map

package/dist/plugins/cookie-jar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookie-jar.d.ts","sourceRoot":"","sources":["../../src/plugins/cookie-jar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiC,MAAM,mBAAmB,CAAC;AAE1E,MAAM,WAAW,gBAAgB;IAE/B,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAMD,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,MAAM,CAsGhE"}

package/dist/plugins/cookie-jar.js

@@ -0,0 +1,72 @@
+export function cookieJar(options = {}) {
+    const store = new Map();
+    if (options.store) {
+        if (options.store instanceof Map) {
+            store.set('*', options.store);
+        }
+    }
+    return (client) => {
+        client.beforeRequest((req) => {
+            const url = new URL(req.url);
+            const hostname = url.hostname;
+            const cookieList = [];
+            const addCookies = (domainStore) => {
+                if (domainStore) {
+                    domainStore.forEach((value, key) => {
+                        cookieList.push(`${key}=${value}`);
+                    });
+                }
+            };
+            addCookies(store.get(hostname));
+            for (const [domain, domainStore] of store.entries()) {
+                if (domain !== '*' && domain !== hostname && hostname.endsWith(domain)) {
+                    addCookies(domainStore);
+                }
+                if (domain === '*') {
+                    addCookies(domainStore);
+                }
+            }
+            if (cookieList.length > 0) {
+                const existing = req.headers.get('cookie');
+                const newCookies = cookieList.join('; ');
+                req.headers.set('cookie', existing ? `${existing}; ${newCookies}` : newCookies);
+            }
+        });
+        client.afterResponse((req, res) => {
+            const setCookie = res.headers.get('set-cookie');
+            if (!setCookie)
+                return;
+            const url = new URL(req.url);
+            let domain = url.hostname;
+            const cookies = splitCookies(setCookie);
+            cookies.forEach(cookieStr => {
+                const parts = cookieStr.split(';');
+                const [nameValue] = parts;
+                if (!nameValue)
+                    return;
+                const [key, ...valParts] = nameValue.split('=');
+                if (!key)
+                    return;
+                const value = valParts.join('=').trim();
+                let specificDomain = domain;
+                const domainPart = parts.find(p => p.trim().toLowerCase().startsWith('domain='));
+                if (domainPart) {
+                    const d = domainPart.split('=')[1]?.trim();
+                    if (d)
+                        specificDomain = d;
+                }
+                if (!store.has(specificDomain)) {
+                    store.set(specificDomain, new Map());
+                }
+                const domainStore = store.get(specificDomain);
+                domainStore.set(key.trim(), value);
+                if (options.store) {
+                    options.store.set(key.trim(), value);
+                }
+            });
+        });
+    };
+}
+function splitCookies(header) {
+    return header.split(/,(?=\s*[a-zA-Z0-9_]+=[^;])/g);
+}

package/dist/plugins/dedup.d.ts

@@ -0,0 +1,6 @@
+import { Plugin, ReckerRequest } from '../types/index.js';
+export interface DedupOptions {
+    keyGenerator?: (req: ReckerRequest) => string;
+}
+export declare function dedup(options?: DedupOptions): Plugin;
+//# sourceMappingURL=dedup.d.ts.map

package/dist/plugins/dedup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup.d.ts","sourceRoot":"","sources":["../../src/plugins/dedup.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEtE,MAAM,WAAW,YAAY;IAC3B,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,MAAM,CAAC;CAC/C;AAED,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CAiExD"}

package/dist/plugins/dedup.js

@@ -0,0 +1,34 @@
+export function dedup(options = {}) {
+    const pendingRequests = new Map();
+    const generateKey = options.keyGenerator || ((req) => {
+        return `${req.method}:${req.url}`;
+    });
+    const dedupMiddleware = async (req, next) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            return next(req);
+        }
+        const key = generateKey(req);
+        if (pendingRequests.has(key)) {
+            const response = await pendingRequests.get(key);
+            return response.clone();
+        }
+        const promise = next(req)
+            .then((res) => {
+            return res;
+        })
+            .finally(() => {
+            pendingRequests.delete(key);
+        });
+        pendingRequests.set(key, promise);
+        try {
+            const response = await promise;
+            return response.clone ? response.clone() : response;
+        }
+        catch (err) {
+            throw err;
+        }
+    };
+    return (client) => {
+        client.use(dedupMiddleware);
+    };
+}

package/dist/plugins/graphql.d.ts

@@ -0,0 +1,13 @@
+import { Plugin, ReckerResponse } from '../types/index.js';
+import { Client } from '../core/client.js';
+export declare class GraphQLError extends Error {
+    errors: any[];
+    response: ReckerResponse;
+    constructor(errors: any[], response: ReckerResponse);
+}
+export interface GraphQLOptions {
+    throwOnErrors?: boolean;
+}
+export declare function graphqlPlugin(options?: GraphQLOptions): Plugin;
+export declare function graphql<T = any>(client: Client, query: string, variables?: Record<string, any>, options?: any): Promise<T>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/plugins/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../src/plugins/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA6B,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACtF,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,qBAAa,YAAa,SAAQ,KAAK;IAClB,MAAM,EAAE,GAAG,EAAE;IAAS,QAAQ,EAAE,cAAc;gBAA9C,MAAM,EAAE,GAAG,EAAE,EAAS,QAAQ,EAAE,cAAc;CAIlE;AAED,MAAM,WAAW,cAAc;IAE7B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAOD,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CA4BlE;AAQD,wBAAsB,OAAO,CAAC,CAAC,GAAG,GAAG,EACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACnC,OAAO,GAAE,GAAQ,GAClB,OAAO,CAAC,CAAC,CAAC,CAIZ"}