@minimalcorp/tsunagi 0.0.4 → 0.1.0

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/http/protobuf_encode.js

@@ -1,78 +0,0 @@
-import { Stmt, Batch } from "../shared/protobuf_encode.js";
-import { impossible } from "../util.js";
-export function PipelineReqBody(w, msg) {
-    if (msg.baton !== undefined) {
-        w.string(1, msg.baton);
-    }
-    for (const req of msg.requests) {
-        w.message(2, req, StreamRequest);
-    }
-}
-function StreamRequest(w, msg) {
-    if (msg.type === "close") {
-        w.message(1, msg, CloseStreamReq);
-    }
-    else if (msg.type === "execute") {
-        w.message(2, msg, ExecuteStreamReq);
-    }
-    else if (msg.type === "batch") {
-        w.message(3, msg, BatchStreamReq);
-    }
-    else if (msg.type === "sequence") {
-        w.message(4, msg, SequenceStreamReq);
-    }
-    else if (msg.type === "describe") {
-        w.message(5, msg, DescribeStreamReq);
-    }
-    else if (msg.type === "store_sql") {
-        w.message(6, msg, StoreSqlStreamReq);
-    }
-    else if (msg.type === "close_sql") {
-        w.message(7, msg, CloseSqlStreamReq);
-    }
-    else if (msg.type === "get_autocommit") {
-        w.message(8, msg, GetAutocommitStreamReq);
-    }
-    else {
-        throw impossible(msg, "Impossible type of StreamRequest");
-    }
-}
-function CloseStreamReq(_w, _msg) {
-}
-function ExecuteStreamReq(w, msg) {
-    w.message(1, msg.stmt, Stmt);
-}
-function BatchStreamReq(w, msg) {
-    w.message(1, msg.batch, Batch);
-}
-function SequenceStreamReq(w, msg) {
-    if (msg.sql !== undefined) {
-        w.string(1, msg.sql);
-    }
-    if (msg.sqlId !== undefined) {
-        w.int32(2, msg.sqlId);
-    }
-}
-function DescribeStreamReq(w, msg) {
-    if (msg.sql !== undefined) {
-        w.string(1, msg.sql);
-    }
-    if (msg.sqlId !== undefined) {
-        w.int32(2, msg.sqlId);
-    }
-}
-function StoreSqlStreamReq(w, msg) {
-    w.int32(1, msg.sqlId);
-    w.string(2, msg.sql);
-}
-function CloseSqlStreamReq(w, msg) {
-    w.int32(1, msg.sqlId);
-}
-function GetAutocommitStreamReq(_w, _msg) {
-}
-export function CursorReqBody(w, msg) {
-    if (msg.baton !== undefined) {
-        w.string(1, msg.baton);
-    }
-    w.message(2, msg.batch, Batch);
-}

package/.next/standalone/node_modules/@prisma/adapter-libsql/node_modules/@libsql/hrana-client/lib-esm/http/stream.js

