@bxb1337/windsurf-fast-context 1.0.0

package/dist/esm/provider.test.js

@@ -0,0 +1,59 @@
+import { describe, it, expect } from 'vitest';
+import { createWindsurfProvider, windsurf } from './provider.js';
+import { DevstralLanguageModel } from './model/devstral-language-model.js';
+// Helper to narrow the returned model in tests without using `any`.
+function providerShape(m) {
+    return m;
+}
+describe('provider factory', () => {
+    it('with-api-key: constructs model when apiKey passed explicitly', () => {
+        const factory = createWindsurfProvider({ apiKey: 'explicit-key' });
+        const model = factory('MODEL_SWE_1_6_FAST');
+        expect(model).toBeInstanceOf(DevstralLanguageModel);
+        expect(providerShape(model).apiKey).toBe('explicit-key');
+    });
+    it('env-var: uses WINDSURF_API_KEY when apiKey not provided', () => {
+        const old = process.env.WINDSURF_API_KEY;
+        try {
+            process.env.WINDSURF_API_KEY = 'env-key';
+            const factory = createWindsurfProvider();
+            const model = factory('MODEL_SWE_1_6_FAST');
+            expect(providerShape(model).apiKey).toBe('env-key');
+        }
+        finally {
+            if (old === undefined)
+                delete process.env.WINDSURF_API_KEY;
+            else
+                process.env.WINDSURF_API_KEY = old;
+        }
+    });
+    it('no-key: throws when no api key available', () => {
+        const old = process.env.WINDSURF_API_KEY;
+        try {
+            delete process.env.WINDSURF_API_KEY;
+            const factory = createWindsurfProvider();
+            expect(() => factory('MODEL_SWE_1_6_FAST')).toThrow('WINDSURF_API_KEY is required');
+        }
+        finally {
+            if (old === undefined)
+                delete process.env.WINDSURF_API_KEY;
+            else
+                process.env.WINDSURF_API_KEY = old;
+        }
+    });
+    it('custom-baseurl: passes baseURL and trims trailing slash', () => {
+        const factory = createWindsurfProvider({ apiKey: 'k', baseURL: 'https://example.com/' });
+        const model = factory('MODEL_SWE_1_6_FAST');
+        expect(providerShape(model).baseURL).toBe('https://example.com');
+    });
+    it('custom-headers: passes headers through to model', () => {
+        const headers = { 'x-foo': 'bar' };
+        const factory = createWindsurfProvider({ apiKey: 'k', headers });
+        const model = factory('MODEL_SWE_1_6_FAST');
+        expect(providerShape(model).headers['x-foo']).toBe('bar');
+    });
+    it('exports: named factory and default windsurf', () => {
+        expect(typeof createWindsurfProvider).toBe('function');
+        expect(windsurf).toBeDefined();
+    });
+});

package/dist/esm/scripts/postbuild.js

@@ -0,0 +1,10 @@
+import { writeFileSync, existsSync } from 'fs';
+const esmIndex = `export * from './esm/index.js';\n`;
+writeFileSync('dist/index.js', esmIndex);
+const cjsIndex = `exports.__esModule = true;\nmodule.exports = require('./cjs/index.js');\n`;
+writeFileSync('dist/index.cjs', cjsIndex);
+const typesPath = 'dist/index.d.ts';
+if (!existsSync(typesPath)) {
+    writeFileSync(typesPath, 'export {}\n');
+}
+console.log('postbuild: wrapped ESM/CJS entries and ensured types');

package/dist/esm/src/index.js

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

package/dist/esm/transport/http.js

