@minimalcorp/tsunagi 0.0.4 → 0.1.0

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

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stmtToProto = exports.Stmt = void 0;
-const sql_js_1 = require("./sql.js");
-const value_js_1 = require("./value.js");
-/** A statement that can be evaluated by the database. Besides the SQL text, it also contains the positional
- * and named arguments. */
-class Stmt {
-    /** The SQL statement text. */
-    sql;
-    /** @private */
-    _args;
-    /** @private */
-    _namedArgs;
-    /** Initialize the statement with given SQL text. */
-    constructor(sql) {
-        this.sql = sql;
-        this._args = [];
-        this._namedArgs = new Map();
-    }
-    /** Binds positional parameters from the given `values`. All previous positional bindings are cleared. */
-    bindIndexes(values) {
-        this._args.length = 0;
-        for (const value of values) {
-            this._args.push((0, value_js_1.valueToProto)(value));
-        }
-        return this;
-    }
-    /** Binds a parameter by a 1-based index. */
-    bindIndex(index, value) {
-        if (index !== (index | 0) || index <= 0) {
-            throw new RangeError("Index of a positional argument must be positive integer");
-        }
-        while (this._args.length < index) {
-            this._args.push(null);
-        }
-        this._args[index - 1] = (0, value_js_1.valueToProto)(value);
-        return this;
-    }
-    /** Binds a parameter by name. */
-    bindName(name, value) {
-        this._namedArgs.set(name, (0, value_js_1.valueToProto)(value));
-        return this;
-    }
-    /** Clears all bindings. */
-    unbindAll() {
-        this._args.length = 0;
-        this._namedArgs.clear();
-        return this;
-    }
-}
-exports.Stmt = Stmt;
-function stmtToProto(sqlOwner, stmt, wantRows) {
-    let inSql;
-    let args = [];
-    let namedArgs = [];
-    if (stmt instanceof Stmt) {
-        inSql = stmt.sql;
-        args = stmt._args;
-        for (const [name, value] of stmt._namedArgs.entries()) {
-            namedArgs.push({ name, value });
-        }
-    }
-    else if (Array.isArray(stmt)) {
-        inSql = stmt[0];
-        if (Array.isArray(stmt[1])) {
-            args = stmt[1].map((arg) => (0, value_js_1.valueToProto)(arg));
-        }
-        else {
-            namedArgs = Object.entries(stmt[1]).map(([name, value]) => {
-                return { name, value: (0, value_js_1.valueToProto)(value) };
-            });
-        }
-    }
-    else {
-        inSql = stmt;
-    }
-    const { sql, sqlId } = (0, sql_js_1.sqlToProto)(sqlOwner, inSql);
-    return { sql, sqlId, args, namedArgs, wantRows };
-}
-exports.stmtToProto = stmtToProto;

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

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Stream = void 0;
-const batch_js_1 = require("./batch.js");
-const describe_js_1 = require("./describe.js");
-const result_js_1 = require("./result.js");
-const sql_js_1 = require("./sql.js");
-const stmt_js_1 = require("./stmt.js");
-/** A stream for executing SQL statements (a "database connection"). */
-class Stream {
-    /** @private */
-    constructor(intMode) {
-        this.intMode = intMode;
-    }
-    /** Execute a statement and return rows. */
-    query(stmt) {
-        return this.#execute(stmt, true, result_js_1.rowsResultFromProto);
-    }
-    /** Execute a statement and return at most a single row. */
-    queryRow(stmt) {
-        return this.#execute(stmt, true, result_js_1.rowResultFromProto);
-    }
-    /** Execute a statement and return at most a single value. */
-    queryValue(stmt) {
-        return this.#execute(stmt, true, result_js_1.valueResultFromProto);
-    }
-    /** Execute a statement without returning rows. */
-    run(stmt) {
-        return this.#execute(stmt, false, result_js_1.stmtResultFromProto);
-    }
-    #execute(inStmt, wantRows, fromProto) {
-        const stmt = (0, stmt_js_1.stmtToProto)(this._sqlOwner(), inStmt, wantRows);
-        return this._execute(stmt).then((r) => fromProto(r, this.intMode));
-    }
-    /** Return a builder for creating and executing a batch.
-     *
-     * If `useCursor` is true, the batch will be executed using a Hrana cursor, which will stream results from
-     * the server to the client, which consumes less memory on the server. This requires protocol version 3 or
-     * higher.
-     */
-    batch(useCursor = false) {
-        return new batch_js_1.Batch(this, useCursor);
-    }
-    /** Parse and analyze a statement. This requires protocol version 2 or higher. */
-    describe(inSql) {
-        const protoSql = (0, sql_js_1.sqlToProto)(this._sqlOwner(), inSql);
-        return this._describe(protoSql).then(describe_js_1.describeResultFromProto);
-    }
-    /** Execute a sequence of statements separated by semicolons. This requires protocol version 2 or higher.
-     * */
-    sequence(inSql) {
-        const protoSql = (0, sql_js_1.sqlToProto)(this._sqlOwner(), inSql);
-        return this._sequence(protoSql);
-    }
-    /** Representation of integers returned from the database. See {@link IntMode}.
-     *
-     * This value affects the results of all operations on this stream.
-     */
-    intMode;
-}
-exports.Stream = Stream;

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

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.impossible = void 0;
-const errors_js_1 = require("./errors.js");
-function impossible(value, message) {
-    throw new errors_js_1.InternalError(message);
-}
-exports.impossible = impossible;

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

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.valueFromProto = exports.valueToProto = void 0;
-const errors_js_1 = require("./errors.js");
-const util_js_1 = require("./util.js");
-function valueToProto(value) {
-    if (value === null) {
-        return null;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    else if (typeof value === "number") {
-        if (!Number.isFinite(value)) {
-            throw new RangeError("Only finite numbers (not Infinity or NaN) can be passed as arguments");
-        }
-        return value;
-    }
-    else if (typeof value === "bigint") {
-        if (value < minInteger || value > maxInteger) {
-            throw new RangeError("This bigint value is too large to be represented as a 64-bit integer and passed as argument");
-        }
-        return value;
-    }
-    else if (typeof value === "boolean") {
-        return value ? 1n : 0n;
-    }
-    else if (value instanceof ArrayBuffer) {
-        return new Uint8Array(value);
-    }
-    else if (value instanceof Uint8Array) {
-        return value;
-    }
-    else if (value instanceof Date) {
-        return +value.valueOf();
-    }
-    else if (typeof value === "object") {
-        return "" + value.toString();
-    }
-    else {
-        throw new TypeError("Unsupported type of value");
-    }
-}
-exports.valueToProto = valueToProto;
-const minInteger = -9223372036854775808n;
-const maxInteger = 9223372036854775807n;
-function valueFromProto(value, intMode) {
-    if (value === null) {
-        return null;
-    }
-    else if (typeof value === "number") {
-        return value;
-    }
-    else if (typeof value === "string") {
-        return value;
-    }
-    else if (typeof value === "bigint") {
-        if (intMode === "number") {
-            const num = Number(value);
-            if (!Number.isSafeInteger(num)) {
-                throw new RangeError("Received integer which is too large to be safely represented as a JavaScript number");
-            }
-            return num;
-        }
-        else if (intMode === "bigint") {
-            return value;
-        }
-        else if (intMode === "string") {
-            return "" + value;
-        }
-        else {
-            throw new errors_js_1.MisuseError("Invalid value for IntMode");
-        }
-    }
-    else if (value instanceof Uint8Array) {
-        // TODO: we need to copy data from `Uint8Array` to return an `ArrayBuffer`. Perhaps we should add a
-        // `blobMode` parameter, similar to `intMode`, which would allow the user to choose between receiving
-        // `ArrayBuffer` (default, convenient) and `Uint8Array` (zero copy)?
-        return value.slice().buffer;
-    }
-    else if (value === undefined) {
-        throw new errors_js_1.ProtoError("Received unrecognized type of Value");
-    }
-    else {
-        throw (0, util_js_1.impossible)(value, "Impossible type of Value");
-    }
-}
-exports.valueFromProto = valueFromProto;

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

@@ -1,322 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WsClient = exports.subprotocolsV3 = exports.subprotocolsV2 = void 0;
-const client_js_1 = require("../client.js");
-const index_js_1 = require("../encoding/index.js");
-const errors_js_1 = require("../errors.js");
-const id_alloc_js_1 = require("../id_alloc.js");
-const result_js_1 = require("../result.js");
-const sql_js_1 = require("../sql.js");
-const util_js_1 = require("../util.js");
-const stream_js_1 = require("./stream.js");
-const json_encode_js_1 = require("./json_encode.js");
-const protobuf_encode_js_1 = require("./protobuf_encode.js");
-const json_decode_js_1 = require("./json_decode.js");
-const protobuf_decode_js_1 = require("./protobuf_decode.js");
-exports.subprotocolsV2 = new Map([
-    ["hrana2", { version: 2, encoding: "json" }],
-    ["hrana1", { version: 1, encoding: "json" }],
-]);
-exports.subprotocolsV3 = new Map([
-    ["hrana3-protobuf", { version: 3, encoding: "protobuf" }],
-    ["hrana3", { version: 3, encoding: "json" }],
-    ["hrana2", { version: 2, encoding: "json" }],
-    ["hrana1", { version: 1, encoding: "json" }],
-]);
-/** A client for the Hrana protocol over a WebSocket. */
-class WsClient extends client_js_1.Client {
-    #socket;
-    // List of callbacks that we queue until the socket transitions from the CONNECTING to the OPEN state.
-    #openCallbacks;
-    // Have we already transitioned from CONNECTING to OPEN and fired the callbacks in #openCallbacks?
-    #opened;
-    // Stores the error that caused us to close the client (and the socket). If we are not closed, this is
-    // `undefined`.
-    #closed;
-    // Have we received a response to our "hello" from the server?
-    #recvdHello;
-    // Subprotocol negotiated with the server. It is only available after the socket transitions to the OPEN
-    // state.
-    #subprotocol;
-    // Has the `getVersion()` function been called? This is only used to validate that the API is used
-    // correctly.
-    #getVersionCalled;
-    // A map from request id to the responses that we expect to receive from the server.
-    #responseMap;
-    // An allocator of request ids.
-    #requestIdAlloc;
-    // An allocator of stream ids.
-    /** @private */
-    _streamIdAlloc;
-    // An allocator of cursor ids.
-    /** @private */
-    _cursorIdAlloc;
-    // An allocator of SQL text ids.
-    #sqlIdAlloc;
-    /** @private */
-    constructor(socket, jwt) {
-        super();
-        this.#socket = socket;
-        this.#openCallbacks = [];
-        this.#opened = false;
-        this.#closed = undefined;
-        this.#recvdHello = false;
-        this.#subprotocol = undefined;
-        this.#getVersionCalled = false;
-        this.#responseMap = new Map();
-        this.#requestIdAlloc = new id_alloc_js_1.IdAlloc();
-        this._streamIdAlloc = new id_alloc_js_1.IdAlloc();
-        this._cursorIdAlloc = new id_alloc_js_1.IdAlloc();
-        this.#sqlIdAlloc = new id_alloc_js_1.IdAlloc();
-        this.#socket.binaryType = "arraybuffer";
-        this.#socket.addEventListener("open", () => this.#onSocketOpen());
-        this.#socket.addEventListener("close", (event) => this.#onSocketClose(event));
-        this.#socket.addEventListener("error", (event) => this.#onSocketError(event));
-        this.#socket.addEventListener("message", (event) => this.#onSocketMessage(event));
-        this.#send({ type: "hello", jwt });
-    }
-    // Send (or enqueue to send) a message to the server.
-    #send(msg) {
-        if (this.#closed !== undefined) {
-            throw new errors_js_1.InternalError("Trying to send a message on a closed client");
-        }
-        if (this.#opened) {
-            this.#sendToSocket(msg);
-        }
-        else {
-            const openCallback = () => this.#sendToSocket(msg);
-            const errorCallback = () => undefined;
-            this.#openCallbacks.push({ openCallback, errorCallback });
-        }
-    }
-    // The socket transitioned from CONNECTING to OPEN
-    #onSocketOpen() {
-        const protocol = this.#socket.protocol;
-        if (protocol === undefined) {
-            this.#setClosed(new errors_js_1.ClientError("The `WebSocket.protocol` property is undefined. This most likely means that the WebSocket " +
-                "implementation provided by the environment is broken. If you are using Miniflare 2, " +
-                "please update to Miniflare 3, which fixes this problem."));
-            return;
-        }
-        else if (protocol === "") {
-            this.#subprotocol = { version: 1, encoding: "json" };
-        }
-        else {
-            this.#subprotocol = exports.subprotocolsV3.get(protocol);
-            if (this.#subprotocol === undefined) {
-                this.#setClosed(new errors_js_1.ProtoError(`Unrecognized WebSocket subprotocol: ${JSON.stringify(protocol)}`));
-                return;
-            }
-        }
-        for (const callbacks of this.#openCallbacks) {
-            callbacks.openCallback();
-        }
-        this.#openCallbacks.length = 0;
-        this.#opened = true;
-    }
-    #sendToSocket(msg) {
-        const encoding = this.#subprotocol.encoding;
-        if (encoding === "json") {
-            const jsonMsg = (0, index_js_1.writeJsonObject)(msg, json_encode_js_1.ClientMsg);
-            this.#socket.send(jsonMsg);
-        }
-        else if (encoding === "protobuf") {
-            const protobufMsg = (0, index_js_1.writeProtobufMessage)(msg, protobuf_encode_js_1.ClientMsg);
-            this.#socket.send(protobufMsg);
-        }
-        else {
-            throw (0, util_js_1.impossible)(encoding, "Impossible encoding");
-        }
-    }
-    /** Get the protocol version negotiated with the server, possibly waiting until the socket is open. */
-    getVersion() {
-        return new Promise((versionCallback, errorCallback) => {
-            this.#getVersionCalled = true;
-            if (this.#closed !== undefined) {
-                errorCallback(this.#closed);
-            }
-            else if (!this.#opened) {
-                const openCallback = () => versionCallback(this.#subprotocol.version);
-                this.#openCallbacks.push({ openCallback, errorCallback });
-            }
-            else {
-                versionCallback(this.#subprotocol.version);
-            }
-        });
-    }
-    // Make sure that the negotiated version is at least `minVersion`.
-    /** @private */
-    _ensureVersion(minVersion, feature) {
-        if (this.#subprotocol === undefined || !this.#getVersionCalled) {
-            throw new errors_js_1.ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, ` +
-                "but the version supported by the WebSocket server is not yet known. " +
-                "Use Client.getVersion() to wait until the version is available.");
-        }
-        else if (this.#subprotocol.version < minVersion) {
-            throw new errors_js_1.ProtocolVersionError(`${feature} is supported on protocol version ${minVersion} and higher, ` +
-                `but the WebSocket server only supports version ${this.#subprotocol.version}`);
-        }
-    }
-    // Send a request to the server and invoke a callback when we get the response.
-    /** @private */
-    _sendRequest(request, callbacks) {
-        if (this.#closed !== undefined) {
-            callbacks.errorCallback(new errors_js_1.ClosedError("Client is closed", this.#closed));
-            return;
-        }
-        const requestId = this.#requestIdAlloc.alloc();
-        this.#responseMap.set(requestId, { ...callbacks, type: request.type });
-        this.#send({ type: "request", requestId, request });
-    }
-    // The socket encountered an error.
-    #onSocketError(event) {
-        const eventMessage = event.message;
-        const message = eventMessage ?? "WebSocket was closed due to an error";
-        this.#setClosed(new errors_js_1.WebSocketError(message));
-    }
-    // The socket was closed.
-    #onSocketClose(event) {
-        let message = `WebSocket was closed with code ${event.code}`;
-        if (event.reason) {
-            message += `: ${event.reason}`;
-        }
-        this.#setClosed(new errors_js_1.WebSocketError(message));
-    }
-    // Close the client with the given error.
-    #setClosed(error) {
-        if (this.#closed !== undefined) {
-            return;
-        }
-        this.#closed = error;
-        for (const callbacks of this.#openCallbacks) {
-            callbacks.errorCallback(error);
-        }
-        this.#openCallbacks.length = 0;
-        for (const [requestId, responseState] of this.#responseMap.entries()) {
-            responseState.errorCallback(error);
-            this.#requestIdAlloc.free(requestId);
-        }
-        this.#responseMap.clear();
-        this.#socket.close();
-    }
-    // We received a message from the socket.
-    #onSocketMessage(event) {
-        if (this.#closed !== undefined) {
-            return;
-        }
-        try {
-            let msg;
-            const encoding = this.#subprotocol.encoding;
-            if (encoding === "json") {
-                if (typeof event.data !== "string") {
-                    this.#socket.close(3003, "Only text messages are accepted with JSON encoding");
-                    this.#setClosed(new errors_js_1.ProtoError("Received non-text message from server with JSON encoding"));
-                    return;
-                }
-                msg = (0, index_js_1.readJsonObject)(JSON.parse(event.data), json_decode_js_1.ServerMsg);
-            }
-            else if (encoding === "protobuf") {
-                if (!(event.data instanceof ArrayBuffer)) {
-                    this.#socket.close(3003, "Only binary messages are accepted with Protobuf encoding");
-                    this.#setClosed(new errors_js_1.ProtoError("Received non-binary message from server with Protobuf encoding"));
-                    return;
-                }
-                msg = (0, index_js_1.readProtobufMessage)(new Uint8Array(event.data), protobuf_decode_js_1.ServerMsg);
-            }
-            else {
-                throw (0, util_js_1.impossible)(encoding, "Impossible encoding");
-            }
-            this.#handleMsg(msg);
-        }
-        catch (e) {
-            this.#socket.close(3007, "Could not handle message");
-            this.#setClosed(e);
-        }
-    }
-    // Handle a message from the server.
-    #handleMsg(msg) {
-        if (msg.type === "none") {
-            throw new errors_js_1.ProtoError("Received an unrecognized ServerMsg");
-        }
-        else if (msg.type === "hello_ok" || msg.type === "hello_error") {
-            if (this.#recvdHello) {
-                throw new errors_js_1.ProtoError("Received a duplicated hello response");
-            }
-            this.#recvdHello = true;
-            if (msg.type === "hello_error") {
-                throw (0, result_js_1.errorFromProto)(msg.error);
-            }
-            return;
-        }
-        else if (!this.#recvdHello) {
-            throw new errors_js_1.ProtoError("Received a non-hello message before a hello response");
-        }
-        if (msg.type === "response_ok") {
-            const requestId = msg.requestId;
-            const responseState = this.#responseMap.get(requestId);
-            this.#responseMap.delete(requestId);
-            if (responseState === undefined) {
-                throw new errors_js_1.ProtoError("Received unexpected OK response");
-            }
-            this.#requestIdAlloc.free(requestId);
-            try {
-                if (responseState.type !== msg.response.type) {
-                    console.dir({ responseState, msg });
-                    throw new errors_js_1.ProtoError("Received unexpected type of response");
-                }
-                responseState.responseCallback(msg.response);
-            }
-            catch (e) {
-                responseState.errorCallback(e);
-                throw e;
-            }
-        }
-        else if (msg.type === "response_error") {
-            const requestId = msg.requestId;
-            const responseState = this.#responseMap.get(requestId);
-            this.#responseMap.delete(requestId);
-            if (responseState === undefined) {
-                throw new errors_js_1.ProtoError("Received unexpected error response");
-            }
-            this.#requestIdAlloc.free(requestId);
-            responseState.errorCallback((0, result_js_1.errorFromProto)(msg.error));
-        }
-        else {
-            throw (0, util_js_1.impossible)(msg, "Impossible ServerMsg type");
-        }
-    }
-    /** Open a {@link WsStream}, a stream for executing SQL statements. */
-    openStream() {
-        return stream_js_1.WsStream.open(this);
-    }
-    /** Cache a SQL text on the server. This requires protocol version 2 or higher. */
-    storeSql(sql) {
-        this._ensureVersion(2, "storeSql()");
-        const sqlId = this.#sqlIdAlloc.alloc();
-        const sqlObj = new sql_js_1.Sql(this, sqlId);
-        const responseCallback = () => undefined;
-        const errorCallback = (e) => sqlObj._setClosed(e);
-        const request = { type: "store_sql", sqlId, sql };
-        this._sendRequest(request, { responseCallback, errorCallback });
-        return sqlObj;
-    }
-    /** @private */
-    _closeSql(sqlId) {
-        if (this.#closed !== undefined) {
-            return;
-        }
-        const responseCallback = () => this.#sqlIdAlloc.free(sqlId);
-        const errorCallback = (e) => this.#setClosed(e);
-        const request = { type: "close_sql", sqlId };
-        this._sendRequest(request, { responseCallback, errorCallback });
-    }
-    /** Close the client and the WebSocket. */
-    close() {
-        this.#setClosed(new errors_js_1.ClientError("Client was manually closed"));
-    }
-    /** True if the client is closed. */
-    get closed() {
-        return this.#closed !== undefined;
-    }
-}
-exports.WsClient = WsClient;

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

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WsCursor = void 0;
-const errors_js_1 = require("../errors.js");
-const cursor_js_1 = require("../cursor.js");
-const queue_js_1 = require("../queue.js");
-const fetchChunkSize = 1000;
-const fetchQueueSize = 10;
-class WsCursor extends cursor_js_1.Cursor {
-    #client;
-    #stream;
-    #cursorId;
-    #entryQueue;
-    #fetchQueue;
-    #closed;
-    #done;
-    /** @private */
-    constructor(client, stream, cursorId) {
-        super();
-        this.#client = client;
-        this.#stream = stream;
-        this.#cursorId = cursorId;
-        this.#entryQueue = new queue_js_1.Queue();
-        this.#fetchQueue = new queue_js_1.Queue();
-        this.#closed = undefined;
-        this.#done = false;
-    }
-    /** Fetch the next entry from the cursor. */
-    async next() {
-        for (;;) {
-            if (this.#closed !== undefined) {
-                throw new errors_js_1.ClosedError("Cursor is closed", this.#closed);
-            }
-            while (!this.#done && this.#fetchQueue.length < fetchQueueSize) {
-                this.#fetchQueue.push(this.#fetch());
-            }
-            const entry = this.#entryQueue.shift();
-            if (this.#done || entry !== undefined) {
-                return entry;
-            }
-            // we assume that `Cursor.next()` is never called concurrently
-            await this.#fetchQueue.shift().then((response) => {
-                if (response === undefined) {
-                    return;
-                }
-                for (const entry of response.entries) {
-                    this.#entryQueue.push(entry);
-                }
-                this.#done ||= response.done;
-            });
-        }
-    }
-    #fetch() {
-        return this.#stream._sendCursorRequest(this, {
-            type: "fetch_cursor",
-            cursorId: this.#cursorId,
-            maxCount: fetchChunkSize,
-        }).then((resp) => resp, (error) => {
-            this._setClosed(error);
-            return undefined;
-        });
-    }
-    /** @private */
-    _setClosed(error) {
-        if (this.#closed !== undefined) {
-            return;
-        }
-        this.#closed = error;
-        this.#stream._sendCursorRequest(this, {
-            type: "close_cursor",
-            cursorId: this.#cursorId,
-        }).catch(() => undefined);
-        this.#stream._cursorClosed(this);
-    }
-    /** Close the cursor. */
-    close() {
-        this._setClosed(new errors_js_1.ClientError("Cursor was manually closed"));
-    }
-    /** True if the cursor is closed. */
-    get closed() {
-        return this.#closed !== undefined;
-    }
-}
-exports.WsCursor = WsCursor;