@@ -1,368 +0,0 @@
-import { Request, Headers } from "cross-fetch";
-import { ClientError, HttpServerError, ProtocolVersionError, ProtoError, ClosedError, InternalError, } from "../errors.js";
-import { readJsonObject, writeJsonObject, readProtobufMessage, writeProtobufMessage, } from "../encoding/index.js";
-import { IdAlloc } from "../id_alloc.js";
-import { Queue } from "../queue.js";
-import { queueMicrotask } from "../queue_microtask.js";
-import { errorFromProto } from "../result.js";
-import { Sql } from "../sql.js";
-import { Stream } from "../stream.js";
-import { impossible } from "../util.js";
-import { HttpCursor } from "./cursor.js";
-import { PipelineReqBody as json_PipelineReqBody } from "./json_encode.js";
-import { PipelineReqBody as protobuf_PipelineReqBody } from "./protobuf_encode.js";
-import { CursorReqBody as json_CursorReqBody } from "./json_encode.js";
-import { CursorReqBody as protobuf_CursorReqBody } from "./protobuf_encode.js";
-import { PipelineRespBody as json_PipelineRespBody } from "./json_decode.js";
-import { PipelineRespBody as protobuf_PipelineRespBody } from "./protobuf_decode.js";
-export class HttpStream extends Stream {
-    #client;
-    #baseUrl;
-    #jwt;
-    #fetch;
-    #remoteEncryptionKey;
-    #baton;
-    #queue;
-    #flushing;
-    #cursor;
-    #closing;
-    #closeQueued;
-    #closed;
-    #sqlIdAlloc;
-    /** @private */
-    constructor(client, baseUrl, jwt, customFetch, remoteEncryptionKey) {
-        super(client.intMode);
-        this.#client = client;
-        this.#baseUrl = baseUrl.toString();
-        this.#jwt = jwt;
-        this.#fetch = customFetch;
-        this.#remoteEncryptionKey = remoteEncryptionKey;
-        this.#baton = undefined;
-        this.#queue = new Queue();
-        this.#flushing = false;
-        this.#closing = false;
-        this.#closeQueued = false;
-        this.#closed = undefined;
-        this.#sqlIdAlloc = new IdAlloc();
-    }
-    /** Get the {@link HttpClient} object that this stream belongs to. */
-    client() {
-        return this.#client;
-    }
-    /** @private */
-    _sqlOwner() {
-        return this;
-    }
-    /** Cache a SQL text on the server. */
-    storeSql(sql) {
-        const sqlId = this.#sqlIdAlloc.alloc();
-        this.#sendStreamRequest({ type: "store_sql", sqlId, sql }).then(() => undefined, (error) => this._setClosed(error));
-        return new Sql(this, sqlId);
-    }
-    /** @private */
-    _closeSql(sqlId) {
-        if (this.#closed !== undefined) {
-            return;
-        }
-        this.#sendStreamRequest({ type: "close_sql", sqlId }).then(() => this.#sqlIdAlloc.free(sqlId), (error) => this._setClosed(error));
-    }
-    /** @private */
-    _execute(stmt) {
-        return this.#sendStreamRequest({ type: "execute", stmt }).then((response) => {
-            return response.result;
-        });
-    }
-    /** @private */
-    _batch(batch) {
-        return this.#sendStreamRequest({ type: "batch", batch }).then((response) => {
-            return response.result;
-        });
-    }
-    /** @private */
-    _describe(protoSql) {
-        return this.#sendStreamRequest({
-            type: "describe",
-            sql: protoSql.sql,
-            sqlId: protoSql.sqlId
-        }).then((response) => {
-            return response.result;
-        });
-    }
-    /** @private */
-    _sequence(protoSql) {
-        return this.#sendStreamRequest({
-            type: "sequence",
-            sql: protoSql.sql,
-            sqlId: protoSql.sqlId,
-        }).then((_response) => {
-            return undefined;
-        });
-    }
-    /** Check whether the SQL connection underlying this stream is in autocommit state (i.e., outside of an
-     * explicit transaction). This requires protocol version 3 or higher.
-     */
-    getAutocommit() {
-        this.#client._ensureVersion(3, "getAutocommit()");
-        return this.#sendStreamRequest({
-            type: "get_autocommit",
-        }).then((response) => {
-            return response.isAutocommit;
-        });
-    }
-    #sendStreamRequest(request) {
-        return new Promise((responseCallback, errorCallback) => {
-            this.#pushToQueue({ type: "pipeline", request, responseCallback, errorCallback });
-        });
-    }
-    /** @private */
-    _openCursor(batch) {
-        return new Promise((cursorCallback, errorCallback) => {
-            this.#pushToQueue({ type: "cursor", batch, cursorCallback, errorCallback });
-        });
-    }
-    /** @private */
-    _cursorClosed(cursor) {
-        if (cursor !== this.#cursor) {
-            throw new InternalError("Cursor was closed, but it was not associated with the stream");
-        }
-        this.#cursor = undefined;
-        queueMicrotask(() => this.#flushQueue());
-    }
-    /** Immediately close the stream. */
-    close() {
-        this._setClosed(new ClientError("Stream was manually closed"));
-    }
-    /** Gracefully close the stream. */
-    closeGracefully() {
-        this.#closing = true;
-        queueMicrotask(() => this.#flushQueue());
-    }
-    /** True if the stream is closed. */
-    get closed() {
-        return this.#closed !== undefined || this.#closing;
-    }
-    /** @private */
-    _setClosed(error) {
-        if (this.#closed !== undefined) {
-            return;
-        }
-        this.#closed = error;
-        if (this.#cursor !== undefined) {
-            this.#cursor._setClosed(error);
-        }
-        this.#client._streamClosed(this);
-        for (;;) {
-            const entry = this.#queue.shift();
-            if (entry !== undefined) {
-                entry.errorCallback(error);
-            }
-            else {
-                break;
-            }
-        }
-        if ((this.#baton !== undefined || this.#flushing) && !this.#closeQueued) {
-            this.#queue.push({
-                type: "pipeline",
-                request: { type: "close" },
-                responseCallback: () => undefined,
-                errorCallback: () => undefined,
-            });
-            this.#closeQueued = true;
-            queueMicrotask(() => this.#flushQueue());
-        }
-    }
-    #pushToQueue(entry) {
-        if (this.#closed !== undefined) {
-            throw new ClosedError("Stream is closed", this.#closed);
-        }
-        else if (this.#closing) {
-            throw new ClosedError("Stream is closing", undefined);
-        }
-        else {
-            this.#queue.push(entry);
-            queueMicrotask(() => this.#flushQueue());
-        }
-    }
-    #flushQueue() {
-        if (this.#flushing || this.#cursor !== undefined) {
-            return;
-        }
-        if (this.#closing && this.#queue.length === 0) {
-            this._setClosed(new ClientError("Stream was gracefully closed"));
-            return;
-        }
-        const endpoint = this.#client._endpoint;
-        if (endpoint === undefined) {
-            this.#client._endpointPromise.then(() => this.#flushQueue(), (error) => this._setClosed(error));
-            return;
-        }
-        const firstEntry = this.#queue.shift();
-        if (firstEntry === undefined) {
-            return;
-        }
-        else if (firstEntry.type === "pipeline") {
-            const pipeline = [firstEntry];
-            for (;;) {
-                const entry = this.#queue.first();
-                if (entry !== undefined && entry.type === "pipeline") {
-                    pipeline.push(entry);
-                    this.#queue.shift();
-                }
-                else if (entry === undefined && this.#closing && !this.#closeQueued) {
-                    pipeline.push({
-                        type: "pipeline",
-                        request: { type: "close" },
-                        responseCallback: () => undefined,
-                        errorCallback: () => undefined,
-                    });
-                    this.#closeQueued = true;
-                    break;
-                }
-                else {
-                    break;
-                }
-            }
-            this.#flushPipeline(endpoint, pipeline);
-        }
-        else if (firstEntry.type === "cursor") {
-            this.#flushCursor(endpoint, firstEntry);
-        }
-        else {
-            throw impossible(firstEntry, "Impossible type of QueueEntry");
-        }
-    }
-    #flushPipeline(endpoint, pipeline) {
-        this.#flush(() => this.#createPipelineRequest(pipeline, endpoint), (resp) => decodePipelineResponse(resp, endpoint.encoding), (respBody) => respBody.baton, (respBody) => respBody.baseUrl, (respBody) => handlePipelineResponse(pipeline, respBody), (error) => pipeline.forEach((entry) => entry.errorCallback(error)));
-    }
-    #flushCursor(endpoint, entry) {
-        const cursor = new HttpCursor(this, endpoint.encoding);
-        this.#cursor = cursor;
-        this.#flush(() => this.#createCursorRequest(entry, endpoint), (resp) => cursor.open(resp), (respBody) => respBody.baton, (respBody) => respBody.baseUrl, (_respBody) => entry.cursorCallback(cursor), (error) => entry.errorCallback(error));
-    }
-    #flush(createRequest, decodeResponse, getBaton, getBaseUrl, handleResponse, handleError) {
-        let promise;
-        try {
-            const request = createRequest();
-            const fetch = this.#fetch;
-            promise = fetch(request);
-        }
-        catch (error) {
-            promise = Promise.reject(error);
-        }
-        this.#flushing = true;
-        promise.then((resp) => {
-            if (!resp.ok) {
-                return errorFromResponse(resp).then((error) => {
-                    throw error;
-                });
-            }
-            return decodeResponse(resp);
-        }).then((r) => {
-            this.#baton = getBaton(r);
-            this.#baseUrl = getBaseUrl(r) ?? this.#baseUrl;
-            handleResponse(r);
-        }).catch((error) => {
-            this._setClosed(error);
-            handleError(error);
-        }).finally(() => {
-            this.#flushing = false;
-            this.#flushQueue();
-        });
-    }
-    #createPipelineRequest(pipeline, endpoint) {
-        return this.#createRequest(new URL(endpoint.pipelinePath, this.#baseUrl), {
-            baton: this.#baton,
-            requests: pipeline.map((entry) => entry.request),
-        }, endpoint.encoding, json_PipelineReqBody, protobuf_PipelineReqBody);
-    }
-    #createCursorRequest(entry, endpoint) {
-        if (endpoint.cursorPath === undefined) {
-            throw new ProtocolVersionError("Cursors are supported only on protocol version 3 and higher, " +
-                `but the HTTP server only supports version ${endpoint.version}.`);
-        }
-        return this.#createRequest(new URL(endpoint.cursorPath, this.#baseUrl), {
-            baton: this.#baton,
-            batch: entry.batch,
-        }, endpoint.encoding, json_CursorReqBody, protobuf_CursorReqBody);
-    }
-    #createRequest(url, reqBody, encoding, jsonFun, protobufFun) {
-        let bodyData;
-        let contentType;
-        if (encoding === "json") {
-            bodyData = writeJsonObject(reqBody, jsonFun);
-            contentType = "application/json";
-        }
-        else if (encoding === "protobuf") {
-            bodyData = writeProtobufMessage(reqBody, protobufFun);
-            contentType = "application/x-protobuf";
-        }
-        else {
-            throw impossible(encoding, "Impossible encoding");
-        }
-        const headers = new Headers();
-        headers.set("content-type", contentType);
-        if (this.#jwt !== undefined) {
-            headers.set("authorization", `Bearer ${this.#jwt}`);
-        }
-        if (this.#remoteEncryptionKey !== undefined) {
-            headers.set("x-turso-encryption-key", this.#remoteEncryptionKey);
-        }
-        return new Request(url.toString(), { method: "POST", headers, body: bodyData });
-    }
-}
-function handlePipelineResponse(pipeline, respBody) {
-    if (respBody.results.length !== pipeline.length) {
-        throw new ProtoError("Server returned unexpected number of pipeline results");
-    }
-    for (let i = 0; i < pipeline.length; ++i) {
-        const result = respBody.results[i];
-        const entry = pipeline[i];
-        if (result.type === "ok") {
-            if (result.response.type !== entry.request.type) {
-                throw new ProtoError("Received unexpected type of response");
-            }
-            entry.responseCallback(result.response);
-        }
-        else if (result.type === "error") {
-            entry.errorCallback(errorFromProto(result.error));
-        }
-        else if (result.type === "none") {
-            throw new ProtoError("Received unrecognized type of StreamResult");
-        }
-        else {
-            throw impossible(result, "Received impossible type of StreamResult");
-        }
-    }
-}
-async function decodePipelineResponse(resp, encoding) {
-    if (encoding === "json") {
-        const respJson = await resp.json();
-        return readJsonObject(respJson, json_PipelineRespBody);
-    }
-    if (encoding === "protobuf") {
-        const respData = await resp.arrayBuffer();
-        return readProtobufMessage(new Uint8Array(respData), protobuf_PipelineRespBody);
-    }
-    await resp.body?.cancel();
-    throw impossible(encoding, "Impossible encoding");
-}
-async function errorFromResponse(resp) {
-    const respType = resp.headers.get("content-type") ?? "text/plain";
-    let message = `Server returned HTTP status ${resp.status}`;
-    if (respType === "application/json") {
-        const respBody = await resp.json();
-        if ("message" in respBody) {
-            return errorFromProto(respBody);
-        }
-        return new HttpServerError(message, resp.status);
-    }
-    if (respType === "text/plain") {
-        const respBody = (await resp.text()).trim();
-        if (respBody !== "") {
-            message += `: ${respBody}`;
-        }
-        return new HttpServerError(message, resp.status);
-    }
-    await resp.body?.cancel();
-    return new HttpServerError(message, resp.status);
-}

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