@@ -0,0 +1,78 @@
+export class DevstralTransportError extends Error {
+    code;
+    status;
+    constructor(code, message, status, options) {
+        super(message, options);
+        this.name = 'DevstralTransportError';
+        this.code = code;
+        this.status = status;
+    }
+}
+export class DevstralTransport {
+    fetchFn;
+    maxAttempts;
+    constructor(options = {}) {
+        this.fetchFn = options.fetch ?? fetch;
+        this.maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+    }
+    postUnary(url, body, headers) {
+        return this.postUnaryRequest(url, body, headers);
+    }
+    postStreaming(url, body, headers, signal) {
+        return this.postStreamingRequest(url, body, headers, signal);
+    }
+    async postUnaryRequest(url, body, headers) {
+        const response = await this.post(url, body, headers);
+        return Buffer.from(await response.arrayBuffer());
+    }
+    async postStreamingRequest(url, body, headers, signal) {
+        const response = await this.post(url, body, headers, signal);
+        if (response.body == null) {
+            throw new DevstralTransportError('NETWORK_ERROR', 'Streaming response body is unavailable', response.status);
+        }
+        return response.body;
+    }
+    async post(url, body, headers, signal) {
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+            try {
+                const response = await this.fetchFn(url, {
+                    method: 'POST',
+                    headers,
+                    body,
+                    signal,
+                });
+                if (response.ok) {
+                    return response;
+                }
+                if (response.status === 403) {
+                    throw new DevstralTransportError('AUTH_ERROR', 'HTTP 403', response.status);
+                }
+                if (response.status === 429) {
+                    throw new DevstralTransportError('RATE_LIMITED', 'HTTP 429', response.status);
+                }
+                if (response.status >= 500 && response.status < 600) {
+                    if (attempt < this.maxAttempts) {
+                        continue;
+                    }
+                    throw new DevstralTransportError('NETWORK_ERROR', `HTTP ${response.status}`, response.status);
+                }
+                throw new DevstralTransportError('NETWORK_ERROR', `HTTP ${response.status}`, response.status);
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    throw error;
+                }
+                if (error instanceof DevstralTransportError) {
+                    throw error;
+                }
+                throw new DevstralTransportError('NETWORK_ERROR', 'Network request failed', undefined, {
+                    cause: error,
+                });
+            }
+        }
+        throw new DevstralTransportError('NETWORK_ERROR', 'Network request failed');
+    }
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}

package/dist/esm/transport/http.test.js

