neuralex 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NeuraLex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,269 @@
+# NeuraLex JavaScript/TypeScript Client
+
+Official TypeScript/JavaScript client library for the [NeuraLex](https://neuralex.ca) API.
+
+## Installation
+
+```bash
+npm install neuralex
+```
+
+or
+
+```bash
+yarn add neuralex
+```
+
+## Quick Start
+
+```typescript
+import { NeuraLexClient } from 'neuralex';
+
+// Initialize client with your API key
+const client = new NeuraLexClient({ apiKey: 'nlx_your_api_key' });
+
+// Generate embeddings
+const response = await client.embed('Hello, world!');
+
+// Access the embedding vector
+const embedding = response.payload[0].embedding;
+console.log(`Dimensions: ${embedding.length}`);
+console.log(`First 5 values: ${embedding.slice(0, 5)}`);
+```
+
+## Features
+
+- ✅ TypeScript support with full type definitions
+- ✅ Promise-based async API
+- ✅ Automatic error handling
+- ✅ Configurable semantic/term-based balance
+- ✅ Batch embedding support (up to 100 inputs)
+- ✅ Tree-shakeable ESM and CommonJS builds
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { NeuraLexClient } from 'neuralex';
+
+const client = new NeuraLexClient({ apiKey: 'nlx_your_api_key' });
+
+// Single text
+const response = await client.embed('Machine learning is fascinating');
+const embedding = response.payload[0].embedding;
+```
+
+### Batch Embeddings
+
+```typescript
+// Multiple texts
+const texts = [
+  'First document',
+  'Second document',
+  'Third document'
+];
+
+const response = await client.embed(texts);
+
+response.payload.forEach((item) => {
+  console.log(`Text: ${item.text}`);
+  console.log(`Embedding dimensions: ${item.embedding.length}`);
+  console.log(`Tokens used: ${item.usage.totalTokens}`);
+});
+```
+
+### Adjusting Semantic Weight
+
+The `semanticWeight` parameter controls the balance between term-based and semantic embeddings:
+- `0.0` = Pure term-based (exact keyword matching)
+- `1.0` = Pure semantic (meaning-based)
+- `0.5` = Balanced (default)
+
+```typescript
+// More term-focused (better for keyword search)
+const response = await client.embed('Python programming', {
+  semanticWeight: 0.3
+});
+
+// More semantic-focused (better for meaning-based search)
+const response = await client.embed('Python programming', {
+  semanticWeight: 0.8
+});
+```
+
+### Error Handling
+
+```typescript
+import {
+  NeuraLexClient,
+  AuthenticationError,
+  RateLimitError,
+  APIError
+} from 'neuralex';
+
+const client = new NeuraLexClient({ apiKey: 'nlx_your_api_key' });
+
+try {
+  const response = await client.embed('Hello, world!');
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    console.error('Invalid API key');
+  } else if (error instanceof RateLimitError) {
+    console.error('Rate limit exceeded, please wait');
+  } else if (error instanceof APIError) {
+    console.error(`API error: ${error.message} (status: ${error.statusCode})`);
+  } else {
+    console.error(`Unexpected error: ${error}`);
+  }
+}
+```
+
+### Using with JavaScript (CommonJS)
+
+```javascript
+const { NeuraLexClient } = require('neuralex');
+
+const client = new NeuraLexClient({ apiKey: 'nlx_your_api_key' });
+
+async function main() {
+  const response = await client.embed('Hello, world!');
+  console.log(response.payload[0].embedding.slice(0, 5));
+}
+
+main();
+```
+
+## API Reference
+
+### `NeuraLexClient`
+
+Main client class for API interactions.
+
+**Constructor:**
+
+```typescript
+new NeuraLexClient(config: NeuraLexClientConfig)
+```
+
+**Config Options:**
+
+- `apiKey` (string, required): Your NeuraLex API key
+- `baseUrl` (string, optional): Base URL for the API (default: "https://api.neuralex.ca")
+- `timeout` (number, optional): Request timeout in milliseconds (default: 30000)
+
+**Methods:**
+
+#### `embed(inputs, options?)`
+
+Generate embeddings for text input(s).
+
+**Parameters:**
+
+- `inputs` (string | string[]): Text or array of texts to embed (max 100)
+- `options` (object, optional):
+  - `model` (string): Model name (default: "public")
+  - `language` (string): Language for lexeme extraction (default: "english")
+  - `semanticWeight` (number): Balance between term (0.0) and semantic (1.0) (default: 0.5)
+
+**Returns:** `Promise<EmbeddingResponse>`
+
+### Types
+
+#### `EmbeddingResponse`
+
+```typescript
+interface EmbeddingResponse {
+  payload: EmbeddingData[];
+  model: string;
+  totalUsage: Usage;
+}
+```
+
+#### `EmbeddingData`
+
+```typescript
+interface EmbeddingData {
+  text: string;
+  embedding: number[];
+  usage: Usage;
+}
+```
+
+#### `Usage`
+
+```typescript
+interface Usage {
+  totalTokens: number;
+}
+```
+
+### Error Classes
+
+- `NeuraLexError` - Base error class
+- `AuthenticationError` - Invalid or missing API key
+- `RateLimitError` - Rate limit exceeded
+- `APIError` - API error response (includes `statusCode` and `responseData`)
+
+## Getting an API Key
+
+1. Sign up at [app.neuralex.ca](https://app.neuralex.ca)
+2. Generate a new API key
+3. Keep your API key secure and never commit it to version control
+
+## Examples
+
+### Semantic Search
+
+```typescript
+import { NeuraLexClient } from 'neuralex';
+
+const client = new NeuraLexClient({ apiKey: process.env.NEURALEX_API_KEY });
+
+// Embed documents
+const documents = [
+  'The quick brown fox jumps over the lazy dog',
+  'Machine learning is a subset of artificial intelligence',
+  'Python is a popular programming language'
+];
+
+const docResponse = await client.embed(documents);
+const docEmbeddings = docResponse.payload.map(d => d.embedding);
+
+// Embed query
+const queryResponse = await client.embed('Tell me about AI');
+const queryEmbedding = queryResponse.payload[0].embedding;
+
+// Compute cosine similarity (you'll need to implement this)
+const similarities = docEmbeddings.map(docEmb => 
+  cosineSimilarity(queryEmbedding, docEmb)
+);
+
+console.log('Most similar document:', documents[similarities.indexOf(Math.max(...similarities))]);
+```
+
+### Integration with Vector Databases
+
+```typescript
+import { NeuraLexClient } from 'neuralex';
+// import your vector database client
+
+const nlxClient = new NeuraLexClient({ apiKey: 'nlx_your_api_key' });
+
+async function indexDocuments(documents: string[]) {
+  const response = await nlxClient.embed(documents);
+  
+  // Store in your vector database
+  for (let i = 0; i < response.payload.length; i++) {
+    await vectorDB.insert({
+      id: i,
+      text: response.payload[i].text,
+      embedding: response.payload[i].embedding
+    });
+  }
+}
+```
+
+## License
+
+MIT License - see LICENSE file for details

package/dist/index.d.mts

@@ -0,0 +1,52 @@
+interface EmbeddingRequest {
+    inputs: string[];
+    model?: string;
+    language?: string;
+    semanticWeight?: number;
+}
+interface Usage {
+    totalTokens: number;
+}
+interface EmbeddingData {
+    text: string;
+    embedding: number[];
+    usage: Usage;
+}
+interface EmbeddingResponse {
+    payload: EmbeddingData[];
+    model: string;
+    totalUsage: Usage;
+}
+interface NeuraLexClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+
+declare class NeuraLexClient {
+    private client;
+    private apiKey;
+    constructor(config: NeuraLexClientConfig);
+    embed(inputs: string | string[], options?: {
+        model?: string;
+        language?: string;
+        semanticWeight?: number;
+    }): Promise<EmbeddingResponse>;
+}
+
+declare class NeuraLexError extends Error {
+    constructor(message: string);
+}
+declare class AuthenticationError extends NeuraLexError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends NeuraLexError {
+    constructor(message?: string);
+}
+declare class APIError extends NeuraLexError {
+    statusCode: number;
+    responseData: any;
+    constructor(message: string, statusCode: number, responseData?: any);
+}
+
+export { APIError, AuthenticationError, type EmbeddingData, type EmbeddingRequest, type EmbeddingResponse, NeuraLexClient, type NeuraLexClientConfig, NeuraLexError, RateLimitError, type Usage };

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+interface EmbeddingRequest {
+    inputs: string[];
+    model?: string;
+    language?: string;
+    semanticWeight?: number;
+}
+interface Usage {
+    totalTokens: number;
+}
+interface EmbeddingData {
+    text: string;
+    embedding: number[];
+    usage: Usage;
+}
+interface EmbeddingResponse {
+    payload: EmbeddingData[];
+    model: string;
+    totalUsage: Usage;
+}
+interface NeuraLexClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+
+declare class NeuraLexClient {
+    private client;
+    private apiKey;
+    constructor(config: NeuraLexClientConfig);
+    embed(inputs: string | string[], options?: {
+        model?: string;
+        language?: string;
+        semanticWeight?: number;
+    }): Promise<EmbeddingResponse>;
+}
+
+declare class NeuraLexError extends Error {
+    constructor(message: string);
+}
+declare class AuthenticationError extends NeuraLexError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends NeuraLexError {
+    constructor(message?: string);
+}
+declare class APIError extends NeuraLexError {
+    statusCode: number;
+    responseData: any;
+    constructor(message: string, statusCode: number, responseData?: any);
+}
+
+export { APIError, AuthenticationError, type EmbeddingData, type EmbeddingRequest, type EmbeddingResponse, NeuraLexClient, type NeuraLexClientConfig, NeuraLexError, RateLimitError, type Usage };

package/dist/index.js

@@ -0,0 +1,188 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => APIError,
+  AuthenticationError: () => AuthenticationError,
+  NeuraLexClient: () => NeuraLexClient,
+  NeuraLexError: () => NeuraLexError,
+  RateLimitError: () => RateLimitError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_axios = __toESM(require("axios"));
+
+// src/errors.ts
+var NeuraLexError = class _NeuraLexError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NeuraLexError";
+    Object.setPrototypeOf(this, _NeuraLexError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends NeuraLexError {
+  constructor(message = "Authentication failed") {
+    super(message);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends NeuraLexError {
+  constructor(message = "Rate limit exceeded") {
+    super(message);
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var APIError = class _APIError extends NeuraLexError {
+  constructor(message, statusCode, responseData = {}) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+    this.responseData = responseData;
+    Object.setPrototypeOf(this, _APIError.prototype);
+  }
+};
+
+// src/client.ts
+var NeuraLexClient = class {
+  /**
+   * Create a new NeuraLex client
+   *
+   * @param config - Client configuration
+   * @param config.apiKey - Your NeuraLex API key (starts with 'nlx_')
+   * @param config.baseUrl - Base URL for the API (default: https://api.neuralex.ca)
+   * @param config.timeout - Request timeout in milliseconds (default: 30000)
+   */
+  constructor(config) {
+    const { apiKey, baseUrl = "https://api.neuralex.ca", timeout = 3e4 } = config;
+    if (!apiKey) {
+      throw new AuthenticationError("API key is required");
+    }
+    if (!apiKey.startsWith("nlx_")) {
+      throw new AuthenticationError("Invalid API key format (should start with 'nlx_')");
+    }
+    this.apiKey = apiKey;
+    this.client = import_axios.default.create({
+      baseURL: baseUrl,
+      timeout,
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  /**
+   * Generate embeddings for the provided input text(s)
+   *
+   * @param inputs - Text string or array of text strings to embed (max 100)
+   * @param options - Optional parameters
+   * @param options.model - Model name (default: "public")
+   * @param options.language - Language for lexeme extraction (default: "english")
+   * @param options.semanticWeight - Balance between term-based (0.0) and semantic (1.0) (default: 0.5)
+   * @returns Promise<EmbeddingResponse> - Embeddings and usage information
+   *
+   * @throws {AuthenticationError} Invalid or missing API key
+   * @throws {RateLimitError} Rate limit exceeded
+   * @throws {APIError} API returned an error response
+   * @throws {NeuraLexError} Other errors
+   *
+   * @example
+   * ```typescript
+   * // Single text
+   * const response = await client.embed('Hello, world!');
+   *
+   * // Multiple texts
+   * const response = await client.embed(['Text 1', 'Text 2', 'Text 3']);
+   *
+   * // With options
+   * const response = await client.embed('Python programming', {
+   *   semanticWeight: 0.8,
+   *   model: 'public'
+   * });
+   * ```
+   */
+  async embed(inputs, options = {}) {
+    const inputArray = Array.isArray(inputs) ? inputs : [inputs];
+    if (inputArray.length === 0) {
+      throw new Error("At least one input is required");
+    }
+    if (inputArray.length > 100) {
+      throw new Error("Maximum 100 inputs allowed per request");
+    }
+    const request = {
+      inputs: inputArray,
+      model: options.model ?? "public",
+      language: options.language ?? "english",
+      semanticWeight: options.semanticWeight ?? 0.5
+    };
+    try {
+      const response = await this.client.post(
+        "/api/v1/embed",
+        request
+      );
+      return response.data;
+    } catch (error) {
+      if (import_axios.default.isAxiosError(error)) {
+        const axiosError = error;
+        if (axiosError.response?.status === 401) {
+          throw new AuthenticationError("Invalid API key");
+        } else if (axiosError.response?.status === 429) {
+          throw new RateLimitError("Rate limit exceeded");
+        } else if (axiosError.response?.status && axiosError.response.status >= 400) {
+          const errorData = axiosError.response.data;
+          throw new APIError(
+            errorData?.message || "API request failed",
+            axiosError.response.status,
+            errorData
+          );
+        } else if (error.code === "ECONNABORTED") {
+          throw new NeuraLexError("Request timeout");
+        }
+      }
+      if (error instanceof NeuraLexError) {
+        throw error;
+      }
+      throw new NeuraLexError(
+        error instanceof Error ? error.message : "Unknown error occurred"
+      );
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AuthenticationError,
+  NeuraLexClient,
+  NeuraLexError,
+  RateLimitError
+});

package/dist/index.mjs

@@ -0,0 +1,147 @@
+// src/client.ts
+import axios from "axios";
+
+// src/errors.ts
+var NeuraLexError = class _NeuraLexError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NeuraLexError";
+    Object.setPrototypeOf(this, _NeuraLexError.prototype);
+  }
+};
+var AuthenticationError = class _AuthenticationError extends NeuraLexError {
+  constructor(message = "Authentication failed") {
+    super(message);
+    this.name = "AuthenticationError";
+    Object.setPrototypeOf(this, _AuthenticationError.prototype);
+  }
+};
+var RateLimitError = class _RateLimitError extends NeuraLexError {
+  constructor(message = "Rate limit exceeded") {
+    super(message);
+    this.name = "RateLimitError";
+    Object.setPrototypeOf(this, _RateLimitError.prototype);
+  }
+};
+var APIError = class _APIError extends NeuraLexError {
+  constructor(message, statusCode, responseData = {}) {
+    super(message);
+    this.name = "APIError";
+    this.statusCode = statusCode;
+    this.responseData = responseData;
+    Object.setPrototypeOf(this, _APIError.prototype);
+  }
+};
+
+// src/client.ts
+var NeuraLexClient = class {
+  /**
+   * Create a new NeuraLex client
+   *
+   * @param config - Client configuration
+   * @param config.apiKey - Your NeuraLex API key (starts with 'nlx_')
+   * @param config.baseUrl - Base URL for the API (default: https://api.neuralex.ca)
+   * @param config.timeout - Request timeout in milliseconds (default: 30000)
+   */
+  constructor(config) {
+    const { apiKey, baseUrl = "https://api.neuralex.ca", timeout = 3e4 } = config;
+    if (!apiKey) {
+      throw new AuthenticationError("API key is required");
+    }
+    if (!apiKey.startsWith("nlx_")) {
+      throw new AuthenticationError("Invalid API key format (should start with 'nlx_')");
+    }
+    this.apiKey = apiKey;
+    this.client = axios.create({
+      baseURL: baseUrl,
+      timeout,
+      headers: {
+        "X-API-Key": apiKey,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  /**
+   * Generate embeddings for the provided input text(s)
+   *
+   * @param inputs - Text string or array of text strings to embed (max 100)
+   * @param options - Optional parameters
+   * @param options.model - Model name (default: "public")
+   * @param options.language - Language for lexeme extraction (default: "english")
+   * @param options.semanticWeight - Balance between term-based (0.0) and semantic (1.0) (default: 0.5)
+   * @returns Promise<EmbeddingResponse> - Embeddings and usage information
+   *
+   * @throws {AuthenticationError} Invalid or missing API key
+   * @throws {RateLimitError} Rate limit exceeded
+   * @throws {APIError} API returned an error response
+   * @throws {NeuraLexError} Other errors
+   *
+   * @example
+   * ```typescript
+   * // Single text
+   * const response = await client.embed('Hello, world!');
+   *
+   * // Multiple texts
+   * const response = await client.embed(['Text 1', 'Text 2', 'Text 3']);
+   *
+   * // With options
+   * const response = await client.embed('Python programming', {
+   *   semanticWeight: 0.8,
+   *   model: 'public'
+   * });
+   * ```
+   */
+  async embed(inputs, options = {}) {
+    const inputArray = Array.isArray(inputs) ? inputs : [inputs];
+    if (inputArray.length === 0) {
+      throw new Error("At least one input is required");
+    }
+    if (inputArray.length > 100) {
+      throw new Error("Maximum 100 inputs allowed per request");
+    }
+    const request = {
+      inputs: inputArray,
+      model: options.model ?? "public",
+      language: options.language ?? "english",
+      semanticWeight: options.semanticWeight ?? 0.5
+    };
+    try {
+      const response = await this.client.post(
+        "/api/v1/embed",
+        request
+      );
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error;
+        if (axiosError.response?.status === 401) {
+          throw new AuthenticationError("Invalid API key");
+        } else if (axiosError.response?.status === 429) {
+          throw new RateLimitError("Rate limit exceeded");
+        } else if (axiosError.response?.status && axiosError.response.status >= 400) {
+          const errorData = axiosError.response.data;
+          throw new APIError(
+            errorData?.message || "API request failed",
+            axiosError.response.status,
+            errorData
+          );
+        } else if (error.code === "ECONNABORTED") {
+          throw new NeuraLexError("Request timeout");
+        }
+      }
+      if (error instanceof NeuraLexError) {
+        throw error;
+      }
+      throw new NeuraLexError(
+        error instanceof Error ? error.message : "Unknown error occurred"
+      );
+    }
+  }
+};
+export {
+  APIError,
+  AuthenticationError,
+  NeuraLexClient,
+  NeuraLexError,
+  RateLimitError
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "neuralex",
+  "version": "0.1.0",
+  "description": "Official TS/JS client library for NeuraLex API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "embeddings",
+    "vector",
+    "search",
+    "ai",
+    "ml",
+    "neuralex",
+    "typescript",
+    "semantic-search",
+    "hybrid-search",
+    "similarity-search",
+    "rag",
+    "retrieval",
+    "pgvector",
+    "pinecone",
+    "qdrant",
+    "weaviate",
+    "milvus",
+    "chroma",
+    "dense-retrieval",
+    "transformers",
+    "nlp"
+  ],
+  "author": "NeuraLex <support@neuralex.ca>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:pavel604/neuralex-lib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pavel604/neuralex-lib/issues"
+  },
+  "homepage": "https://neuralex.ca",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "axios": "^1.6.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.1.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}