@@ -1,47 +0,0 @@
-import { InternalError } from "./errors.js";
-// An allocator of non-negative integer ids.
-//
-// This clever data structure has these "ideal" properties:
-// - It consumes memory proportional to the number of used ids (which is optimal).
-// - All operations are O(1) time.
-// - The allocated ids are small (with a slight modification, we could always provide the smallest possible
-// id).
-export class IdAlloc {
-    // Set of all allocated ids
-    #usedIds;
-    // Set of all free ids lower than `#usedIds.size`
-    #freeIds;
-    constructor() {
-        this.#usedIds = new Set();
-        this.#freeIds = new Set();
-    }
-    // Returns an id that was free, and marks it as used.
-    alloc() {
-        // this "loop" is just a way to pick an arbitrary element from the `#freeIds` set
-        for (const freeId of this.#freeIds) {
-            this.#freeIds.delete(freeId);
-            this.#usedIds.add(freeId);
-            // maintain the invariant of `#freeIds`
-            if (!this.#usedIds.has(this.#usedIds.size - 1)) {
-                this.#freeIds.add(this.#usedIds.size - 1);
-            }
-            return freeId;
-        }
-        // the `#freeIds` set is empty, so there are no free ids lower than `#usedIds.size`
-        // this means that `#usedIds` is a set that contains all numbers from 0 to `#usedIds.size - 1`,
-        // so `#usedIds.size` is free
-        const freeId = this.#usedIds.size;
-        this.#usedIds.add(freeId);
-        return freeId;
-    }
-    free(id) {
-        if (!this.#usedIds.delete(id)) {
-            throw new InternalError("Freeing an id that is not allocated");
-        }
-        // maintain the invariant of `#freeIds`
-        this.#freeIds.delete(this.#usedIds.size);
-        if (id < this.#usedIds.size) {
-            this.#freeIds.add(id);
-        }
-    }
-}

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