@@ -0,0 +1,194 @@
+import { describe, expect, it } from 'vitest';
+import { DevstralTransport, DevstralTransportError } from './http.js';
+const requestBytes = Buffer.from([1, 2, 3, 4]);
+const responseBytes = Buffer.from([9, 8, 7, 6]);
+function bufferFromBody(body) {
+    if (body == null) {
+        return Buffer.alloc(0);
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    }
+    throw new Error(`Unsupported request body type: ${typeof body}`);
+}
+function makeResponse(status, body) {
+    return new Response(Uint8Array.from(body), { status });
+}
+function makeChunkStream(chunks) {
+    let index = 0;
+    return new ReadableStream({
+        pull(controller) {
+            const chunk = chunks[index];
+            if (!chunk) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(chunk);
+            index += 1;
+        },
+    });
+}
+async function readStreamBytes(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+        const next = await reader.read();
+        if (next.done) {
+            break;
+        }
+        chunks.push(Buffer.from(next.value));
+    }
+    return Buffer.concat(chunks);
+}
+function makeFakeFetch(sequence) {
+    const calls = [];
+    const queue = [...sequence];
+    const fakeFetch = async (input, init) => {
+        calls.push({ input, init });
+        const next = queue.shift();
+        if (!next) {
+            throw new Error('No fake fetch result configured');
+        }
+        if (next instanceof Error) {
+            throw next;
+        }
+        return next;
+    };
+    return { fakeFetch, calls };
+}
+describe('unary transport', () => {
+    it('unary posts bytes and returns response bytes', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([makeResponse(200, responseBytes)]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        const headers = new Headers({ 'content-type': 'application/grpc+proto' });
+        const output = await transport.postUnary('https://api.test/unary', requestBytes, headers);
+        expect(output).toEqual(responseBytes);
+        expect(calls).toHaveLength(1);
+        expect(calls[0]?.input).toBe('https://api.test/unary');
+        expect(calls[0]?.init?.method).toBe('POST');
+        expect(calls[0]?.init?.headers).toBe(headers);
+        expect(bufferFromBody(calls[0]?.init?.body)).toEqual(requestBytes);
+    });
+    it('unary retries 5xx responses and eventually succeeds', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([
+            makeResponse(500, Buffer.from('first-failure')),
+            makeResponse(502, Buffer.from('second-failure')),
+            makeResponse(200, responseBytes),
+        ]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        const output = await transport.postUnary('https://api.test/unary', requestBytes, new Headers());
+        expect(output).toEqual(responseBytes);
+        expect(calls).toHaveLength(3);
+    });
+});
+describe('streaming transport', () => {
+    it('streaming posts bytes and returns response stream without pre-buffering', async () => {
+        let arrayBufferCalled = false;
+        const streamingBody = makeChunkStream([
+            Uint8Array.from([9, 8]),
+            Uint8Array.from([7, 6]),
+        ]);
+        const streamingResponse = {
+            ok: true,
+            status: 200,
+            body: streamingBody,
+            arrayBuffer: async () => {
+                arrayBufferCalled = true;
+                throw new Error('arrayBuffer should not be called for streaming responses');
+            },
+        };
+        const { fakeFetch, calls } = makeFakeFetch([streamingResponse]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        const headers = new Headers({ accept: 'application/connect+proto' });
+        const output = await transport.postStreaming('https://api.test/stream', requestBytes, headers);
+        expect(output).toBe(streamingBody);
+        expect(await readStreamBytes(output)).toEqual(responseBytes);
+        expect(arrayBufferCalled).toBe(false);
+        expect(calls).toHaveLength(1);
+        expect(calls[0]?.input).toBe('https://api.test/stream');
+        expect(calls[0]?.init?.method).toBe('POST');
+        expect(calls[0]?.init?.headers).toBe(headers);
+        expect(bufferFromBody(calls[0]?.init?.body)).toEqual(requestBytes);
+    });
+    it('streaming throws NETWORK_ERROR when response body stream is missing', async () => {
+        const responseWithoutBody = {
+            ok: true,
+            status: 200,
+            body: null,
+            arrayBuffer: async () => Buffer.alloc(0),
+        };
+        const { fakeFetch } = makeFakeFetch([responseWithoutBody]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        await expect(transport.postStreaming('https://api.test/stream', requestBytes, new Headers())).rejects.toMatchObject({
+            code: 'NETWORK_ERROR',
+            message: 'Streaming response body is unavailable',
+        });
+    });
+    it('streaming uses AbortSignal to cancel request', async () => {
+        const controller = new AbortController();
+        const abortedError = new Error('Request aborted');
+        abortedError.name = 'AbortError';
+        const calls = [];
+        const fakeFetch = async (input, init) => {
+            calls.push({ input, init });
+            if (init?.signal?.aborted) {
+                throw abortedError;
+            }
+            return makeResponse(200, responseBytes);
+        };
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        controller.abort();
+        await expect(transport.postStreaming('https://api.test/stream', requestBytes, new Headers(), controller.signal)).rejects.toMatchObject({ name: 'AbortError' });
+        expect(calls).toHaveLength(1);
+        expect(calls[0]?.init?.signal).toBe(controller.signal);
+    });
+});
+describe('error classification', () => {
+    it('error maps 403 to AUTH_ERROR without retrying', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([makeResponse(403, Buffer.from('forbidden'))]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        await expect(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'AUTH_ERROR' });
+        expect(calls).toHaveLength(1);
+    });
+    it('error maps 429 to RATE_LIMITED without retrying', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([makeResponse(429, Buffer.from('limited'))]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        await expect(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'RATE_LIMITED' });
+        expect(calls).toHaveLength(1);
+    });
+    it('error maps network failures to NETWORK_ERROR', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([new Error('socket hang up')]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        await expect(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
+        expect(calls).toHaveLength(1);
+    });
+    it('error does not downgrade https requests on TLS failures', async () => {
+        const calls = [];
+        const fakeFetch = async (input, init) => {
+            calls.push({ input, init });
+            throw new Error('TLS certificate verify failed');
+        };
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        const request = transport.postUnary('https://api.test/unary', requestBytes, new Headers());
+        await expect(request).rejects.toBeInstanceOf(DevstralTransportError);
+        await expect(request).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
+        expect(calls).toHaveLength(1);
+        expect(calls[0]?.input).toBe('https://api.test/unary');
+    });
+    it('error retries 5xx responses before throwing NETWORK_ERROR', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([
+            makeResponse(500, Buffer.from('fail-1')),
+            makeResponse(500, Buffer.from('fail-2')),
+            makeResponse(503, Buffer.from('fail-3')),
+        ]);
+        const transport = new DevstralTransport({ fetch: fakeFetch });
+        await expect(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
+        expect(calls).toHaveLength(3);
+    });
+});

package/dist/esm/types/index.js

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

package/dist/esm/vitest.config.js

@@ -0,0 +1,6 @@
+export default {
+    test: {
+        globals: false,
+        passWithNoTests: true,
+    },
+};

package/dist/index.cjs

@@ -0,0 +1,2 @@
+exports.__esModule = true;
+module.exports = require('./cjs/index.js');

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types/index.js';
+export { createWindsurfProvider, windsurf } from './provider.js';
+export { default } from './provider.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './esm/index.js';

package/dist/model/devstral-language-model.d.ts

@@ -0,0 +1,118 @@
+import { JwtManager } from '../auth/jwt-manager.js';
+import { type LanguageModelV3Prompt } from '../conversion/prompt-converter.js';
+import { DevstralTransport } from '../transport/http.js';
+import type { WindsurfProviderOptions } from '../types/index.js';
+export interface LanguageModelV3FunctionTool {
+    description?: string;
+    parameters?: unknown;
+}
+export interface LanguageModelV3CallOptions {
+    prompt: LanguageModelV3Prompt;
+    tools?: Record<string, LanguageModelV3FunctionTool>;
+    abortSignal?: AbortSignal;
+}
+export interface LanguageModelV3GenerateResult {
+    content: GenerateContentPart[];
+    finishReason: {
+        unified: 'stop';
+        raw: string | undefined;
+    };
+    usage: {
+        inputTokens: {
+            total: number | undefined;
+            noCache: number | undefined;
+            cacheRead: number | undefined;
+            cacheWrite: number | undefined;
+        };
+        outputTokens: {
+            total: number | undefined;
+            text: number | undefined;
+            reasoning: number | undefined;
+        };
+    };
+    warnings: unknown[];
+}
+export interface LanguageModelV3StreamResult {
+    stream: ReadableStream<LanguageModelV3StreamPart>;
+}
+interface LanguageModelV3ToolCallContent {
+    type: 'tool-call';
+    toolCallType: 'function';
+    toolCallId: string;
+    toolName: string;
+    args: string;
+}
+type GenerateContentPart = {
+    type: 'text';
+    text: string;
+} | LanguageModelV3ToolCallContent;
+type LanguageModelV3StreamPart = {
+    type: 'stream-start';
+    warnings: unknown[];
+} | {
+    type: 'response-metadata';
+    modelId: string;
+} | {
+    type: 'text-start';
+    id: string;
+} | {
+    type: 'text-delta';
+    id: string;
+    delta: string;
+} | {
+    type: 'text-end';
+    id: string;
+} | {
+    type: 'tool-input-start';
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: 'tool-input-delta';
+    toolCallId: string;
+    delta: string;
+} | {
+    type: 'tool-input-end';
+    toolCallId: string;
+} | LanguageModelV3ToolCallContent | {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'finish';
+    finishReason: {
+        unified: 'stop';
+        raw: string | undefined;
+    };
+    usage: {
+        inputTokens: {
+            total: number | undefined;
+            noCache: number | undefined;
+            cacheRead: number | undefined;
+            cacheWrite: number | undefined;
+        };
+        outputTokens: {
+            total: number | undefined;
+            text: number | undefined;
+            reasoning: number | undefined;
+        };
+    };
+};
+export interface DevstralLanguageModelOptions extends WindsurfProviderOptions {
+    modelId?: string;
+    transport?: DevstralTransport;
+    jwtManager?: JwtManager;
+}
+export declare class DevstralLanguageModel {
+    readonly specificationVersion = "v3";
+    readonly provider = "windsurf";
+    readonly modelId: string;
+    readonly supportedUrls: Record<string, RegExp[]>;
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly headers;
+    private readonly transport;
+    private readonly jwtManager;
+    constructor(options?: DevstralLanguageModelOptions);
+    doGenerate(options: LanguageModelV3CallOptions): Promise<LanguageModelV3GenerateResult>;
+    doStream(options: LanguageModelV3CallOptions): Promise<LanguageModelV3StreamResult>;
+}
+export {};

package/dist/model/devstral-language-model.test.d.ts

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

package/dist/protocol/connect-frame.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Encode a protobuf payload into a Connect-RPC frame.
+ *
+ * @param payload - The raw protobuf bytes to encode
+ * @param compress - Whether to gzip-compress the payload (default: true)
+ *                   When true, the payload is gzipped and flags=1 is set
+ * @returns Buffer containing: [flags byte][4-byte length][payload (gzipped if compress=true)]
+ */
+export declare function connectFrameEncode(payload: Buffer, compress?: boolean): Buffer;
+export declare function connectFrameDecode(buffer: Buffer): Buffer[];

package/dist/protocol/connect-frame.test.d.ts

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

package/dist/protocol/protobuf.d.ts

@@ -0,0 +1,11 @@
+export declare class ProtobufEncoder {
+    private readonly chunks;
+    writeVarint(field: number, value: number): void;
+    writeString(field: number, value: string): void;
+    writeBytes(field: number, data: Buffer): void;
+    writeMessage(field: number, encoder: ProtobufEncoder): void;
+    toBuffer(): Buffer;
+    private writeTag;
+}
+export declare function decodeVarint(buffer: Buffer, offset: number): [value: number, newOffset: number];
+export declare function extractStrings(buffer: Buffer): string[];

package/dist/protocol/protobuf.test.d.ts

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

package/dist/provider.d.ts

@@ -0,0 +1,5 @@
+import { DevstralLanguageModel } from './model/devstral-language-model.js';
+import type { WindsurfProviderOptions } from './types/index.js';
+export declare function createWindsurfProvider(options?: WindsurfProviderOptions): (modelId?: string) => DevstralLanguageModel;
+export declare const windsurf: (modelId?: string) => DevstralLanguageModel;
+export default windsurf;

package/dist/provider.test.d.ts

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

package/dist/transport/http.d.ts

@@ -0,0 +1,22 @@
+type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type DevstralTransportErrorCode = 'AUTH_ERROR' | 'RATE_LIMITED' | 'NETWORK_ERROR';
+export declare class DevstralTransportError extends Error {
+    readonly code: DevstralTransportErrorCode;
+    readonly status?: number;
+    constructor(code: DevstralTransportErrorCode, message: string, status?: number, options?: ErrorOptions);
+}
+export interface DevstralTransportOptions {
+    fetch?: FetchLike;
+    maxAttempts?: number;
+}
+export declare class DevstralTransport {
+    private readonly fetchFn;
+    private readonly maxAttempts;
+    constructor(options?: DevstralTransportOptions);
+    postUnary(url: string, body: Buffer, headers: Headers): Promise<Buffer>;
+    postStreaming(url: string, body: Buffer, headers: Headers, signal?: AbortSignal): Promise<ReadableStream<Uint8Array>>;
+    private postUnaryRequest;
+    private postStreamingRequest;
+    private post;
+}
+export {};

package/dist/transport/http.test.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,37 @@
+export interface WindsurfProviderOptions {
+    apiKey?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    fetch?: FetchFn;
+    generateId?: () => string;
+}
+export type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface Tool<Input = unknown, Output = unknown> {
+    id: string;
+    name?: string;
+    run?: (input: Input) => Promise<Output> | Output;
+}
+export interface Model {
+    id: string;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface Protocol {
+    send(request: string): Promise<string>;
+}
+export type DevstralRole = 1 | 2 | 4 | 5;
+export interface DevstralMetadata {
+    [key: string]: unknown;
+}
+export interface DevstralMessage {
+    id?: string;
+    role: DevstralRole;
+    content: string;
+    metadata?: DevstralMetadata;
+}
+export interface DevstralToolDefinition {
+    id: string;
+    name?: string;
+    description?: string;
+}
+export type WindsurfModelId = 'MODEL_SWE_1_6_FAST' | 'MODEL_SWE_1_6' | string;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@bxb1337/windsurf-fast-context",
+  "version": "1.0.0",
+  "description": "AI SDK V3 provider for Windsurf's Devstral code search API",
+  "type": "module",
+  "scripts": {
+    "test": "vitest --run",
+    "build:types": "tsc -p tsconfig.types.json",
+    "build:esm": "tsc -p tsconfig.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build": "pnpm -s run build:types && pnpm -s run build:esm && pnpm -s run build:cjs && node ./scripts/postbuild.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "keywords": [
+    "windsurf",
+    "devstral",
+    "ai-sdk",
+    "code-search",
+    "llm",
+    "provider"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bxb1337/windsurf-fast-context"
+  },
+  "devDependencies": {
+    "ai": "^6.0.116",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  },
+  "peerDependencies": {
+    "ai": ">=4.0.0"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
+}