rado 1.3.0-preview.2 → 1.3.0-preview.4

package/README.md

@@ -121,6 +121,7 @@ const db = connect(new Database('app.db'))
 | PostgreSQL | [@neondatabase/serverless](https://www.npmjs.com/package/@neondatabase/serverless) | `rado/driver/pg`             | async      |
 | PostgreSQL | [@vercel/postgres](https://www.npmjs.com/package/@vercel/postgres)                 | `rado/driver/pg`             | async      |
 | SQLite     | [better-sqlite3](https://www.npmjs.com/package/better-sqlite3)                     | `rado/driver/better-sqlite3` | sync       |
+| SQLite     | `node:sqlite`                                                                      | `rado/driver/node-sqlite`    | sync       |
 | SQLite     | `bun:sqlite`                                                                       | `rado/driver/bun-sqlite`     | sync       |
 | SQLite     | [sql.js](https://www.npmjs.com/package/sql.js)                                     | `rado/driver/sql.js`         | sync       |
 | SQLite     | [@libsql/client](https://www.npmjs.com/package/@libsql/client)                     | `rado/driver/libsql`         | async      |

package/dist/core/Index.js

@@ -13,14 +13,25 @@ var IndexData = class {
 };
 var IndexApi = class extends IndexData {
   toSql(tableName, indexName, ifNotExists) {
+    const fields = this.fields.map(
+      (field) => sql.join([
+        field,
+        this.order && sql.unsafe(this.order),
+        this.nulls && sql`nulls ${sql.unsafe(this.nulls)}`
+      ])
+    );
     return sql.join([
       sql`create`,
       this.unique && sql`unique`,
       sql`index`,
+      this.concurrently && sql`concurrently`,
       ifNotExists && sql`if not exists`,
       sql.identifier(indexName),
       sql`on`,
-      sql`${sql.identifier(tableName)}(${sql.join(this.fields, sql`, `)})`,
+      this.only && sql`only`,
+      sql.identifier(tableName),
+      this.using && sql`using ${this.using}`,
+      sql`(${sql.join(fields, sql`, `)})`,
       this.where && sql`where ${this.where}`
     ]).inlineFields(false);
   }

package/dist/core/MetaData.d.ts

@@ -1,7 +1,7 @@
 export type QueryMode = 'sync' | 'async' | undefined;
 export type Runtime = 'sqlite' | 'mysql' | 'postgres';
 export type QueryDialect = 'universal' | Runtime;
-export type Deliver<Meta extends QueryMeta, Result> = Meta extends Either ? Result | Promise<Result> : Meta extends Sync ? Result : Promise<Result>;
+export type Deliver<Meta extends QueryMeta, Result> = Meta extends Sync ? Result : Meta extends Async ? Promise<Result> : Result | Promise<Result>;
 export interface QueryMeta {
     mode: QueryMode;
     dialect: QueryDialect;

package/dist/core/query/Select.d.ts

@@ -83,13 +83,13 @@ export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends U
 }
 export interface WithoutSelection<Meta extends QueryMeta> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
-    from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
-    from<Input>(from: VirtualTarget<Input>): SelectionFrom<Input, Meta>;
+    from<Input, Name extends string>(from: SubQuery<Input, Name>): SelectionFromTargets<Input, Meta, Name>;
+    from<Input>(from: VirtualTarget<Input>): SelectionFromTargets<Input, Meta, string>;
 }
 export interface WithSelection<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta>, HasSql<SelectionRow<Input>> {
-    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
-    from(from: HasTarget): SelectionFrom<Input, Meta>;
-    from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
+    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFromTargets<Input, Meta, Name>;
+    from<SubInput, Name extends string>(from: SubQuery<SubInput, Name>): SelectionFromTargets<Input, Meta, Name>;
+    from<Name extends string>(from: HasTarget<Name>): SelectionFromTargets<Input, Meta, Name>;
     from(from: HasSql): Select<Input, Meta>;
 }
 export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends SelectBase<Input, Meta> {
@@ -110,28 +110,30 @@ export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
     fullJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, Input>>>, Meta>;
 }
-type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
+type MarkFieldsAsNullable<Input, TableName extends string> = Input extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input extends Table ? Input : Expand<{
     [K in keyof Input]: Input[K] extends Field<infer T, TableName> ? HasSql<T | null> : Input[K] extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input[K] extends Record<string, Field<unknown, TableName> | HasSql<unknown>> ? Input[K] & IsNullable : Input[K] extends SelectionRecord ? MarkFieldsAsNullable<Input[K], TableName> : Input[K];
 }>;
-export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
-    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    leftJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    leftJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    leftJoinLateral<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    innerJoinLateral(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFrom<Input, Meta>;
-    crossJoin(right: HasTarget): SelectionFrom<Input, Meta>;
-    crossJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFrom<Input, Meta>;
-    crossJoinLateral(right: HasTarget): SelectionFrom<Input, Meta>;
-    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
-    fullJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
-    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectionFromTargets<Input, Meta, never> {
+}
+interface SelectionFromTargets<Input, Meta extends QueryMeta, FromNames extends string = never> extends SelectBase<Input, Meta> {
+    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    leftJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames>;
+    leftJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    leftJoinLateral<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, Name>, Meta, FromNames | Name>;
+    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, FromNames>, Meta, FromNames | Name>;
+    rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, FromNames>, Meta, FromNames>;
+    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames>;
+    innerJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    innerJoinLateral(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<Input, Meta, FromNames>;
+    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    crossJoin(right: HasTarget): SelectionFromTargets<Input, Meta, FromNames>;
+    crossJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFromTargets<Input, Meta, FromNames | Name>;
+    crossJoinLateral(right: HasTarget): SelectionFromTargets<Input, Meta, FromNames>;
+    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<MarkFieldsAsNullable<Input, FromNames>, Name>, Meta, FromNames | Name>;
+    fullJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<MarkFieldsAsNullable<Input, FromNames>, Name>, Meta, FromNames | Name>;
+    fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFromTargets<MarkFieldsAsNullable<Input, FromNames>, Meta, FromNames>;
 }
 export declare function querySelection({ select, from }: SelectQuery): Selection;
 export declare function selectQuery(query: SelectQuery): Sql;

package/dist/driver/better-sqlite3.js

@@ -44,7 +44,10 @@ var BetterSqlite3Driver = class _BetterSqlite3Driver {
     this.client.close();
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client.prepare(sql), options.isSelection);
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   batch(queries) {
     return this.transaction(

package/dist/driver/bun-sqlite.js

@@ -4,10 +4,12 @@ import { sqliteDialect } from "../sqlite.js";
 import { sqliteDiff } from "../sqlite/diff.js";
 import { execTransaction } from "../sqlite/transactions.js";
 var PreparedStatement = class {
-  constructor(stmt) {
+  constructor(stmt, isSelection) {
     this.stmt = stmt;
+    this.isSelection = isSelection;
   }
   stmt;
+  isSelection;
   all(params) {
     return this.stmt.all(...params);
   }
@@ -18,6 +20,10 @@ var PreparedStatement = class {
     return this.stmt.get(...params);
   }
   values(params) {
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
     return this.stmt.values(...params);
   }
   free() {
@@ -39,12 +45,17 @@ var BunSqliteDriver = class _BunSqliteDriver {
   close() {
     this.client.close();
   }
-  prepare(sql) {
-    return new PreparedStatement(this.client.prepare(sql));
+  prepare(sql, options) {
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   batch(queries) {
     return this.transaction((tx) => {
-      return queries.map(({ sql, params }) => tx.prepare(sql).values(params));
+      return queries.map(
+        ({ sql, params, isSelection }) => tx.prepare(sql, { isSelection }).values(params)
+      );
     }, {});
   }
   transaction(run, options) {

package/dist/driver/d1.d.ts

@@ -17,7 +17,7 @@ export declare class D1Driver implements AsyncDriver {
     supportsTransactions: boolean;
     constructor(client: Client);
     exec(query: string): Promise<void>;
-    prepare(sql: string, options: PrepareOptions): PreparedStatement;
+    prepare(sql: string, options?: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
     batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(): Promise<T>;

package/dist/driver/d1.js

@@ -37,7 +37,10 @@ var D1Driver = class {
     await this.client.exec(query);
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client.prepare(sql), options.isSelection);
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
   }
   async close() {
   }
@@ -46,7 +49,11 @@ var D1Driver = class {
       ({ sql, params }) => this.client.prepare(sql).bind(...params)
     );
     const rows = await this.client.batch(stmts);
-    return rows.map((row) => row.results);
+    return rows.map((row, index) => {
+      const isSelection = queries[index]?.isSelection;
+      if (!isSelection) return [];
+      return row.results.map(Object.values);
+    });
   }
   async transaction() {
     throw new Error("Transactions are not supported in D1");

package/dist/driver/libsql.d.ts

@@ -19,7 +19,7 @@ export declare class LibSQLClient implements AsyncDriver {
     supportsTransactions: boolean;
     constructor(client: Queryable, depth?: number);
     exec(query: string): Promise<void>;
-    prepare(sql: string, options: PrepareOptions): PreparedStatement;
+    prepare(sql: string, options?: PrepareOptions): PreparedStatement;
     close(): Promise<void>;
     batch(queries: Array<BatchedQuery>): Promise<Array<Array<unknown>>>;
     transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['sqlite']): Promise<T>;

package/dist/driver/mysql2.d.ts

@@ -7,8 +7,9 @@ declare class PreparedStatement implements AsyncStatement {
     #private;
     private client;
     private sql;
+    private isSelection;
     private name?;
-    constructor(client: Queryable, sql: string, name?: string | undefined);
+    constructor(client: Queryable, sql: string, isSelection: boolean, name?: string | undefined);
     all(params: Array<unknown>): Promise<Array<object>>;
     run(params: Array<unknown>): Promise<void>;
     get(params: Array<unknown>): Promise<object>;

package/dist/driver/mysql2.js

@@ -4,13 +4,15 @@ import { mysqlDialect } from "../mysql/dialect.js";
 import { mysqlDiff } from "../mysql/diff.js";
 import { setTransaction, startTransaction } from "../mysql/transactions.js";
 var PreparedStatement = class {
-  constructor(client, sql, name) {
+  constructor(client, sql, isSelection, name) {
     this.client = client;
     this.sql = sql;
+    this.isSelection = isSelection;
     this.name = name;
   }
   client;
   sql;
+  isSelection;
   name;
   #transformParam = (param) => {
     if (param instanceof Uint8Array) return Buffer.from(param);
@@ -26,6 +28,7 @@ var PreparedStatement = class {
     return this.all(params).then((rows) => rows[0] ?? null);
   }
   values(params) {
+    if (!this.isSelection) return this.run(params).then(() => []);
     return this.client.query({
       sql: this.sql,
       values: params.map(this.#transformParam),
@@ -48,7 +51,12 @@ var Mysql2Driver = class _Mysql2Driver {
     await this.client.query(query);
   }
   prepare(sql, options) {
-    return new PreparedStatement(this.client, sql, options?.name);
+    return new PreparedStatement(
+      this.client,
+      sql,
+      options?.isSelection ?? false,
+      options?.name
+    );
   }
   async close() {
     if ("end" in this.client) return this.client.end();
@@ -56,8 +64,8 @@ var Mysql2Driver = class _Mysql2Driver {
   async batch(queries) {
     const transact = async (tx) => {
       const results = [];
-      for (const { sql, params } of queries)
-        results.push(await tx.prepare(sql).values(params));
+      for (const { sql, params, isSelection } of queries)
+        results.push(await tx.prepare(sql, { isSelection }).values(params));
       return results;
     };
     if (this.depth > 0) return transact(this);

package/dist/driver/node-sqlite.d.ts

@@ -0,0 +1,14 @@
+import { SyncDatabase } from '../core/Database.js';
+interface Client {
+    close(): void;
+    exec(query: string): void;
+    prepare(sql: string): Statement;
+}
+interface Statement {
+    all(...params: Array<unknown>): Array<object>;
+    run(...params: Array<unknown>): unknown;
+    get(...params: Array<unknown>): object | null;
+    setReturnArrays(value: boolean): void;
+}
+export declare function connect(db: Client): SyncDatabase<'sqlite'>;
+export {};

package/dist/driver/node-sqlite.js

@@ -0,0 +1,81 @@
+// src/driver/node-sqlite.ts
+import { SyncDatabase } from "../core/Database.js";
+import { sqliteDialect } from "../sqlite.js";
+import { sqliteDiff } from "../sqlite/diff.js";
+import { execTransaction } from "../sqlite/transactions.js";
+var PreparedStatement = class {
+  constructor(stmt, isSelection) {
+    this.stmt = stmt;
+    this.isSelection = isSelection;
+  }
+  stmt;
+  isSelection;
+  all(params) {
+    return this.stmt.all(...params);
+  }
+  run(params) {
+    this.stmt.run(...params);
+  }
+  get(params) {
+    return this.stmt.get(...params);
+  }
+  values(params) {
+    if (!this.isSelection) {
+      this.stmt.run(...params);
+      return [];
+    }
+    this.stmt.setReturnArrays(true);
+    try {
+      return this.stmt.all(...params);
+    } finally {
+      this.stmt.setReturnArrays(false);
+    }
+  }
+  free() {
+  }
+};
+var NodeSqliteDriver = class _NodeSqliteDriver {
+  constructor(client, depth = 0) {
+    this.client = client;
+    this.depth = depth;
+  }
+  client;
+  depth;
+  parsesJson = false;
+  supportsTransactions = true;
+  exec(query) {
+    this.client.exec(query);
+  }
+  close() {
+    this.client.close();
+  }
+  prepare(sql, options) {
+    return new PreparedStatement(
+      this.client.prepare(sql),
+      options?.isSelection ?? false
+    );
+  }
+  batch(queries) {
+    return this.transaction(
+      (tx) => queries.map(
+        ({ sql, params, isSelection }) => tx.prepare(sql, { isSelection }).values(params)
+      ),
+      {}
+    );
+  }
+  transaction(run, options) {
+    return execTransaction(
+      this,
+      this.depth,
+      (depth) => new _NodeSqliteDriver(this.client, depth),
+      run,
+      options
+    );
+  }
+};
+function connect(db) {
+  return new SyncDatabase(new NodeSqliteDriver(db), sqliteDialect, sqliteDiff);
+}
+export {
+  connect
+};

package/dist/driver/pg.js

@@ -71,7 +71,8 @@ var PgDriver = class _PgDriver {
     }, {});
   }
   async transaction(run, options) {
-    const client = "totalCount" in this.client ? await this.client.connect() : this.client;
+    const acquiredClient = this.depth === 0 && "totalCount" in this.client ? await this.client.connect() : void 0;
+    const client = acquiredClient ?? this.client;
     try {
       await client.query(this.depth > 0 ? `savepoint d${this.depth}` : "begin");
       if (this.depth === 0) await client.query(setTransaction(options));
@@ -86,7 +87,7 @@ var PgDriver = class _PgDriver {
       );
       throw error;
     } finally {
-      if ("release" in client) client.release();
+      acquiredClient?.release();
     }
   }
 };

package/dist/driver.d.ts

@@ -3,6 +3,7 @@ export { connect as 'bun:sqlite' } from './driver/bun-sqlite.js';
 export { connect as 'd1' } from './driver/d1.js';
 export { connect as '@libsql/client' } from './driver/libsql.js';
 export { connect as 'mysql2' } from './driver/mysql2.js';
+export { connect as 'node:sqlite' } from './driver/node-sqlite.js';
 export { connect as '@neondatabase/serverless', connect as '@vercel/postgres', connect as 'pg' } from './driver/pg.js';
 export { connect as '@electric-sql/pglite' } from './driver/pglite.js';
 export { connect as 'sql.js' } from './driver/sql.js.js';

package/dist/driver.js

@@ -4,22 +4,24 @@ import { connect as connect2 } from "./driver/bun-sqlite.js";
 import { connect as connect3 } from "./driver/d1.js";
 import { connect as connect4 } from "./driver/libsql.js";
 import { connect as connect5 } from "./driver/mysql2.js";
+import { connect as connect6 } from "./driver/node-sqlite.js";
 import {
-  connect as connect6,
   connect as connect7,
-  connect as connect8
+  connect as connect8,
+  connect as connect9
 } from "./driver/pg.js";
-import { connect as connect9 } from "./driver/pglite.js";
-import { connect as connect10 } from "./driver/sql.js.js";
+import { connect as connect10 } from "./driver/pglite.js";
+import { connect as connect11 } from "./driver/sql.js.js";
 export {
-  connect9 as "@electric-sql/pglite",
+  connect10 as "@electric-sql/pglite",
   connect4 as "@libsql/client",
-  connect6 as "@neondatabase/serverless",
-  connect7 as "@vercel/postgres",
+  connect7 as "@neondatabase/serverless",
+  connect8 as "@vercel/postgres",
   connect as "better-sqlite3",
   connect2 as "bun:sqlite",
   connect3 as d1,
   connect5 as mysql2,
-  connect8 as pg,
-  connect10 as "sql.js"
+  connect6 as "node:sqlite",
+  connect9 as pg,
+  connect11 as "sql.js"
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rado",
-  "version": "1.3.0-preview.2",
+  "version": "1.3.0-preview.4",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -36,6 +36,9 @@
     "format:check": "oxfmt --check .",
     "lint": "oxlint .",
     "check": "bun run format:check && bun run lint",
+    "test:mysql": "bun test --test-filter mysql",
+    "test:postgres": "bun test --test-filter postgres pg",
+    "test:sqlite": "bun test --test-filter sqlite",
     "test:bun": "bun test",
     "test:node": "node --disable-warning=ExperimentalWarning --test-force-exit --test-concurrency=1 --test-reporter=spec --experimental-transform-types --test \"**/*.test.ts\"",
     "test:deno": "deno test --node-modules-dir=false --no-check -A --unstable-ffi",