@xata.io/client 0.22.0 → 0.22.2

package/.turbo/turbo-add-version.log

@@ -1,4 +1,4 @@
 
-> @xata.io/client@0.22.0 add-version /home/runner/work/client-ts/client-ts/packages/client
+> @xata.io/client@0.22.2 add-version /home/runner/work/client-ts/client-ts/packages/client
 > node ../../scripts/add-version-file.mjs
 

package/.turbo/turbo-build.log

@@ -1,13 +1,13 @@
 
-> @xata.io/client@0.22.0 build /home/runner/work/client-ts/client-ts/packages/client
+> @xata.io/client@0.22.2 build /home/runner/work/client-ts/client-ts/packages/client
 > rimraf dist && rollup -c
 
 
 src/index.ts → dist/index.cjs...
-created dist/index.cjs in 1s
+created dist/index.cjs in 1.2s
 
 src/index.ts → dist/index.mjs...
-created dist/index.mjs in 814ms
+created dist/index.mjs in 1.1s
 
 src/index.ts → dist/index.d.ts...
-created dist/index.d.ts in 6.5s
+created dist/index.d.ts in 6.9s

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @xata.io/client
 
+## 0.22.2
+
+### Patch Changes
+
+- [#898](https://github.com/xataio/client-ts/pull/898) [`72e13bf9`](https://github.com/xataio/client-ts/commit/72e13bf99d0ebefef91c984a995a28b0e8ca2a8f) Thanks [@SferaDev](https://github.com/SferaDev)! - Add methods for vector type
+
+## 0.22.1
+
+### Patch Changes
+
+- [#885](https://github.com/xataio/client-ts/pull/885) [`4cafde72`](https://github.com/xataio/client-ts/commit/4cafde728e4e9e5e83812d475d9980397ae78362) Thanks [@SferaDev](https://github.com/SferaDev)! - Update body of compareBranchSchemas
+
+- [#890](https://github.com/xataio/client-ts/pull/890) [`639710a5`](https://github.com/xataio/client-ts/commit/639710a52132f260bf3a26560a21ae2193abb71d) Thanks [@SferaDev](https://github.com/SferaDev)! - Expose consistency settings in summarize
+
 ## 0.22.0
 
 ### Minor Changes

package/README.md

@@ -4,277 +4,4 @@ The Xata SDK supports typescript definitions for your Xata database schema. It a
 
 It has zero dependencies and runs in Node.js, V8, Deno and Bun.
 
-## Installation
-
-See our [docs](https://xata.io/docs/sdk/typescript#installation) to get started using the Xata SDK.
-
-
-## Table of Contents
-
-<!-- START doctoc generated TOC please keep comment here to allow auto update -->
-<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
-
-- [Installation](#installation)
-- [Usage](#usage)
-  - [Schema-generated Client](#schema-generated-client)
-  - [Schema-less Client](#schema-less-client)
-  - [API Design](#api-design)
-    - [Creating Records](#creating-records)
-    - [Query a Single Record by its ID](#query-a-single-record-by-its-id)
-    - [Querying Multiple Records](#querying-multiple-records)
-    - [Updating Records](#updating-records)
-    - [Deleting Records](#deleting-records)
-  - [API Client](#api-client)
-- [Deno support](#deno-support)
-
-<!-- END doctoc generated TOC please keep comment here to allow auto update -->
-
-## Manual Installation
-
-```bash
-npm install @xata.io/client
-```
-
-## Usage
-
-There are three ways to use the SDK:
-
-- **Schema-generated Client**: SDK to create/read/update/delete records in a given database following a schema file (with type-safety).
-- **Schema-less Client**: SDK to create/read/update/delete records in any database without schema validation (with partial type-safety).
-- **API Client**: SDK to interact with the whole Xata API and all its endpoints.
-
-### Schema-generated Client
-
-To use the schema-generated client, you need to run the code generator utility that comes with [our CLI](https://docs.xata.io/cli/getting-started).
-
-To run it (and assuming you have configured the project with `xata init`):
-
-```bash
-xata codegen
-```
-
-In a TypeScript file, start using the generated code like this:
-
-```ts
-import { XataClient } from './xata'; // or wherever you chose to generate the client
-
-const xata = new XataClient();
-```
-
-The import above will differ if you chose to generate the code in a different location.
-
-The `XataClient` constructor accepts an object with configuration options, like the `fetch` parameter, which is required only if your runtime doesn't provide a global `fetch` function. There's also a `databaseURL` argument that by default will contain a URL pointing to your database (e.g. `https://myworkspace-123abc.xata.sh/db/databasename`). It can be specified in the constructor to overwrite that value if for whatever reason you need to connect to a different workspace or database.
-
-The code generator will create two TypeScript types for each schema entity. The base one will be an `Identifiable` entity with the internal properties your entity has and the `Record` one will extend it with a set of operations (update, delete, etc...) and some schema metadata (xata version).
-
-```ts
-interface User extends Identifiable {
-  email?: string | null;
-}
-
-type UserRecord = User & XataRecord;
-
-async function initializeDatabase(admin: User): Promise<UserRecord> {
-  return xata.db.users.create(admin);
-}
-
-const admin = await initializeDatabase({ email: 'admin@example.com' });
-await admin.update({ email: 'admin@foo.bar' });
-await admin.delete();
-```
-
-You will learn more about the available operations below, under the [`API Design`](#api-design) section.
-
-### Schema-less Client
-
-If you don't have a schema file, or you are building a generic way to interact with Xata, you can use the `BaseClient` class without schema validation.
-
-```ts
-import { BaseClient } from '@xata.io/client';
-
-const xata = new BaseClient({
-  branch: 'branchname',
-  apiKey: 'xau_1234abcdef',
-  fetch: fetchImplementation // Required if your runtime doesn't provide a global `fetch` function.
-});
-```
-
-It works the same way as the code-generated `XataClient` but doesn't provide type-safety for your model.
-
-You can read more on the methods available below, in the next section.
-
-### API Design
-
-The Xata SDK to create/read/update/delete records follows the [repository pattern](https://lyz-code.github.io/blue-book/architecture/repository_pattern/). Each table will have a repository object available at `xata.db.[table-name]`.
-
-For example if you have a `users` table, there'll be a repository at `xata.db.users`. If you're using the schema-less client, you can also use the `xata.db.[table-name]` syntax to access the repository but without TypeScript auto-completion.
-
-#### Creating Records
-
-Invoke the `create()` method in the repository. Example:
-
-```ts
-const user = await xata.db.users.create({
-  fullName: 'John Smith'
-});
-```
-
-If you want to create a record with a specific ID, you can provide the id as parameter to the `create()` method.
-
-```ts
-const user = await xata.db.users.create('user_admin', {
-  fullName: 'John Smith'
-});
-```
-
-And if you want to create or update a record with a specific ID, you can invoke `createOrUpdate()` with an id parameter.
-
-```ts
-const user = await xata.db.users.createOrUpdate('user_admin', {
-  fullName: 'John Smith'
-});
-```
-
-#### Query a Single Record by its ID
-
-```ts
-// `user` will be null if the record cannot be found
-const user = await xata.db.users.read('rec_1234abcdef');
-```
-
-#### Querying Multiple Records
-
-```ts
-// Query records selecting all fields.
-const page = await xata.db.users.select().getPaginated();
-const user = await xata.db.users.select().getFirst();
-
-// You can also use `xata.db.users` directly, since it's an immutable Query too!
-const page = await xata.db.users.getPaginated();
-const user = await xata.db.users.getFirst();
-
-// Query records selecting just one or more fields
-const page = await xata.db.users.select('email', 'profile').getPaginated();
-
-// Apply constraints
-const page = await xata.db.users.filter('email', 'foo@example.com').getPaginated();
-
-// Sorting
-const page = await xata.db.users.sort('full_name', 'asc').getPaginated();
-```
-
-Query operations (`select()`, `filter()`, `sort()`) return a `Query` object. These objects are immutable. You can add additional constraints, `sort`, etc. by calling their methods, and a new query will be returned. In order to finally make a query to the database you'll invoke `getPaginated()`, `getMany()`, `getAll()`, or `getFirst()`.
-
-To learn the differences between these methods, see the [reference](https://docs.xata.io/sdk/reference#query).
-
-```ts
-// Operators that combine multiple conditions can be deconstructed
-const { filter, any, all, not, sort } = xata.db.users;
-const query = filter('email', 'foo@example.com');
-
-// Single-column operators are imported directly from the package
-import { gt, includes, startsWith } from '@xata.io/client';
-filter('email', startsWith('username')).not(filter('created_at', gt(somePastDate)));
-
-// Queries are immutable objects. This is useful to derive queries from other queries
-const admins = filter('admin', true);
-const spaniardsAdmins = admins.filter('country', 'Spain');
-await admins.getAll(); // still returns all admins
-
-// Finally fetch the results of the query
-const users = await query.getAll();
-const firstUser = await query.getFirst();
-```
-
-The `getPaginated()` method will return a `Page` object. It's a wrapper that internally uses cursor based pagination.
-
-```ts
-page.records; // Array of records
-page.hasNextPage(); // Boolean
-
-const nextPage = await page.nextPage(); // Page object
-const previousPage = await page.previousPage(); // Page object
-const startPage = await page.startPage(); // Page object
-const endPage = await page.endPage(); // Page object
-```
-
-If you want to use an iterator, both the Repository and the Query classes implement an `AsyncIterable`. Alternatively you can use `getIterator()` and customize the batch size of the iterator:
-
-```ts
-for await (const record of xata.db.users) {
-  console.log(record);
-}
-
-for await (const record of xata.db.users.filter('team.id', teamId)) {
-  console.log(record);
-}
-
-for await (const records of xata.db.users.getIterator({ batchSize: 100 })) {
-  console.log(records);
-}
-```
-
-#### Updating Records
-
-Updating a record leaves the existing object unchanged, but returns a new object with the updated values.
-
-```ts
-// Using an existing object
-const updatedUser = await user.update({
-  fullName: 'John Smith Jr.'
-});
-
-// Using a record id
-const updatedUser = await xata.db.users.update('rec_1234abcdef', {
-  fullName: 'John Smith Jr.'
-});
-```
-
-#### Deleting Records
-
-```ts
-// Using an existing object
-await user.delete();
-
-// Using a record id
-await xata.db.users.delete('rec_1234abcdef');
-```
-
-### API Client
-
-One of the main features of the SDK is the ability to interact with the whole Xata API and perform administrative operations such as creating/reading/updating/deleting [workspaces](https://docs.xata.io/concepts/workspaces), databases, tables, branches...
-
-To communicate with the SDK we provide a constructor called `XataApiClient` that accepts an API token and an optional fetch implementation method.
-
-```ts
-const api = new XataApiClient({ apiKey: process.env.XATA_API_KEY });
-```
-
-Once you have initialized the API client, the operations are organized following the same hiearchy as in the [official documentation](https://docs.xata.io). You have different namespaces for each entity (ie. `workspaces`, `databases`, `tables`, `branches`, `users`, `records`...).
-
-```ts
-const { id: workspace } = await api.workspaces.createWorkspace({ name: 'example' });
-const { databaseName } = await api.database.createDatabase(workspace, 'database', { region: 'eu-west-1' });
-
-await api.branches.createBranch(workspace, databaseName, 'branch');
-await api.tables.createTable(workspace, databaseName, 'branch', 'table');
-await api.tables.setTableSchema(workspace, databaseName, 'branch', 'table', {
-  columns: [{ name: 'email', type: 'string' }]
-});
-
-const { id: recordId } = await api.records.insertRecord(workspace, databaseName, 'branch', 'table', {
-  email: 'example@foo.bar'
-});
-
-const record = await api.records.getRecord(workspace, databaseName, 'branch', 'table', recordId);
-
-await api.workspaces.deleteWorkspace(workspace);
-```
-
-## Deno support
-
-We publish the client on [deno.land](https://deno.land/x/xata). You can use it by changing the import in the auto-generated `xata.ts` file:
-
-```ts
-import { buildClient, BaseClientOptions, XataRecord } from 'https://deno.land/x/xata/mod.ts';
-```
+You can find the SDK documentation [here](https://xata.io/docs/typescript-client/overview).

package/dist/index.cjs

@@ -302,7 +302,7 @@ function generateUUID() {
   });
 }
 
-const VERSION = "0.22.0";
+const VERSION = "0.22.2";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -396,6 +396,7 @@ async function fetch$1({
   clientID,
   sessionID,
   clientName,
+  xataAgentExtra,
   fetchOptions = {}
 }) {
   pool.setFetch(fetchImpl);
@@ -412,7 +413,8 @@ async function fetch$1({
       const xataAgent = compact([
         ["client", "TS_SDK"],
         ["version", VERSION],
-        isDefined(clientName) ? ["service", clientName] : void 0
+        isDefined(clientName) ? ["service", clientName] : void 0,
+        ...Object.entries(xataAgentExtra ?? {})
       ]).map(([key, value]) => `${key}=${value}`).join("; ");
       const headers = {
         "Accept-Encoding": "identity",
@@ -611,6 +613,7 @@ const searchTable = (variables, signal) => dataPlaneFetch({
   ...variables,
   signal
 });
+const vectorSearchTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/vectorSearch", method: "post", ...variables, signal });
 const summarizeTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/summarize", method: "post", ...variables, signal });
 const aggregateTable = (variables, signal) => dataPlaneFetch({ url: "/db/{dbBranchName}/tables/{tableName}/aggregate", method: "post", ...variables, signal });
 const operationsByTag$2 = {
@@ -670,7 +673,7 @@ const operationsByTag$2 = {
     deleteRecord,
     bulkInsertTableRecords
   },
-  searchAndFilter: { queryTable, searchBranch, searchTable, summarizeTable, aggregateTable }
+  searchAndFilter: { queryTable, searchBranch, searchTable, vectorSearchTable, summarizeTable, aggregateTable }
 };
 
 const controlPlaneFetch = async (options) => fetch$1({ ...options, endpoint: "controlPlane" });
@@ -769,6 +772,9 @@ const deleteDatabase = (variables, signal) => controlPlaneFetch({
 });
 const getDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "get", ...variables, signal });
 const updateDatabaseMetadata = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "patch", ...variables, signal });
+const getDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "get", ...variables, signal });
+const updateDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "put", ...variables, signal });
+const deleteDatabaseGithubSettings = (variables, signal) => controlPlaneFetch({ url: "/workspaces/{workspaceId}/dbs/{dbName}/github", method: "delete", ...variables, signal });
 const listRegions = (variables, signal) => controlPlaneFetch({
   url: "/workspaces/{workspaceId}/regions",
   method: "get",
@@ -801,6 +807,9 @@ const operationsByTag$1 = {
     deleteDatabase,
     getDatabaseMetadata,
     updateDatabaseMetadata,
+    getDatabaseGithubSettings,
+    updateDatabaseGithubSettings,
+    deleteDatabaseGithubSettings,
     listRegions
   }
 };
@@ -821,8 +830,8 @@ const providers = {
     workspaces: "https://{workspaceId}.{region}.xata.sh"
   },
   staging: {
-    main: "https://staging.xatabase.co",
-    workspaces: "https://{workspaceId}.staging.{region}.xatabase.co"
+    main: "https://api.staging-xata.dev",
+    workspaces: "https://{workspaceId}.{region}.staging-xata.dev"
   }
 };
 function isHostProviderAlias(alias) {
@@ -844,8 +853,10 @@ function parseWorkspacesUrlParts(url) {
   if (!isString(url))
     return null;
   const regex = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.sh.*/;
-  const regexStaging = /(?:https:\/\/)?([^.]+)\.staging(?:\.([^.]+))\.xatabase\.co.*/;
-  const match = url.match(regex) || url.match(regexStaging);
+  const regexDev = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.dev-xata\.dev.*/;
+  const regexStaging = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.staging-xata\.dev.*/;
+  const regexProdTesting = /(?:https:\/\/)?([^.]+)(?:\.([^.]+))\.xata\.tech.*/;
+  const match = url.match(regex) || url.match(regexDev) || url.match(regexStaging) || url.match(regexProdTesting);
   if (!match)
     return null;
   return { workspace: match[1], region: match[2] };
@@ -888,6 +899,7 @@ class XataApiClient {
       apiKey,
       trace,
       clientName: options.clientName,
+      xataAgentExtra: options.xataAgentExtra,
       clientID
     });
   }
@@ -1763,11 +1775,13 @@ class MigrationsApi {
     region,
     database,
     branch,
-    schema
+    schema,
+    schemaOperations,
+    branchOperations
   }) {
     return operationsByTag.migrations.compareBranchWithUserSchema({
       pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
-      body: { schema },
+      body: { schema, schemaOperations, branchOperations },
       ...this.extraProps
     });
   }
@@ -1777,11 +1791,12 @@ class MigrationsApi {
     database,
     branch,
     compare,
-    schema
+    sourceBranchOperations,
+    targetBranchOperations
   }) {
     return operationsByTag.migrations.compareBranchSchemas({
       pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, branchName: compare },
-      body: { schema },
+      body: { sourceBranchOperations, targetBranchOperations },
       ...this.extraProps
     });
   }
@@ -1875,6 +1890,35 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
+  getDatabaseGithubSettings({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.getDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      ...this.extraProps
+    });
+  }
+  updateDatabaseGithubSettings({
+    workspace,
+    database,
+    settings
+  }) {
+    return operationsByTag.databases.updateDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: settings,
+      ...this.extraProps
+    });
+  }
+  deleteDatabaseGithubSettings({
+    workspace,
+    database
+  }) {
+    return operationsByTag.databases.deleteDatabaseGithubSettings({
+      pathParams: { workspaceId: workspace, dbName: database },
+      ...this.extraProps
+    });
+  }
   listRegions({ workspace }) {
     return operationsByTag.databases.listRegions({
       pathParams: { workspaceId: workspace },
@@ -2573,6 +2617,29 @@ class RestRepository extends Query {
       return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"]));
     });
   }
+  async vectorSearch(column, query, options) {
+    return __privateGet$4(this, _trace).call(this, "vectorSearch", async () => {
+      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+      const { records } = await vectorSearchTable({
+        pathParams: {
+          workspace: "{workspaceId}",
+          dbBranchName: "{dbBranch}",
+          region: "{region}",
+          tableName: __privateGet$4(this, _table)
+        },
+        body: {
+          column,
+          queryVector: query,
+          similarityFunction: options?.similarityFunction,
+          size: options?.size,
+          filter: options?.filter
+        },
+        ...fetchProps
+      });
+      const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+      return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, ["*"]));
+    });
+  }
   async aggregate(aggs, filter) {
     return __privateGet$4(this, _trace).call(this, "aggregate", async () => {
       const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
@@ -3240,7 +3307,8 @@ async function resolveXataBranch(gitBranch, options) {
     pathParams: { dbName, workspace, region },
     queryParams: { gitBranch, fallbackBranch },
     trace: defaultTrace,
-    clientName: options?.clientName
+    clientName: options?.clientName,
+    xataAgentExtra: options?.xataAgentExtra
   });
   return branch;
 }
@@ -3360,11 +3428,13 @@ const buildClient = (plugins) => {
     const cache = options?.cache ?? new SimpleCache({ defaultQueryTTL: 0 });
     const trace = options?.trace ?? defaultTrace;
     const clientName = options?.clientName;
+    const xataAgentExtra = options?.xataAgentExtra;
     const branch = async () => options?.branch !== void 0 ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({
       apiKey,
       databaseURL,
       fetchImpl: options?.fetch,
-      clientName: options?.clientName
+      clientName,
+      xataAgentExtra
     });
     if (!apiKey) {
       throw new Error("Option apiKey is required");
@@ -3372,7 +3442,18 @@ const buildClient = (plugins) => {
     if (!databaseURL) {
       throw new Error("Option databaseURL is required");
     }
-    return { fetch, databaseURL, apiKey, branch, cache, trace, clientID: generateUUID(), enableBrowser, clientName };
+    return {
+      fetch,
+      databaseURL,
+      apiKey,
+      branch,
+      cache,
+      trace,
+      clientID: generateUUID(),
+      enableBrowser,
+      clientName,
+      xataAgentExtra
+    };
   }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({
     fetch,
     apiKey,
@@ -3380,7 +3461,8 @@ const buildClient = (plugins) => {
     branch,
     trace,
     clientID,
-    clientName
+    clientName,
+    xataAgentExtra
   }) {
     const branchValue = await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, branch);
     if (!branchValue)
@@ -3396,7 +3478,8 @@ const buildClient = (plugins) => {
       },
       trace,
       clientID,
-      clientName
+      clientName,
+      xataAgentExtra
     };
   }, _evaluateBranch = new WeakSet(), evaluateBranch_fn = async function(param) {
     if (__privateGet(this, _branch))
@@ -3551,6 +3634,7 @@ exports.createWorkspace = createWorkspace;
 exports.deleteBranch = deleteBranch;
 exports.deleteColumn = deleteColumn;
 exports.deleteDatabase = deleteDatabase;
+exports.deleteDatabaseGithubSettings = deleteDatabaseGithubSettings;
 exports.deleteRecord = deleteRecord;
 exports.deleteTable = deleteTable;
 exports.deleteUser = deleteUser;
@@ -3573,6 +3657,7 @@ exports.getBranchStats = getBranchStats;
 exports.getColumn = getColumn;
 exports.getCurrentBranchDetails = getCurrentBranchDetails;
 exports.getCurrentBranchName = getCurrentBranchName;
+exports.getDatabaseGithubSettings = getDatabaseGithubSettings;
 exports.getDatabaseList = getDatabaseList;
 exports.getDatabaseMetadata = getDatabaseMetadata;
 exports.getDatabaseURL = getDatabaseURL;
@@ -3637,6 +3722,7 @@ exports.summarizeTable = summarizeTable;
 exports.updateBranchMetadata = updateBranchMetadata;
 exports.updateBranchSchema = updateBranchSchema;
 exports.updateColumn = updateColumn;
+exports.updateDatabaseGithubSettings = updateDatabaseGithubSettings;
 exports.updateDatabaseMetadata = updateDatabaseMetadata;
 exports.updateMigrationRequest = updateMigrationRequest;
 exports.updateRecordWithID = updateRecordWithID;
@@ -3646,4 +3732,5 @@ exports.updateWorkspace = updateWorkspace;
 exports.updateWorkspaceMemberInvite = updateWorkspaceMemberInvite;
 exports.updateWorkspaceMemberRole = updateWorkspaceMemberRole;
 exports.upsertRecordWithID = upsertRecordWithID;
+exports.vectorSearchTable = vectorSearchTable;
 //# sourceMappingURL=index.cjs.map