@@ -1,42 +0,0 @@
-import { WebSocket } from "@libsql/isomorphic-ws";
-import { subprotocolsV2, subprotocolsV3 } from "./ws/client.js";
-import { WebSocketUnsupportedError } from "./errors.js";
-import { HttpClient } from "./http/client.js";
-import { WsClient } from "./ws/client.js";
-export { WebSocket } from "@libsql/isomorphic-ws";
-export { fetch, Request, Headers } from "cross-fetch";
-export { Client } from "./client.js";
-export * from "./errors.js";
-export { Batch, BatchStep, BatchCond } from "./batch.js";
-export { parseLibsqlUrl } from "./libsql_url.js";
-export { Sql } from "./sql.js";
-export { Stmt } from "./stmt.js";
-export { Stream } from "./stream.js";
-export { HttpClient } from "./http/client.js";
-export { HttpStream } from "./http/stream.js";
-export { WsClient } from "./ws/client.js";
-export { WsStream } from "./ws/stream.js";
-/** Open a Hrana client over WebSocket connected to the given `url`. */
-export function openWs(url, jwt, protocolVersion = 2) {
-    if (typeof WebSocket === "undefined") {
-        throw new WebSocketUnsupportedError("WebSockets are not supported in this environment");
-    }
-    var subprotocols = undefined;
-    if (protocolVersion == 3) {
-        subprotocols = Array.from(subprotocolsV3.keys());
-    }
-    else {
-        subprotocols = Array.from(subprotocolsV2.keys());
-    }
-    const socket = new WebSocket(url, subprotocols);
-    return new WsClient(socket, jwt);
-}
-/** Open a Hrana client over HTTP connected to the given `url`.
- *
- * If the `customFetch` argument is passed and not `undefined`, it is used in place of the `fetch` function
- * from `cross-fetch`. This function is always called with a `Request` object from
- * `cross-fetch`.
- */
-export function openHttp(url, jwt, customFetch, remoteEncryptionKey, protocolVersion = 2) {
-    return new HttpClient(url instanceof URL ? url : new URL(url), jwt, customFetch, remoteEncryptionKey, protocolVersion);
-}

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

