@minimalcorp/tsunagi 0.0.4 → 0.0.6

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/client/lib-cjs/hrana.js

@@ -1,372 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapHranaError = exports.resultSetFromHrana = exports.stmtToHrana = exports.executeHranaBatch = exports.HranaTransaction = void 0;
-const hrana = __importStar(require("@libsql/hrana-client"));
-const api_1 = require("@libsql/core/api");
-const util_1 = require("@libsql/core/util");
-class HranaTransaction {
-    #mode;
-    #version;
-    // Promise that is resolved when the BEGIN statement completes, or `undefined` if we haven't executed the
-    // BEGIN statement yet.
-    #started;
-    /** @private */
-    constructor(mode, version) {
-        this.#mode = mode;
-        this.#version = version;
-        this.#started = undefined;
-    }
-    execute(stmt) {
-        return this.batch([stmt]).then((results) => results[0]);
-    }
-    async batch(stmts) {
-        const stream = this._getStream();
-        if (stream.closed) {
-            throw new api_1.LibsqlError("Cannot execute statements because the transaction is closed", "TRANSACTION_CLOSED");
-        }
-        try {
-            const hranaStmts = stmts.map(stmtToHrana);
-            let rowsPromises;
-            if (this.#started === undefined) {
-                // The transaction hasn't started yet, so we need to send the BEGIN statement in a batch with
-                // `hranaStmts`.
-                this._getSqlCache().apply(hranaStmts);
-                const batch = stream.batch(this.#version >= 3);
-                const beginStep = batch.step();
-                const beginPromise = beginStep.run((0, util_1.transactionModeToBegin)(this.#mode));
-                // Execute the `hranaStmts` only if the BEGIN succeeded, to make sure that we don't execute it
-                // outside of a transaction.
-                let lastStep = beginStep;
-                rowsPromises = hranaStmts.map((hranaStmt) => {
-                    const stmtStep = batch
-                        .step()
-                        .condition(hrana.BatchCond.ok(lastStep));
-                    if (this.#version >= 3) {
-                        // If the Hrana version supports it, make sure that we are still in a transaction
-                        stmtStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
-                    }
-                    const rowsPromise = stmtStep.query(hranaStmt);
-                    rowsPromise.catch(() => undefined); // silence Node warning
-                    lastStep = stmtStep;
-                    return rowsPromise;
-                });
-                // `this.#started` is resolved successfully only if the batch and the BEGIN statement inside
-                // of the batch are both successful.
-                this.#started = batch
-                    .execute()
-                    .then(() => beginPromise)
-                    .then(() => undefined);
-                try {
-                    await this.#started;
-                }
-                catch (e) {
-                    // If the BEGIN failed, the transaction is unusable and we must close it. However, if the
-                    // BEGIN suceeds and `hranaStmts` fail, the transaction is _not_ closed.
-                    this.close();
-                    throw e;
-                }
-            }
-            else {
-                if (this.#version < 3) {
-                    // The transaction has started, so we must wait until the BEGIN statement completed to make
-                    // sure that we don't execute `hranaStmts` outside of a transaction.
-                    await this.#started;
-                }
-                else {
-                    // The transaction has started, but we will use `hrana.BatchCond.isAutocommit()` to make
-                    // sure that we don't execute `hranaStmts` outside of a transaction, so we don't have to
-                    // wait for `this.#started`
-                }
-                this._getSqlCache().apply(hranaStmts);
-                const batch = stream.batch(this.#version >= 3);
-                let lastStep = undefined;
-                rowsPromises = hranaStmts.map((hranaStmt) => {
-                    const stmtStep = batch.step();
-                    if (lastStep !== undefined) {
-                        stmtStep.condition(hrana.BatchCond.ok(lastStep));
-                    }
-                    if (this.#version >= 3) {
-                        stmtStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
-                    }
-                    const rowsPromise = stmtStep.query(hranaStmt);
-                    rowsPromise.catch(() => undefined); // silence Node warning
-                    lastStep = stmtStep;
-                    return rowsPromise;
-                });
-                await batch.execute();
-            }
-            const resultSets = [];
-            for (let i = 0; i < rowsPromises.length; i++) {
-                try {
-                    const rows = await rowsPromises[i];
-                    if (rows === undefined) {
-                        throw new api_1.LibsqlBatchError("Statement in a transaction was not executed, " +
-                            "probably because the transaction has been rolled back", i, "TRANSACTION_CLOSED");
-                    }
-                    resultSets.push(resultSetFromHrana(rows));
-                }
-                catch (e) {
-                    if (e instanceof api_1.LibsqlBatchError) {
-                        throw e;
-                    }
-                    // Map hrana errors to LibsqlError first, then wrap in LibsqlBatchError
-                    const mappedError = mapHranaError(e);
-                    if (mappedError instanceof api_1.LibsqlError) {
-                        throw new api_1.LibsqlBatchError(mappedError.message, i, mappedError.code, mappedError.extendedCode, mappedError.rawCode, mappedError.cause instanceof Error
-                            ? mappedError.cause
-                            : undefined);
-                    }
-                    throw mappedError;
-                }
-            }
-            return resultSets;
-        }
-        catch (e) {
-            throw mapHranaError(e);
-        }
-    }
-    async executeMultiple(sql) {
-        const stream = this._getStream();
-        if (stream.closed) {
-            throw new api_1.LibsqlError("Cannot execute statements because the transaction is closed", "TRANSACTION_CLOSED");
-        }
-        try {
-            if (this.#started === undefined) {
-                // If the transaction hasn't started yet, start it now
-                this.#started = stream
-                    .run((0, util_1.transactionModeToBegin)(this.#mode))
-                    .then(() => undefined);
-                try {
-                    await this.#started;
-                }
-                catch (e) {
-                    this.close();
-                    throw e;
-                }
-            }
-            else {
-                // Wait until the transaction has started
-                await this.#started;
-            }
-            await stream.sequence(sql);
-        }
-        catch (e) {
-            throw mapHranaError(e);
-        }
-    }
-    async rollback() {
-        try {
-            const stream = this._getStream();
-            if (stream.closed) {
-                return;
-            }
-            if (this.#started !== undefined) {
-                // We don't have to wait for the BEGIN statement to complete. If the BEGIN fails, we will
-                // execute a ROLLBACK outside of an active transaction, which should be harmless.
-            }
-            else {
-                // We did nothing in the transaction, so there is nothing to rollback.
-                return;
-            }
-            // Pipeline the ROLLBACK statement and the stream close.
-            const promise = stream.run("ROLLBACK").catch((e) => {
-                throw mapHranaError(e);
-            });
-            stream.closeGracefully();
-            await promise;
-        }
-        catch (e) {
-            throw mapHranaError(e);
-        }
-        finally {
-            // `this.close()` may close the `hrana.Client`, which aborts all pending stream requests, so we
-            // must call it _after_ we receive the ROLLBACK response.
-            // Also note that the current stream should already be closed, but we need to call `this.close()`
-            // anyway, because it may need to do more cleanup.
-            this.close();
-        }
-    }
-    async commit() {
-        // (this method is analogous to `rollback()`)
-        try {
-            const stream = this._getStream();
-            if (stream.closed) {
-                throw new api_1.LibsqlError("Cannot commit the transaction because it is already closed", "TRANSACTION_CLOSED");
-            }
-            if (this.#started !== undefined) {
-                // Make sure to execute the COMMIT only if the BEGIN was successful.
-                await this.#started;
-            }
-            else {
-                return;
-            }
-            const promise = stream.run("COMMIT").catch((e) => {
-                throw mapHranaError(e);
-            });
-            stream.closeGracefully();
-            await promise;
-        }
-        catch (e) {
-            throw mapHranaError(e);
-        }
-        finally {
-            this.close();
-        }
-    }
-}
-exports.HranaTransaction = HranaTransaction;
-async function executeHranaBatch(mode, version, batch, hranaStmts, disableForeignKeys = false) {
-    if (disableForeignKeys) {
-        batch.step().run("PRAGMA foreign_keys=off");
-    }
-    const beginStep = batch.step();
-    const beginPromise = beginStep.run((0, util_1.transactionModeToBegin)(mode));
-    let lastStep = beginStep;
-    const stmtPromises = hranaStmts.map((hranaStmt) => {
-        const stmtStep = batch.step().condition(hrana.BatchCond.ok(lastStep));
-        if (version >= 3) {
-            stmtStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
-        }
-        const stmtPromise = stmtStep.query(hranaStmt);
-        lastStep = stmtStep;
-        return stmtPromise;
-    });
-    const commitStep = batch.step().condition(hrana.BatchCond.ok(lastStep));
-    if (version >= 3) {
-        commitStep.condition(hrana.BatchCond.not(hrana.BatchCond.isAutocommit(batch)));
-    }
-    const commitPromise = commitStep.run("COMMIT");
-    const rollbackStep = batch
-        .step()
-        .condition(hrana.BatchCond.not(hrana.BatchCond.ok(commitStep)));
-    rollbackStep.run("ROLLBACK").catch((_) => undefined);
-    if (disableForeignKeys) {
-        batch.step().run("PRAGMA foreign_keys=on");
-    }
-    await batch.execute();
-    const resultSets = [];
-    await beginPromise;
-    for (let i = 0; i < stmtPromises.length; i++) {
-        try {
-            const hranaRows = await stmtPromises[i];
-            if (hranaRows === undefined) {
-                throw new api_1.LibsqlBatchError("Statement in a batch was not executed, probably because the transaction has been rolled back", i, "TRANSACTION_CLOSED");
-            }
-            resultSets.push(resultSetFromHrana(hranaRows));
-        }
-        catch (e) {
-            if (e instanceof api_1.LibsqlBatchError) {
-                throw e;
-            }
-            // Map hrana errors to LibsqlError first, then wrap in LibsqlBatchError
-            const mappedError = mapHranaError(e);
-            if (mappedError instanceof api_1.LibsqlError) {
-                throw new api_1.LibsqlBatchError(mappedError.message, i, mappedError.code, mappedError.extendedCode, mappedError.rawCode, mappedError.cause instanceof Error
-                    ? mappedError.cause
-                    : undefined);
-            }
-            throw mappedError;
-        }
-    }
-    await commitPromise;
-    return resultSets;
-}
-exports.executeHranaBatch = executeHranaBatch;
-function stmtToHrana(stmt) {
-    let sql;
-    let args;
-    if (Array.isArray(stmt)) {
-        [sql, args] = stmt;
-    }
-    else if (typeof stmt === "string") {
-        sql = stmt;
-    }
-    else {
-        sql = stmt.sql;
-        args = stmt.args;
-    }
-    const hranaStmt = new hrana.Stmt(sql);
-    if (args) {
-        if (Array.isArray(args)) {
-            hranaStmt.bindIndexes(args);
-        }
-        else {
-            for (const [key, value] of Object.entries(args)) {
-                hranaStmt.bindName(key, value);
-            }
-        }
-    }
-    return hranaStmt;
-}
-exports.stmtToHrana = stmtToHrana;
-function resultSetFromHrana(hranaRows) {
-    const columns = hranaRows.columnNames.map((c) => c ?? "");
-    const columnTypes = hranaRows.columnDecltypes.map((c) => c ?? "");
-    const rows = hranaRows.rows;
-    const rowsAffected = hranaRows.affectedRowCount;
-    const lastInsertRowid = hranaRows.lastInsertRowid !== undefined
-        ? hranaRows.lastInsertRowid
-        : undefined;
-    return new util_1.ResultSetImpl(columns, columnTypes, rows, rowsAffected, lastInsertRowid);
-}
-exports.resultSetFromHrana = resultSetFromHrana;
-function mapHranaError(e) {
-    if (e instanceof hrana.ClientError) {
-        const code = mapHranaErrorCode(e);
-        // TODO: Parse extendedCode once the SQL over HTTP protocol supports it
-        return new api_1.LibsqlError(e.message, code, undefined, undefined, e);
-    }
-    return e;
-}
-exports.mapHranaError = mapHranaError;
-function mapHranaErrorCode(e) {
-    if (e instanceof hrana.ResponseError && e.code !== undefined) {
-        return e.code;
-    }
-    else if (e instanceof hrana.ProtoError) {
-        return "HRANA_PROTO_ERROR";
-    }
-    else if (e instanceof hrana.ClosedError) {
-        return e.cause instanceof hrana.ClientError
-            ? mapHranaErrorCode(e.cause)
-            : "HRANA_CLOSED_ERROR";
-    }
-    else if (e instanceof hrana.WebSocketError) {
-        return "HRANA_WEBSOCKET_ERROR";
-    }
-    else if (e instanceof hrana.HttpServerError) {
-        return "SERVER_ERROR";
-    }
-    else if (e instanceof hrana.ProtocolVersionError) {
-        return "PROTOCOL_VERSION_ERROR";
-    }
-    else if (e instanceof hrana.InternalError) {
-        return "INTERNAL_ERROR";
-    }
-    else {
-        return "UNKNOWN";
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/client/lib-cjs/http.js

@@ -1,268 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpTransaction = exports.HttpClient = exports._createClient = exports.createClient = void 0;
-const hrana = __importStar(require("@libsql/hrana-client"));
-const api_1 = require("@libsql/core/api");
-const config_1 = require("@libsql/core/config");
-const hrana_js_1 = require("./hrana.js");
-const sql_cache_js_1 = require("./sql_cache.js");
-const uri_1 = require("@libsql/core/uri");
-const util_1 = require("@libsql/core/util");
-const promise_limit_1 = __importDefault(require("promise-limit"));
-__exportStar(require("@libsql/core/api"), exports);
-function createClient(config) {
-    return _createClient((0, config_1.expandConfig)(config, true));
-}
-exports.createClient = createClient;
-/** @private */
-function _createClient(config) {
-    if (config.scheme !== "https" && config.scheme !== "http") {
-        throw new api_1.LibsqlError('The HTTP client supports only "libsql:", "https:" and "http:" URLs, ' +
-            `got ${JSON.stringify(config.scheme + ":")}. For more information, please read ${util_1.supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
-    }
-    if (config.encryptionKey !== undefined) {
-        throw new api_1.LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
-    }
-    if (config.scheme === "http" && config.tls) {
-        throw new api_1.LibsqlError(`A "http:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
-    }
-    else if (config.scheme === "https" && !config.tls) {
-        throw new api_1.LibsqlError(`A "https:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
-    }
-    const url = (0, uri_1.encodeBaseUrl)(config.scheme, config.authority, config.path);
-    return new HttpClient(url, config.authToken, config.intMode, config.fetch, config.concurrency, config.remoteEncryptionKey);
-}
-exports._createClient = _createClient;
-const sqlCacheCapacity = 30;
-class HttpClient {
-    #client;
-    protocol;
-    #url;
-    #intMode;
-    #customFetch;
-    #concurrency;
-    #authToken;
-    #remoteEncryptionKey;
-    #promiseLimitFunction;
-    /** @private */
-    constructor(url, authToken, intMode, customFetch, concurrency, remoteEncryptionKey) {
-        this.#url = url;
-        this.#authToken = authToken;
-        this.#intMode = intMode;
-        this.#customFetch = customFetch;
-        this.#concurrency = concurrency;
-        this.#remoteEncryptionKey = remoteEncryptionKey;
-        this.#client = hrana.openHttp(this.#url, this.#authToken, this.#customFetch, remoteEncryptionKey);
-        this.#client.intMode = this.#intMode;
-        this.protocol = "http";
-        this.#promiseLimitFunction = (0, promise_limit_1.default)(this.#concurrency);
-    }
-    async limit(fn) {
-        return this.#promiseLimitFunction(fn);
-    }
-    async execute(stmtOrSql, args) {
-        let stmt;
-        if (typeof stmtOrSql === "string") {
-            stmt = {
-                sql: stmtOrSql,
-                args: args || [],
-            };
-        }
-        else {
-            stmt = stmtOrSql;
-        }
-        return this.limit(async () => {
-            try {
-                const hranaStmt = (0, hrana_js_1.stmtToHrana)(stmt);
-                // Pipeline all operations, so `hrana.HttpClient` can open the stream, execute the statement and
-                // close the stream in a single HTTP request.
-                let rowsPromise;
-                const stream = this.#client.openStream();
-                try {
-                    rowsPromise = stream.query(hranaStmt);
-                }
-                finally {
-                    stream.closeGracefully();
-                }
-                const rowsResult = await rowsPromise;
-                return (0, hrana_js_1.resultSetFromHrana)(rowsResult);
-            }
-            catch (e) {
-                throw (0, hrana_js_1.mapHranaError)(e);
-            }
-        });
-    }
-    async batch(stmts, mode = "deferred") {
-        return this.limit(async () => {
-            try {
-                const normalizedStmts = stmts.map((stmt) => {
-                    if (Array.isArray(stmt)) {
-                        return {
-                            sql: stmt[0],
-                            args: stmt[1] || [],
-                        };
-                    }
-                    return stmt;
-                });
-                const hranaStmts = normalizedStmts.map(hrana_js_1.stmtToHrana);
-                const version = await this.#client.getVersion();
-                // Pipeline all operations, so `hrana.HttpClient` can open the stream, execute the batch and
-                // close the stream in a single HTTP request.
-                let resultsPromise;
-                const stream = this.#client.openStream();
-                try {
-                    // It makes sense to use a SQL cache even for a single batch, because it may contain the same
-                    // statement repeated multiple times.
-                    const sqlCache = new sql_cache_js_1.SqlCache(stream, sqlCacheCapacity);
-                    sqlCache.apply(hranaStmts);
-                    // TODO: we do not use a cursor here, because it would cause three roundtrips:
-                    // 1. pipeline request to store SQL texts
-                    // 2. cursor request
-                    // 3. pipeline request to close the stream
-                    const batch = stream.batch(false);
-                    resultsPromise = (0, hrana_js_1.executeHranaBatch)(mode, version, batch, hranaStmts);
-                }
-                finally {
-                    stream.closeGracefully();
-                }
-                const results = await resultsPromise;
-                return results;
-            }
-            catch (e) {
-                throw (0, hrana_js_1.mapHranaError)(e);
-            }
-        });
-    }
-    async migrate(stmts) {
-        return this.limit(async () => {
-            try {
-                const hranaStmts = stmts.map(hrana_js_1.stmtToHrana);
-                const version = await this.#client.getVersion();
-                // Pipeline all operations, so `hrana.HttpClient` can open the stream, execute the batch and
-                // close the stream in a single HTTP request.
-                let resultsPromise;
-                const stream = this.#client.openStream();
-                try {
-                    const batch = stream.batch(false);
-                    resultsPromise = (0, hrana_js_1.executeHranaBatch)("deferred", version, batch, hranaStmts, true);
-                }
-                finally {
-                    stream.closeGracefully();
-                }
-                const results = await resultsPromise;
-                return results;
-            }
-            catch (e) {
-                throw (0, hrana_js_1.mapHranaError)(e);
-            }
-        });
-    }
-    async transaction(mode = "write") {
-        return this.limit(async () => {
-            try {
-                const version = await this.#client.getVersion();
-                return new HttpTransaction(this.#client.openStream(), mode, version);
-            }
-            catch (e) {
-                throw (0, hrana_js_1.mapHranaError)(e);
-            }
-        });
-    }
-    async executeMultiple(sql) {
-        return this.limit(async () => {
-            try {
-                // Pipeline all operations, so `hrana.HttpClient` can open the stream, execute the sequence and
-                // close the stream in a single HTTP request.
-                let promise;
-                const stream = this.#client.openStream();
-                try {
-                    promise = stream.sequence(sql);
-                }
-                finally {
-                    stream.closeGracefully();
-                }
-                await promise;
-            }
-            catch (e) {
-                throw (0, hrana_js_1.mapHranaError)(e);
-            }
-        });
-    }
-    sync() {
-        throw new api_1.LibsqlError("sync not supported in http mode", "SYNC_NOT_SUPPORTED");
-    }
-    close() {
-        this.#client.close();
-    }
-    async reconnect() {
-        try {
-            if (!this.closed) {
-                // Abort in-flight ops and free resources
-                this.#client.close();
-            }
-        }
-        finally {
-            // Recreate the underlying hrana client
-            this.#client = hrana.openHttp(this.#url, this.#authToken, this.#customFetch, this.#remoteEncryptionKey);
-            this.#client.intMode = this.#intMode;
-        }
-    }
-    get closed() {
-        return this.#client.closed;
-    }
-}
-exports.HttpClient = HttpClient;
-class HttpTransaction extends hrana_js_1.HranaTransaction {
-    #stream;
-    #sqlCache;
-    /** @private */
-    constructor(stream, mode, version) {
-        super(mode, version);
-        this.#stream = stream;
-        this.#sqlCache = new sql_cache_js_1.SqlCache(stream, sqlCacheCapacity);
-    }
-    /** @private */
-    _getStream() {
-        return this.#stream;
-    }
-    /** @private */
-    _getSqlCache() {
-        return this.#sqlCache;
-    }
-    close() {
-        this.#stream.close();
-    }
-    get closed() {
-        return this.#stream.closed;
-    }
-}
-exports.HttpTransaction = HttpTransaction;

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/client/lib-cjs/node.js

@@ -1,41 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClient = void 0;
-const config_1 = require("@libsql/core/config");
-const sqlite3_js_1 = require("./sqlite3.js");
-const ws_js_1 = require("./ws.js");
-const http_js_1 = require("./http.js");
-__exportStar(require("@libsql/core/api"), exports);
-/** Creates a {@link Client} object.
- *
- * You must pass at least an `url` in the {@link Config} object.
- */
-function createClient(config) {
-    return _createClient((0, config_1.expandConfig)(config, true));
-}
-exports.createClient = createClient;
-function _createClient(config) {
-    if (config.scheme === "wss" || config.scheme === "ws") {
-        return (0, ws_js_1._createClient)(config);
-    }
-    else if (config.scheme === "https" || config.scheme === "http") {
-        return (0, http_js_1._createClient)(config);
-    }
-    else {
-        return (0, sqlite3_js_1._createClient)(config);
-    }
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/client/lib-cjs/package.json

@@ -1,3 +0,0 @@
-{
-    "type": "commonjs"
-}