embedded-raptor 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Christoffer Artmann <artgaard@gmail.com>
+
+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,232 @@
+# Raptor
+
+[![CI](https://img.shields.io/github/actions/workflow/status/artmann/raptor/ci.yml?branch=main&label=CI&logo=github)](https://github.com/artmann/raptor/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/raptor.svg?logo=npm)](https://www.npmjs.com/package/raptor)
+[![npm downloads](https://img.shields.io/npm/dm/raptor.svg)](https://www.npmjs.com/package/raptor)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg?logo=typescript)](https://www.typescriptlang.org/)
+
+> A lightweight semantic search database with text embeddings for Node.js and
+> Bun
+
+Raptor lets you build semantic search into your applications with just a few
+lines of code. Store text, search by meaning, and find similar content—perfect
+for RAG systems, chatbots, and recommendation engines.
+
+## What is Raptor?
+
+Raptor is an embedding database that automatically converts text into vector
+embeddings and stores them in an efficient binary format. Instead of searching
+by exact keywords, you can search by semantic similarity—finding documents that
+mean the same thing, even if they use different words.
+
+**Example:** Search for "how to reset password" and find results like "forgot my
+login credentials" or "change account password".
+
+## Why Raptor?
+
+- **Simple API** - No complex setup, just store and search
+- **Semantic Search** - Find content by meaning, not just keywords
+- **Fast & Efficient** - Binary storage format ~50% smaller than JSON
+- **Zero Dependencies** - Embeddings generated locally, no API keys needed
+- **Works Everywhere** - Compatible with Node.js and Bun
+- **Built for RAG** - Perfect for Retrieval Augmented Generation systems
+
+## Use Cases
+
+- **FAQ Bots** - Match user questions to answers by meaning
+- **Document Search** - Semantic search over documentation or knowledge bases
+- **Code Search** - Find code snippets by describing what they do
+- **Content Recommendations** - "More like this" functionality
+- **RAG Systems** - Retrieve relevant context for LLM prompts
+
+## Installation
+
+```bash
+# Using npm
+npm install raptor
+
+# Using bun
+bun add raptor
+```
+
+## Quick Start
+
+### Programmatic API
+
+```typescript
+import { EmbeddingEngine } from 'raptor'
+
+const engine = new EmbeddingEngine({
+  storePath: './my-database.raptor'
+})
+
+// Store documents
+await engine.storeMany([
+  { key: 'doc1', text: 'How to reset your password' },
+  { key: 'doc2', text: 'Machine learning basics' },
+  { key: 'doc3', text: 'Getting started with Bun' }
+])
+
+// Search by meaning
+const results = await engine.search('forgot my password', 5)
+console.log(results[0].key) // 'doc1' - matched by meaning!
+console.log(results[0].similarity) // 0.87 - high similarity score
+```
+
+### Command Line Interface
+
+```bash
+# Store documents
+raptor store doc1 "How to reset your password"
+raptor store doc2 "Machine learning basics"
+
+# Search by meaning
+raptor search "forgot my password" --limit 5
+
+# Retrieve by key
+raptor get doc1
+```
+
+## Examples
+
+See the [examples/](examples/) directory for complete, runnable examples:
+
+| Example                    | Description                                             | Run                                             |
+| -------------------------- | ------------------------------------------------------- | ----------------------------------------------- |
+| **Document Search / RAG**  | Semantic search over documentation chunks               | `bun run examples/01-document-search.ts`        |
+| **FAQ Bot**                | Match user questions to FAQs with confidence thresholds | `bun run examples/02-faq-bot.ts`                |
+| **Code Snippet Library**   | Search code by natural language descriptions            | `bun run examples/03-code-snippets.ts`          |
+| **Content Recommendation** | "More like this" functionality                          | `bun run examples/04-content-recommendation.ts` |
+
+## API Reference
+
+### `EmbeddingEngine`
+
+#### `constructor(options)`
+
+Create a new embedding engine.
+
+```typescript
+const engine = new EmbeddingEngine({
+  storePath: './database.raptor' // Path to storage file
+})
+```
+
+#### `store(key, text)`
+
+Store a single text entry with auto-generated embedding.
+
+```typescript
+await engine.store('doc1', 'The quick brown fox')
+```
+
+#### `storeMany(items)`
+
+Store multiple entries in batch (faster than multiple `store()` calls).
+
+```typescript
+await engine.storeMany([
+  { key: 'doc1', text: 'First document' },
+  { key: 'doc2', text: 'Second document' }
+])
+```
+
+#### `search(query, limit?, minSimilarity?)`
+
+Search for semantically similar entries.
+
+```typescript
+const results = await engine.search(
+  'artificial intelligence', // query text
+  10, // max results (default: 10)
+  0.7 // min similarity 0-1 (default: 0)
+)
+
+// Results are sorted by similarity (highest first)
+results.forEach((result) => {
+  console.log(result.key) // Document key
+  console.log(result.similarity) // Similarity score 0-1
+})
+```
+
+#### `get(key)`
+
+Retrieve a specific entry by key.
+
+```typescript
+const entry = await engine.get('doc1')
+if (entry) {
+  console.log(entry.key) // 'doc1'
+  console.log(entry.embedding) // [0.1, 0.2, ...] (768 dimensions)
+}
+```
+
+## CLI Reference
+
+### Commands
+
+```bash
+# Store text
+raptor store <key> <text> [--storePath path]
+
+# Search for similar text
+raptor search <query> [--limit 10] [--minSimilarity 0] [--storePath path]
+
+# Get by key
+raptor get <key> [--storePath path]
+```
+
+### Options
+
+- `-s, --storePath` - Path to database file (default: `./database.raptor`)
+- `-l, --limit` - Maximum results to return (default: 10)
+- `-m, --minSimilarity` - Minimum similarity threshold 0-1 (default: 0)
+
+### Examples
+
+```bash
+# Store documents
+raptor store doc1 "The quick brown fox jumps over the lazy dog"
+raptor store doc2 "Machine learning is a subset of artificial intelligence"
+raptor store doc3 "Bun is a fast JavaScript runtime"
+
+# Search with default settings
+raptor search "artificial intelligence"
+
+# Search with custom limit and threshold
+raptor search "AI and ML" --limit 3 --minSimilarity 0.7
+
+# Use custom database path
+raptor store key1 "Some text" --storePath ./data/custom.raptor
+```
+
+## How It Works
+
+1. **Text → Embeddings**: Raptor uses the BGE-Base-EN model to convert text into
+   768-dimensional vector embeddings
+2. **Storage**: Embeddings are stored in an efficient binary format (.raptor
+   files)
+3. **Search**: When you search, Raptor compares your query embedding against all
+   stored embeddings using cosine similarity
+4. **Results**: Returns the most similar results ranked by similarity score
+
+**Embedding Model**:
+[BAAI/bge-base-en](https://huggingface.co/BAAI/bge-base-en-v1.5) (768
+dimensions)
+
+## Performance
+
+- **Batch operations**: Use `storeMany()` for faster bulk inserts
+- **Memory efficient**: Reads file in 64KB chunks, handles large databases
+- **Fast search**: Cosine similarity comparison across all embeddings
+- **Deduplication**: Latest entry automatically used for duplicate keys
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for
+development setup, architecture details, and guidelines.
+
+## License
+
+MIT © [Christoffer Artmann](mailto:artgaard@gmail.com)

package/dist/binary-file-reader.d.ts

@@ -0,0 +1,9 @@
+import type { EmbeddingEntry } from './types';
+export declare class BinaryFileReader {
+    private storePath;
+    constructor(storePath: string);
+    entries(): AsyncGenerator<EmbeddingEntry>;
+    private parseRecord;
+    private parseRecordFromView;
+}
+//# sourceMappingURL=binary-file-reader.d.ts.map

package/dist/binary-file-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-file-reader.d.ts","sourceRoot":"","sources":["../src/binary-file-reader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,qBAAa,gBAAgB;IACf,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,MAAM;IAE9B,OAAO,IAAI,cAAc,CAAC,cAAc,CAAC;IAuFhD,OAAO,CAAC,WAAW;IAQnB,OAAO,CAAC,mBAAmB;CAuC5B"}

package/dist/binary-format.d.ts

@@ -0,0 +1,22 @@
+export declare const magicBytes = "EMBD";
+export declare const currentVersion = 1;
+export declare const headerSize = 16;
+export interface Header {
+    version: number;
+    dimension: number;
+}
+export interface BinaryRecord {
+    key: string;
+    embedding: Float32Array;
+    recordLength: number;
+}
+export declare function calculateRecordLength(keyLength: number, dimension: number): number;
+export declare function writeHeader(filePath: string, dimension: number): Promise<void>;
+export declare function readHeader(filePath: string): Promise<Header>;
+export declare function writeRecord(filePath: string, key: string, embedding: Float32Array): Promise<void>;
+export declare function writeRecords(filePath: string, records: Array<{
+    key: string;
+    embedding: Float32Array;
+}>): Promise<void>;
+export declare function readRecordForward(filePath: string, dimension: number, offset: number): Promise<BinaryRecord | null>;
+//# sourceMappingURL=binary-format.d.ts.map

package/dist/binary-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-format.d.ts","sourceRoot":"","sources":["../src/binary-format.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,SAAS,CAAA;AAChC,eAAO,MAAM,cAAc,IAAI,CAAA;AAC/B,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,YAAY,CAAA;IACvB,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0ClE;AAED,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,YAAY,CAAA;CAAE,CAAC,GACvD,OAAO,CAAC,IAAI,CAAC,CAqDf;AAED,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CA4E9B"}

package/dist/candidate-set.d.ts

@@ -0,0 +1,16 @@
+export declare class CandidateSet {
+    readonly size: number;
+    protected readonly entries: CandidateSetEntry[];
+    constructor(size?: number);
+    add(key: string, value: number): void;
+    count(): number;
+    getEntries(): CandidateSetEntry[];
+    getKeys(): string[];
+}
+declare class CandidateSetEntry {
+    readonly key: string;
+    readonly value: number;
+    constructor(key: string, value: number);
+}
+export {};
+//# sourceMappingURL=candidate-set.d.ts.map

package/dist/candidate-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-set.d.ts","sourceRoot":"","sources":["../src/candidate-set.ts"],"names":[],"mappings":"AAEA,qBAAa,YAAY;IACvB,SAAgB,IAAI,EAAE,MAAM,CAAA;IAC5B,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,EAAE,CAAK;gBAExC,IAAI,SAAI;IAMpB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAyBrC,KAAK,IAAI,MAAM;IAIf,UAAU,IAAI,iBAAiB,EAAE;IAIjC,OAAO,IAAI,MAAM,EAAE;CAGpB;AAED,cAAM,iBAAiB;IACrB,SAAgB,GAAG,EAAE,MAAM,CAAA;IAC3B,SAAgB,KAAK,EAAE,MAAM,CAAA;gBAEjB,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;CAIvC"}

package/dist/cli.cjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+const require_engine = require('./engine-KhnrAv7v.cjs');
+let node_fs = require("node:fs");
+node_fs = require_engine.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_engine.__toESM(node_path);
+let cleye = require("cleye");
+cleye = require_engine.__toESM(cleye);
+let node_url = require("node:url");
+node_url = require_engine.__toESM(node_url);
+
+//#region src/commands/flags.ts
+const sharedFlags = { storePath: {
+	type: String,
+	description: "Path to the embeddings store file",
+	default: "./database.raptor",
+	alias: "s"
+} };
+const searchFlags = {
+	limit: {
+		type: Number,
+		description: "Maximum number of results to return",
+		default: 10,
+		alias: "l"
+	},
+	minSimilarity: {
+		type: Number,
+		description: "Minimum similarity threshold (0-1)",
+		default: 0,
+		alias: "m"
+	}
+};
+
+//#endregion
+//#region src/commands/store.ts
+const store = (0, cleye.command)({
+	name: "store",
+	description: "Store a text embedding with a key",
+	parameters: ["<key>", "<text>"],
+	flags: { ...sharedFlags }
+}, async (argv) => {
+	const engine = new require_engine.EmbeddingEngine({ storePath: argv.flags.storePath });
+	const [key, text] = argv._;
+	await engine.store(key, text);
+	console.log(`✓ Stored embedding for key: ${key}`);
+});
+
+//#endregion
+//#region src/commands/get.ts
+const get = (0, cleye.command)({
+	name: "get",
+	description: "Retrieve an embedding entry by key",
+	parameters: ["<key>"],
+	flags: { ...sharedFlags }
+}, async (argv) => {
+	const engine = new require_engine.EmbeddingEngine({ storePath: argv.flags.storePath });
+	const [key] = argv._;
+	const entry = await engine.get(key);
+	if (entry) console.log(JSON.stringify({
+		key: entry.key,
+		text: entry.text,
+		embeddingDimensions: entry.embedding.length,
+		timestamp: new Date(entry.timestamp).toISOString()
+	}, null, 2));
+	else {
+		console.log(`Key "${key}" not found`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/search.ts
+const search = (0, cleye.command)({
+	name: "search",
+	description: "Search for similar embeddings using a query",
+	parameters: ["<query>"],
+	flags: {
+		...sharedFlags,
+		...searchFlags
+	}
+}, async (argv) => {
+	const engine = new require_engine.EmbeddingEngine({ storePath: argv.flags.storePath });
+	const [query] = argv._;
+	const results = await engine.search(query, argv.flags.limit, argv.flags.minSimilarity);
+	if (results.length === 0) console.log("No results found");
+	else {
+		console.log(`Found ${results.length} result(s):\n`);
+		for (const result of results) console.log(`${result.key}: ${result.similarity.toFixed(6)}`);
+	}
+});
+
+//#endregion
+//#region src/cli.ts
+const __dirname$1 = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+function main() {
+	(0, cleye.cli)({
+		name: "raptor",
+		version: JSON.parse((0, node_fs.readFileSync)((0, node_path.resolve)(__dirname$1, "../package.json"), "utf-8")).version,
+		description: "An embedding database CLI for storing and searching text indexes",
+		commands: [
+			store,
+			get,
+			search
+		]
+	}, () => {});
+}
+main();
+
+//#endregion

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { t as EmbeddingEngine } from "./engine-DISO9uFr.mjs";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { cli, command } from "cleye";
+import { fileURLToPath } from "node:url";
+
+//#region src/commands/flags.ts
+const sharedFlags = { storePath: {
+	type: String,
+	description: "Path to the embeddings store file",
+	default: "./database.raptor",
+	alias: "s"
+} };
+const searchFlags = {
+	limit: {
+		type: Number,
+		description: "Maximum number of results to return",
+		default: 10,
+		alias: "l"
+	},
+	minSimilarity: {
+		type: Number,
+		description: "Minimum similarity threshold (0-1)",
+		default: 0,
+		alias: "m"
+	}
+};
+
+//#endregion
+//#region src/commands/store.ts
+const store = command({
+	name: "store",
+	description: "Store a text embedding with a key",
+	parameters: ["<key>", "<text>"],
+	flags: { ...sharedFlags }
+}, async (argv) => {
+	const engine = new EmbeddingEngine({ storePath: argv.flags.storePath });
+	const [key, text] = argv._;
+	await engine.store(key, text);
+	console.log(`✓ Stored embedding for key: ${key}`);
+});
+
+//#endregion
+//#region src/commands/get.ts
+const get = command({
+	name: "get",
+	description: "Retrieve an embedding entry by key",
+	parameters: ["<key>"],
+	flags: { ...sharedFlags }
+}, async (argv) => {
+	const engine = new EmbeddingEngine({ storePath: argv.flags.storePath });
+	const [key] = argv._;
+	const entry = await engine.get(key);
+	if (entry) console.log(JSON.stringify({
+		key: entry.key,
+		text: entry.text,
+		embeddingDimensions: entry.embedding.length,
+		timestamp: new Date(entry.timestamp).toISOString()
+	}, null, 2));
+	else {
+		console.log(`Key "${key}" not found`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/search.ts
+const search = command({
+	name: "search",
+	description: "Search for similar embeddings using a query",
+	parameters: ["<query>"],
+	flags: {
+		...sharedFlags,
+		...searchFlags
+	}
+}, async (argv) => {
+	const engine = new EmbeddingEngine({ storePath: argv.flags.storePath });
+	const [query] = argv._;
+	const results = await engine.search(query, argv.flags.limit, argv.flags.minSimilarity);
+	if (results.length === 0) console.log("No results found");
+	else {
+		console.log(`Found ${results.length} result(s):\n`);
+		for (const result of results) console.log(`${result.key}: ${result.similarity.toFixed(6)}`);
+	}
+});
+
+//#endregion
+//#region src/cli.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function main() {
+	cli({
+		name: "raptor",
+		version: JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8")).version,
+		description: "An embedding database CLI for storing and searching text indexes",
+		commands: [
+			store,
+			get,
+			search
+		]
+	}, () => {});
+}
+main();
+
+//#endregion

package/dist/commands/flags.d.ts

@@ -0,0 +1,23 @@
+export declare const sharedFlags: {
+    readonly storePath: {
+        readonly type: StringConstructor;
+        readonly description: "Path to the embeddings store file";
+        readonly default: "./database.raptor";
+        readonly alias: "s";
+    };
+};
+export declare const searchFlags: {
+    readonly limit: {
+        readonly type: NumberConstructor;
+        readonly description: "Maximum number of results to return";
+        readonly default: 10;
+        readonly alias: "l";
+    };
+    readonly minSimilarity: {
+        readonly type: NumberConstructor;
+        readonly description: "Minimum similarity threshold (0-1)";
+        readonly default: 0;
+        readonly alias: "m";
+    };
+};
+//# sourceMappingURL=flags.d.ts.map

package/dist/commands/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../src/commands/flags.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;;;;;CAOd,CAAA;AAEV,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAad,CAAA"}

package/dist/commands/get.d.ts

@@ -0,0 +1,41 @@
+export declare const get: import("cleye").Command<{
+    name: "get";
+    description: string;
+    parameters: "<key>"[];
+    flags: {
+        storePath: {
+            readonly type: StringConstructor;
+            readonly description: "Path to the embeddings store file";
+            readonly default: "./database.raptor";
+            readonly alias: "s";
+        };
+    };
+}, {
+    command: "get";
+} & import("type-flag").TypeFlag<{
+    storePath: {
+        readonly type: StringConstructor;
+        readonly description: "Path to the embeddings store file";
+        readonly default: "./database.raptor";
+        readonly alias: "s";
+    };
+} & {
+    help: BooleanConstructor;
+}> & {
+    _: {
+        key: string;
+    };
+    showHelp: (options?: {
+        version?: string;
+        description?: string;
+        usage?: false | string | string[];
+        examples?: string | string[];
+        render?: (nodes: {
+            id?: string;
+            type: keyof import("cleye").Renderers;
+            data: any;
+        }[], renderers: import("cleye").Renderers) => string;
+    }) => void;
+    showVersion: () => void;
+}>;
+//# sourceMappingURL=get.d.ts.map

package/dist/commands/get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get.d.ts","sourceRoot":"","sources":["../../src/commands/get.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoCk7L,CAAC;;;;;;;;;;;;EADl8L,CAAA"}

package/dist/commands/index.d.ts

@@ -0,0 +1,4 @@
+export { store } from './store';
+export { get } from './get';
+export { search } from './search';
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAA;AAC3B,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA"}