@@ -1,75 +0,0 @@
-import { LibsqlUrlParseError } from "./errors.js";
-;
-/** Parses a URL compatible with the libsql client (`@libsql/client`). This URL may have the "libsql:" scheme
- * and may contain query parameters. */
-export function parseLibsqlUrl(urlStr) {
-    const url = new URL(urlStr);
-    let authToken = undefined;
-    let tls = undefined;
-    for (const [key, value] of url.searchParams.entries()) {
-        if (key === "authToken") {
-            authToken = value;
-        }
-        else if (key === "tls") {
-            if (value === "0") {
-                tls = false;
-            }
-            else if (value === "1") {
-                tls = true;
-            }
-            else {
-                throw new LibsqlUrlParseError(`Unknown value for the "tls" query argument: ${JSON.stringify(value)}`);
-            }
-        }
-        else {
-            throw new LibsqlUrlParseError(`Unknown URL query argument ${JSON.stringify(key)}`);
-        }
-    }
-    let hranaWsScheme;
-    let hranaHttpScheme;
-    if ((url.protocol === "http:" || url.protocol === "ws:") && (tls === true)) {
-        throw new LibsqlUrlParseError(`A ${JSON.stringify(url.protocol)} URL cannot opt into TLS using ?tls=1`);
-    }
-    else if ((url.protocol === "https:" || url.protocol === "wss:") && (tls === false)) {
-        throw new LibsqlUrlParseError(`A ${JSON.stringify(url.protocol)} URL cannot opt out of TLS using ?tls=0`);
-    }
-    if (url.protocol === "http:" || url.protocol === "https:") {
-        hranaHttpScheme = url.protocol;
-    }
-    else if (url.protocol === "ws:" || url.protocol === "wss:") {
-        hranaWsScheme = url.protocol;
-    }
-    else if (url.protocol === "libsql:") {
-        if (tls === false) {
-            if (!url.port) {
-                throw new LibsqlUrlParseError(`A "libsql:" URL with ?tls=0 must specify an explicit port`);
-            }
-            hranaHttpScheme = "http:";
-            hranaWsScheme = "ws:";
-        }
-        else {
-            hranaHttpScheme = "https:";
-            hranaWsScheme = "wss:";
-        }
-    }
-    else {
-        throw new LibsqlUrlParseError(`This client does not support ${JSON.stringify(url.protocol)} URLs. ` +
-            'Please use a "libsql:", "ws:", "wss:", "http:" or "https:" URL instead.');
-    }
-    if (url.username || url.password) {
-        throw new LibsqlUrlParseError("This client does not support HTTP Basic authentication with a username and password. " +
-            'You can authenticate using a token passed in the "authToken" URL query parameter.');
-    }
-    if (url.hash) {
-        throw new LibsqlUrlParseError("URL fragments are not supported");
-    }
-    let hranaPath = url.pathname;
-    if (hranaPath === "/") {
-        hranaPath = "";
-    }
-    const hranaWsUrl = hranaWsScheme !== undefined
-        ? `${hranaWsScheme}//${url.host}${hranaPath}` : undefined;
-    const hranaHttpUrl = hranaHttpScheme !== undefined
-        ? `${hranaHttpScheme}//${url.host}${hranaPath}` : undefined;
-    return { hranaWsUrl, hranaHttpUrl, authToken };
-}

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

