@bedrockio/ai 0.1.0

package/.prettierignore

@@ -0,0 +1 @@
+test/templates

package/.prettierrc.cjs

@@ -0,0 +1 @@
+module.exports = require('@bedrockio/prettier-config');

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- Initial commit

package/README.md

@@ -0,0 +1,84 @@
+# @bedrockio/ai
+
+This package provides a thin wrapper for common AI chatbots. It standardizes
+usage to allow different platforms to be swapped easily and allows templated
+usage.
+
+- [Install](#install)
+- [Usage](#usage)
+
+## Install
+
+```bash
+yarn install @bedrockio/ai
+```
+
+## Usage
+
+```js
+import { Client } from '@bedrockio/ai';
+
+const client = new Client({
+  // Directory to templates
+  templates: './test/templates',
+  // Platform: openai|gpt|anthopic|claude
+  platform: 'openai',
+  // Your API key
+  apiKey: 'my-api-key',
+});
+
+// Get a one time response.
+const response = await client.prompt({
+  // The template file to use.
+  file: 'classify-fruits',
+  // The form of output. May be raw|text|messages|json.
+  // Default is "text".
+  output: 'json',
+  // A custom template may be passed if "file" is not.
+  template: 'custom',
+
+  // All other variables will be
+  // interpolated into the template.
+  text: 'a long yellow fruit',
+  fruit: 'banana, apple, pear',
+});
+
+// Stream the results
+const stream = await client.stream({
+  file: 'classify-fruits',
+  // ...
+});
+
+// Will return an AsyncIterator
+for await (const chunk of stream) {
+  console.info(chunk.text);
+}
+
+// List available models
+const models = await client.models();
+```
+
+## Templates
+
+Template files must have be markdown (`.md`) and live in your templates
+directory. They may be a simple text description or delineated roles:
+
+````
+--- SYSTEM ---
+
+This is a list of fruits: {{fruits}}
+
+--- USER ---
+
+Which fruit do you think the following input most closely resembles?
+
+Please provide your response as a JSON object containing:
+
+- "name" {string} - The name of the fruit.
+- "reason" {string} - The reason you believe it matches.
+- "certainty" {number} - Your confidence in your answer from 0 to 1.
+
+```
+{{text}}
+```
+````

package/__mocks__/@anthropic-ai/sdk.js

@@ -0,0 +1,43 @@
+let mock;
+
+function Anthropic() {
+  return {
+    messages: {
+      create(options) {
+        if (options.stream) {
+          return streamMock();
+        } else {
+          return mock;
+        }
+      },
+    },
+  };
+}
+
+function setResponse(data) {
+  mock = data;
+}
+
+async function* streamMock() {
+  const content = mock.content[0].text;
+  const size = Math.floor(content.length / 3);
+  const one = content.slice(0, size);
+  const two = content.slice(size, 2 * size);
+  const three = content.slice(2 * size);
+  yield wrapChunk(one, 'content_block_start');
+  yield wrapChunk(two, 'content_block_delta');
+  yield wrapChunk(three, 'message_stop');
+}
+
+function wrapChunk(str, type) {
+  return {
+    type,
+    delta: {
+      text: str,
+    },
+  };
+}
+
+Anthropic.setResponse = setResponse;
+
+module.exports = Anthropic;

package/__mocks__/openai.js

@@ -0,0 +1,48 @@
+let mock;
+
+function OpenAI() {
+  return {
+    chat: {
+      completions: {
+        create(options) {
+          if (options.stream) {
+            return streamMock();
+          } else {
+            return mock;
+          }
+        },
+      },
+    },
+  };
+}
+
+async function* streamMock() {
+  const content = mock.choices[0].message.content;
+  const size = Math.floor(content.length / 3);
+  const one = content.slice(0, size);
+  const two = content.slice(size, 2 * size);
+  const three = content.slice(2 * size);
+  yield wrapChunk(one);
+  yield wrapChunk(two);
+  yield wrapChunk(three);
+}
+
+function wrapChunk(str) {
+  return {
+    choices: [
+      {
+        delta: {
+          content: str,
+        },
+      },
+    ],
+  };
+}
+
+function setResponse(data) {
+  mock = data;
+}
+
+OpenAI.setResponse = setResponse;
+
+module.exports = OpenAI;

package/dist/cjs/Wrapper.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _mustache = _interopRequireDefault(require("mustache"));
+var _util = require("./util.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const MESSAGES_REG = /(?:^|\n)-{3,}\s*(\w+)\s*-{3,}(.*?)(?=\n-{3,}|$)/gs;
+class Wrapper {
+  constructor(options) {
+    this.options = options;
+  }
+  async getMessages(options) {
+    const template = await this.resolveTemplate(options);
+    const raw = _mustache.default.render(template, transformParams(options));
+    const messages = [];
+    for (let match of raw.matchAll(MESSAGES_REG)) {
+      const [, role, content] = match;
+      messages.push({
+        role: role.toLowerCase(),
+        content: content.trim()
+      });
+    }
+    return messages;
+  }
+  async loadTemplates() {
+    const {
+      templates
+    } = this.options;
+    this.templates ||= await (0, _util.loadTemplates)(templates);
+  }
+  async resolveTemplate(options) {
+    await this.loadTemplates();
+    let {
+      file,
+      template
+    } = options;
+    if (!template && file) {
+      template = this.templates[file];
+    }
+    if (!template) {
+      throw new Error('No template provided.');
+    }
+    return template;
+  }
+}
+exports.default = Wrapper;
+function transformParams(params) {
+  const result = {};
+  for (let [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      value = value.map(el => {
+        return `- ${el}`;
+      }).join('\n');
+    } else if (typeof value === 'object') {
+      value = JSON.stringify(value, null, 2);
+    }
+    result[key] = value;
+  }
+  return result;
+}

package/dist/cjs/anthropic.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _sdk = _interopRequireDefault(require("@anthropic-ai/sdk"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const client = new _sdk.default({
+  apiKey: process.env['ANTHROPIC_API_KEY'] // This is the default and can be omitted
+});
+async function main() {
+  const message = await client.messages.create({
+    max_tokens: 1024,
+    messages: [{
+      role: 'user',
+      content: 'Hello, Claude'
+    }],
+    model: 'claude-3-5-sonnet-latest'
+  });
+  console.log(message.content);
+}
+main();

package/dist/cjs/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+console.info('ohai');

package/dist/cjs/openai.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OpenAiClient = void 0;
+var _openai = _interopRequireDefault(require("openai"));
+var _Wrapper = _interopRequireDefault(require("./Wrapper.js"));
+var _util = require("./util.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const DEFAULT_MODEL = 'gpt-4o';
+class OpenAiClient extends _Wrapper.default {
+  constructor(options) {
+    super(options);
+    this.client = new _openai.default({
+      ...options
+    });
+  }
+  async prompt(options) {
+    const messages = await this.getMessages(options);
+    return await runCompletion(this.client, messages, options);
+  }
+}
+exports.OpenAiClient = OpenAiClient;
+async function runCompletion(client, messages, options) {
+  const {
+    output = 'text',
+    model = DEFAULT_MODEL
+  } = options;
+  const response = await client.chat.completions.create({
+    model,
+    messages
+  });
+  let content = response.choices[0].message.content;
+  if (output === 'raw') {
+    return response;
+  } else if (output === 'text') {
+    return content;
+  } else if (output === 'messages') {
+    const {
+      message
+    } = response.choices[0];
+    return [...messages, message];
+  } else if (output === 'json') {
+    return (0, _util.parse)(content);
+  } else {
+    throw new Error(`Unknown output type "${output}".`);
+  }
+}

package/dist/cjs/util.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadTemplates = loadTemplates;
+exports.parse = parse;
+var _promises = _interopRequireDefault(require("fs/promises"));
+var _path = _interopRequireDefault(require("path"));
+var _glob = require("glob");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const JSON_REG = /([{[].+[}\]])/s;
+async function loadTemplates(dir) {
+  const result = {};
+  const files = await (0, _glob.glob)(_path.default.join(dir, '*.md'));
+  for (let file of files) {
+    const base = _path.default.basename(file, '.md');
+    result[base] = await _promises.default.readFile(file, 'utf-8');
+  }
+  return result;
+}
+function parse(content) {
+  try {
+    const match = content.match(JSON_REG);
+    return JSON.parse(match[1]);
+  } catch (error) {
+    throw new Error('Unable to derive JSON object in response.');
+  }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@bedrockio/ai",
+  "version": "0.1.0",
+  "description": "Bedrock wrapper for common AI chatbots.",
+  "type": "module",
+  "scripts": {
+    "test": "node --no-warnings node_modules/.bin/jest",
+    "types": "tsc",
+    "lint": "eslint",
+    "build": "scripts/build",
+    "eject": "scripts/eject",
+    "prepublish": "yarn build && yarn types"
+  },
+  "main": "./dist/cjs/index.js",
+  "types": "types/index.d.ts",
+  "contributors": [
+    {
+      "name": "Andrew Plummer",
+      "email": "andrew@rekall.ai"
+    }
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bedrockio/router"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.33.1",
+    "glob": "^11.0.1",
+    "mustache": "^4.2.0",
+    "openai": "^4.79.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.26.4",
+    "@babel/core": "^7.26.0",
+    "@babel/eslint-parser": "^7.26.5",
+    "@babel/preset-env": "^7.26.0",
+    "@bedrockio/prettier-config": "^1.0.2",
+    "eslint": "^8.33.0",
+    "eslint-plugin-bedrock": "^1.0.27",
+    "eslint-plugin-import": "^2.31.0",
+    "jest": "^29.7.0",
+    "prettier-eslint": "^16.3.0",
+    "typescript": "^5.7.3"
+  },
+  "volta": {
+    "node": "22.12.0",
+    "yarn": "1.22.22"
+  }
+}

package/src/BaseClient.js

@@ -0,0 +1,134 @@
+import Mustache from 'mustache';
+
+import { loadTemplates } from './util.js';
+
+const MESSAGES_REG = /(?:^|\n)-{3,}\s*(\w+)\s*-{3,}(.*?)(?=\n-{3,}|$)/gs;
+
+export default class BaseClient {
+  constructor(options) {
+    this.options = options;
+    this.templates = null;
+  }
+
+  /**
+   * Interpolates vars into the provided template and
+   * runs the chat completion. The "output" option may
+   * be omitted and will default to `"text"`.
+   * {@link https://github.com/bedrockio/ai?tab=readme-ov-file#bedrockioai Documentation}
+   *
+   * @param {object} options
+   * @param {string} options.model - The model to use.
+   * @param {"raw" | "text" | "json" | "messages"} [options.output] - The output to use.
+   * @param {Object.<string, any>} [options.other] - Additional props
+   *             will be interpolated in the template.
+   */
+  async prompt(options) {
+    options = {
+      ...this.options,
+      ...options,
+    };
+
+    const messages = await this.getMessages(options);
+    return await this.getCompletion({
+      ...options,
+      messages,
+    });
+  }
+
+  /**
+   * Streams the prompt response.
+   * @returns {AsyncIterator}
+   */
+  async *stream(options) {
+    const stream = await this.prompt({
+      ...options,
+      output: 'raw',
+      stream: true,
+    });
+
+    let started = false;
+
+    // @ts-ignore
+    for await (const chunk of stream) {
+      const resolved = this.getStreamedChunk(chunk, started);
+      started = true;
+
+      // @ts-ignore
+      if (resolved) {
+        yield resolved;
+      }
+    }
+  }
+
+  async getMessages(options) {
+    const template = await this.resolveTemplate(options);
+    const raw = Mustache.render(template, transformParams(options));
+
+    const messages = [];
+    for (let match of raw.matchAll(MESSAGES_REG)) {
+      const [, role, content] = match;
+      messages.push({
+        role: role.toLowerCase(),
+        content: content.trim(),
+      });
+    }
+
+    if (!messages.length) {
+      messages.push({
+        role: 'user',
+        content: raw.trim(),
+      });
+    }
+
+    return messages;
+  }
+
+  async loadTemplates() {
+    const { templates } = this.options;
+    this.templates ||= await loadTemplates(templates);
+  }
+
+  async resolveTemplate(options) {
+    await this.loadTemplates();
+
+    let { file, template } = options;
+
+    if (!template && file) {
+      template = this.templates[file];
+    }
+
+    if (!template) {
+      throw new Error('No template provided.');
+    }
+
+    return template;
+  }
+
+  getCompletion(options) {
+    void options;
+    new Error('Method not implemented.');
+  }
+
+  getStreamedChunk(chunk, started) {
+    void chunk;
+    void started;
+    new Error('Method not implemented.');
+  }
+}
+
+function transformParams(params) {
+  const result = {};
+  for (let [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      value = value
+        .map((el) => {
+          return `- ${el}`;
+        })
+        .join('\n');
+    } else if (typeof value === 'object') {
+      value = JSON.stringify(value, null, 2);
+    }
+    result[key] = value;
+  }
+  return result;
+}

package/src/anthropic.js

@@ -0,0 +1,96 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+import BaseClient from './BaseClient.js';
+import { transformResponse } from './util.js';
+
+const MODELS_URL = 'https://docs.anthropic.com/en/docs/about-claude/models';
+const DEFAULT_MODEL = 'claude-3-5-sonnet-latest';
+
+export class AnthropicClient extends BaseClient {
+  constructor(options) {
+    super(options);
+    this.client = new Anthropic({
+      ...options,
+    });
+  }
+
+  /**
+   * Lists available models.
+   */
+  async models() {
+    const { data } = await this.client.models.list();
+    return data.map((o) => o.id);
+  }
+
+  async getCompletion(options) {
+    const {
+      model = DEFAULT_MODEL,
+      max_tokens = 2048,
+      output = 'text',
+      stream = false,
+      messages,
+    } = options;
+    const { client } = this;
+
+    const { system, user } = splitMessages(messages);
+
+    if (!model) {
+      throw new Error(
+        `No model specified. Available models are here: ${MODELS_URL}.`,
+      );
+    }
+
+    const response = await client.messages.create({
+      max_tokens,
+      messages: user,
+      system,
+      model,
+      stream,
+    });
+
+    if (output === 'raw') {
+      return response;
+    }
+
+    // @ts-ignore
+    const message = response.content[0];
+
+    return transformResponse({
+      ...options,
+      messages,
+      message,
+    });
+  }
+
+  getStreamedChunk(chunk) {
+    // @ts-ignore
+    let type;
+    if (chunk.type === 'content_block_start') {
+      type = 'start';
+    } else if (chunk.type === 'content_block_delta') {
+      type = 'chunk';
+    } else if (chunk.type === 'message_stop') {
+      type = 'stop';
+    }
+
+    if (type) {
+      return {
+        type,
+        text: chunk.delta?.text || '',
+      };
+    }
+  }
+}
+
+function splitMessages(messages) {
+  const system = [];
+  const user = [];
+  for (let message of messages) {
+    if (message.role === 'system') {
+      system.push(message);
+    } else {
+      user.push(message);
+    }
+  }
+  return { system: system.join('\n'), user };
+}

package/src/index.js

@@ -0,0 +1,17 @@
+import { OpenAiClient } from './openai.js';
+import { AnthropicClient } from './anthropic.js';
+
+export class Client {
+  constructor(options) {
+    const { platform, ...rest } = options;
+    if (platform === 'openai' || platform === 'gpt') {
+      return new OpenAiClient(rest);
+    } else if (platform === 'anthropic' || platform === 'claude') {
+      return new AnthropicClient(rest);
+    } else if (platform) {
+      throw new Error(`Unknown platform "${platform}".`);
+    } else {
+      throw new Error('Platform required.');
+    }
+  }
+}

package/src/openai.js

@@ -0,0 +1,67 @@
+import OpenAI from 'openai';
+
+import BaseClient from './BaseClient.js';
+import { transformResponse } from './util.js';
+
+const DEFAULT_MODEL = 'gpt-4o';
+
+export class OpenAiClient extends BaseClient {
+  constructor(options) {
+    super(options);
+    this.client = new OpenAI({
+      ...options,
+    });
+  }
+
+  /**
+   * Lists available models.
+   */
+  async models() {
+    const { data } = await this.client.models.list();
+    return data.map((o) => o.id);
+  }
+
+  async getCompletion(options) {
+    const { model = DEFAULT_MODEL, output = 'text', stream = false } = options;
+    const { client } = this;
+
+    const messages = await this.getMessages(options);
+    const response = await client.chat.completions.create({
+      model,
+      messages,
+      stream,
+    });
+
+    if (output === 'raw') {
+      return response;
+    }
+
+    const { message } = response.choices[0];
+
+    return transformResponse({
+      ...options,
+      messages,
+      message,
+    });
+  }
+
+  getStreamedChunk(chunk, started) {
+    const [choice] = chunk.choices;
+
+    let type;
+    if (!started) {
+      type = 'start';
+    } else if (choice.finish_reason === 'stop') {
+      type = 'stop';
+    } else {
+      type = 'chunk';
+    }
+
+    if (type) {
+      return {
+        type,
+        text: choice.delta.content || '',
+      };
+    }
+  }
+}

package/src/util.js

@@ -0,0 +1,42 @@
+import fs from 'fs/promises';
+
+import path from 'path';
+
+import { glob } from 'glob';
+
+const JSON_REG = /([{[].+[}\]])/s;
+
+export async function loadTemplates(dir) {
+  const result = {};
+  const files = await glob(path.join(dir, '*.md'));
+
+  for (let file of files) {
+    const base = path.basename(file, '.md');
+    result[base] = await fs.readFile(file, 'utf-8');
+  }
+
+  return result;
+}
+
+export function parse(content) {
+  try {
+    const match = content.match(JSON_REG);
+    return JSON.parse(match[1]);
+  } catch (error) {
+    throw new Error('Unable to derive JSON object in response.');
+  }
+}
+
+export function transformResponse(options) {
+  const { output = 'text', messages, message } = options;
+  const content = message.content || message.text;
+  if (output === 'text') {
+    return content;
+  } else if (output === 'messages') {
+    return [...messages, message];
+  } else if (output === 'json') {
+    return parse(content);
+  } else {
+    throw new Error(`Unknown output type "${output}".`);
+  }
+}

package/types/Link.d.ts

@@ -0,0 +1,2 @@
+export default function Link(props: any): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Link.d.ts.map

package/types/Link.d.ts.map

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

package/types/NavLink.d.ts

@@ -0,0 +1,2 @@
+export default function NavLink(props: any): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=NavLink.d.ts.map

package/types/NavLink.d.ts.map

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

package/types/Redirect.d.ts

@@ -0,0 +1,2 @@
+export default function Redirect(props: any): any;
+//# sourceMappingURL=Redirect.d.ts.map

package/types/Redirect.d.ts.map

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

package/types/Route.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @typedef {import('react').ReactNode|import('react').ElementType} Node
+ *
+ * @typedef {Object} RouteProps
+ * @property {string} path - The path to use.
+ * @property {Node} render - The component or element to render.
+ *
+ * @param {RouteProps} props
+ */
+export default function Route(props: RouteProps): string | number | boolean | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | import("react").ReactPortal;
+export type Node = import("react").ReactNode | import("react").ElementType;
+export type RouteProps = {
+    /**
+     * - The path to use.
+     */
+    path: string;
+    /**
+     * - The component or element to render.
+     */
+    render: Node;
+};
+//# sourceMappingURL=Route.d.ts.map

package/types/Route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Route.d.ts","sourceRoot":"","sources":["../src/Route.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,qCAFW,UAAU,0LAWpB;mBAjBY,OAAO,OAAO,EAAE,SAAS,GAAC,OAAO,OAAO,EAAE,WAAW;;;;;UAGpD,MAAM;;;;YACN,IAAI"}

package/types/Router.d.ts

@@ -0,0 +1,4 @@
+export default function Router(props: any): import("react/jsx-runtime").JSX.Element;
+export function useRouter(): any;
+export const RouterContext: import("react").Context<any>;
+//# sourceMappingURL=Router.d.ts.map

package/types/Router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Router.d.ts","sourceRoot":"","sources":["../src/Router.js"],"names":[],"mappings":"AA6BA,oFAsDC;AAED,iCAEC;AAxED,yDAA2D"}

package/types/hoc.d.ts

@@ -0,0 +1,2 @@
+export function withRouter(Component: any): (props: any) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=hoc.d.ts.map

package/types/hoc.d.ts.map

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

package/types/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

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

package/types/location.d.ts

@@ -0,0 +1,2 @@
+export function useLocation(): any;
+//# sourceMappingURL=location.d.ts.map

package/types/location.d.ts.map

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

package/types/navigate.d.ts

@@ -0,0 +1,8 @@
+export function useNavigate(): typeof navigate;
+declare function navigate(path: any, state: any): void;
+declare namespace navigate {
+    export { replace };
+}
+declare function replace(path: any, state: any): void;
+export {};
+//# sourceMappingURL=navigate.d.ts.map

package/types/navigate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../src/navigate.js"],"names":[],"mappings":"AAYA,+CAEC;AAZD,uDAEC;;;;AAED,sDAEC"}

package/types/params.d.ts

@@ -0,0 +1,2 @@
+export function useParams(): any;
+//# sourceMappingURL=params.d.ts.map

package/types/params.d.ts.map

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

package/types/search.d.ts

@@ -0,0 +1,2 @@
+export function useSearch(): any;
+//# sourceMappingURL=search.d.ts.map

package/types/search.d.ts.map

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