@@ -1,26 +0,0 @@
-export class Queue {
-    #pushStack;
-    #shiftStack;
-    constructor() {
-        this.#pushStack = [];
-        this.#shiftStack = [];
-    }
-    get length() {
-        return this.#pushStack.length + this.#shiftStack.length;
-    }
-    push(elem) {
-        this.#pushStack.push(elem);
-    }
-    shift() {
-        if (this.#shiftStack.length === 0 && this.#pushStack.length > 0) {
-            this.#shiftStack = this.#pushStack.reverse();
-            this.#pushStack = [];
-        }
-        return this.#shiftStack.pop();
-    }
-    first() {
-        return this.#shiftStack.length !== 0
-            ? this.#shiftStack[this.#shiftStack.length - 1]
-            : this.#pushStack[0];
-    }
-}

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

@@ -1,13 +0,0 @@
-// queueMicrotask() ponyfill
-// https://github.com/libsql/libsql-client-ts/issues/47
-let _queueMicrotask;
-if (typeof queueMicrotask !== "undefined") {
-    _queueMicrotask = queueMicrotask;
-}
-else {
-    const resolved = Promise.resolve();
-    _queueMicrotask = (callback) => {
-        resolved.then(callback);
-    };
-}
-export { _queueMicrotask as queueMicrotask };