@versori/run 0.0.1-alpha.1 → 0.0.1-alpha.3

package/script/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.d.ts

@@ -0,0 +1,178 @@
+/** Options which can be set when initializing a {@linkcode ServerSentEvent}. */
+export interface ServerSentEventInit extends EventInit {
+    /**
+     * Optional arbitrary data to send to the client, data this is a string will
+     * be sent unmodified, otherwise `JSON.stringify()` will be used to serialize
+     * the value.
+     */
+    data?: unknown;
+    /** An optional `id` which will be sent with the event and exposed in the
+     * client `EventSource`. */
+    id?: number;
+    /** The replacer is passed to `JSON.stringify` when converting the `data`
+     * property to a JSON string. */
+    replacer?: (string | number)[] | ((this: any, key: string, value: any) => any);
+    /** Space is passed to `JSON.stringify` when converting the `data` property
+     * to a JSON string. */
+    space?: string | number;
+}
+/**
+ * Options which can be sent when initializing a
+ * {@linkcode ServerSentEventTarget}.
+ */
+export interface ServerSentEventTargetOptions {
+    /** Keep client connections alive by sending a comment event to the client
+     * at a specified interval.  If `true`, then it polls every 30000 milliseconds
+     * (30 seconds). If set to a number, then it polls that number of
+     * milliseconds.  The feature is disabled if set to `false`.  It defaults to
+     * `false`. */
+    keepAlive?: boolean | number;
+}
+declare class CloseEvent extends Event {
+    constructor(eventInit: EventInit);
+}
+/**
+ * An event which contains information which will be sent to the remote
+ * connection and be made available in an `EventSource` as an event. A server
+ * creates new events and dispatches them on the target which will then be
+ * sent to a client.
+ *
+ * See more about Server-sent events on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   ServerSentEvent,
+ *   ServerSentEventStreamTarget,
+ * } from "jsr:@oak/commons/server_sent_event";
+ *
+ * Deno.serve({ port: 8000 }, (request) => {
+ *   const target = new ServerSentEventStreamTarget();
+ *   const evt = new ServerSentEvent("message", {
+ *     data: { hello: "world" },
+ *     id: 1
+ *   });
+ *   target.dispatchEvent(evt);
+ *   return target.asResponse();
+ * });
+ * ```
+ */
+export declare class ServerSentEvent extends Event {
+    #private;
+    /**
+     * @param type the event type that will be available on the client. The type
+     *             of `"message"` will be handled specifically as a message
+     *             server-side event.
+     * @param eventInit initialization options for the event
+     */
+    constructor(type: string, eventInit?: ServerSentEventInit);
+    /** The data associated with the event, which will be sent to the client and
+     * be made available in the `EventSource`. */
+    get data(): string;
+    /** The optional ID associated with the event that will be sent to the client
+     * and be made available in the `EventSource`. */
+    get id(): number | undefined;
+    toString(): string;
+}
+/**
+ * The abstract interface for server sent events, which is implemented in
+ * {@linkcode ServerSentEventStreamTarget}.
+ */
+export interface ServerSentEventTarget extends EventTarget {
+    /** Is set to `true` if events cannot be sent to the remote connection.
+     * Otherwise it is set to `false`.
+     *
+     * *Note*: This flag is lazily set, and might not reflect a closed state until
+     * another event, comment or message is attempted to be processed. */
+    readonly closed: boolean;
+    /** Close the target, refusing to accept any more events. */
+    close(): Promise<void>;
+    /** Send a comment to the remote connection.  Comments are not exposed to the
+     * client `EventSource` but are used for diagnostics and helping ensure a
+     * connection is kept alive.
+     *
+     * ```ts
+     * import { ServerSentEventStreamTarget } from "jsr:@oak/commons/server_sent_event";
+     *
+     * Deno.serve({ port: 8000 }, (request) => {
+     *   const target = new ServerSentEventStreamTarget();
+     *   target.dispatchComment("this is a comment");
+     *   return target.asResponse();
+     * });
+     * ```
+     */
+    dispatchComment(comment: string): boolean;
+    /** Dispatch a message to the client.  This message will contain `data: ` only
+     * and be available on the client `EventSource` on the `onmessage` or an event
+     * listener of type `"message"`. */
+    dispatchMessage(data: unknown): boolean;
+    /** Dispatch a server sent event to the client.  The event `type` will be
+     * sent as `event: ` to the client which will be raised as a `MessageEvent`
+     * on the `EventSource` in the client.
+     *
+     * Any local event handlers will be dispatched to first, and if the event
+     * is cancelled, it will not be sent to the client.
+     *
+     * ```ts
+     * import {
+     *   ServerSentEvent,
+     *   ServerSentEventStreamTarget,
+     * } from "jsr:@oak/commons/server_sent_event";
+     *
+     * Deno.serve({ port: 8000 }, (request) => {
+     *   const target = new ServerSentEventStreamTarget();
+     *   const evt = new ServerSentEvent("ping", { data: "hello" });
+     *   target.dispatchEvent(evt);
+     *   return target.asResponse();
+     * });
+     * ```
+     */
+    dispatchEvent(event: ServerSentEvent): boolean;
+    /** Dispatch a server sent event to the client.  The event `type` will be
+     * sent as `event: ` to the client which will be raised as a `MessageEvent`
+     * on the `EventSource` in the client.
+     *
+     * Any local event handlers will be dispatched to first, and if the event
+     * is cancelled, it will not be sent to the client.
+     *
+     * ```ts
+     * import {
+     *   ServerSentEvent,
+     *   ServerSentEventStreamTarget,
+     * } from "jsr:@oak/commons/server_sent_event";
+     *
+     * Deno.serve({ port: 8000 }, (request) => {
+     *   const target = new ServerSentEventStreamTarget();
+     *   const evt = new ServerSentEvent("ping", { data: "hello" });
+     *   target.dispatchEvent(evt);
+     *   return target.asResponse();
+     * });
+     * ```
+     */
+    dispatchEvent(event: CloseEvent | ErrorEvent): boolean;
+}
+/**
+ * An implementation of {@linkcode ServerSentEventTarget} that provides a
+ * readable stream as a body of a response to establish a connection to a
+ * client.
+ */
+export declare class ServerSentEventStreamTarget extends EventTarget implements ServerSentEventTarget {
+    #private;
+    get closed(): boolean;
+    constructor({ keepAlive }?: ServerSentEventTargetOptions);
+    /** Returns a {@linkcode Response} which contains the body and headers needed
+     * to initiate a SSE connection with the client. */
+    asResponse(responseInit?: ResponseInit): Response;
+    /** Returns a tuple which contains the {@linkcode BodyInit} and
+     * {@linkcode ResponseInit} needed to create a response that will establish
+     * a SSE connection with the client. */
+    asResponseInit(responseInit?: ResponseInit): [BodyInit, ResponseInit];
+    close(): Promise<void>;
+    dispatchComment(comment: string): boolean;
+    dispatchMessage(data: any): boolean;
+    dispatchEvent(event: ServerSentEvent): boolean;
+    dispatchEvent(event: CloseEvent | ErrorEvent): boolean;
+}
+export {};
+//# sourceMappingURL=server_sent_event.d.ts.map

package/script/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_sent_event.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.ts"],"names":[],"mappings":"AAkDA,gFAAgF;AAChF,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;+BAC2B;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ;oCACgC;IAChC,QAAQ,CAAC,EACL,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,GAEnB,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAElD;2BACuB;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;;kBAIc;IACd,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC9B;AAED,cAAM,UAAW,SAAQ,KAAK;gBAChB,SAAS,EAAE,SAAS;CAGjC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,eAAgB,SAAQ,KAAK;;IAKxC;;;;;OAKG;gBACS,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,mBAAwB;IAoB7D;iDAC6C;IAC7C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;qDACiD;IACjD,IAAI,EAAE,IAAI,MAAM,GAAG,SAAS,CAE3B;IAEQ,QAAQ,IAAI,MAAM;CAM5B;AASD;;;GAGG;AACH,MAAM,WAAW,qBAAsB,SAAQ,WAAW;IACxD;;;;yEAIqE;IACrE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB,4DAA4D;IAC5D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;;;;;;;;;;;OAaG;IACH,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAE1C;;uCAEmC;IACnC,eAAe,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC;IAE/C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC;CACxD;AAED;;;;GAIG;AACH,qBAAa,2BAA4B,SAAQ,WAC/C,YAAW,qBAAqB;;IA2BhC,IAAI,MAAM,IAAI,OAAO,CAEpB;gBAEW,EAAE,SAAiB,EAAE,GAAE,4BAAiC;IA8CpE;uDACmD;IACnD,UAAU,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,QAAQ;IAIjD;;2CAEuC;IACvC,cAAc,CAAC,YAAY,GAAE,YAAiB,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC;IASzE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAMzC,eAAe,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IAK1B,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO;IAC9C,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO;CAwChE"}

package/script/deps/jsr.io/@oak/commons/1.0.0/server_sent_event.js

@@ -0,0 +1,267 @@
+"use strict";
+// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ServerSentEvent_data, _ServerSentEvent_id, _ServerSentEvent_type, _ServerSentEventStreamTarget_instances, _ServerSentEventStreamTarget_bodyInit, _ServerSentEventStreamTarget_closed, _ServerSentEventStreamTarget_controller, _ServerSentEventStreamTarget_keepAliveId, _ServerSentEventStreamTarget_error, _ServerSentEventStreamTarget_push;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerSentEventStreamTarget = exports.ServerSentEvent = void 0;
+/**
+ * Provides {@linkcode ServerSentEvent} and
+ * {@linkcode ServerSentEventStreamTarget} which provides an interface to send
+ * server sent events to a browser using the DOM event model.
+ *
+ * The {@linkcode ServerSentEventStreamTarget} provides the `.asResponse()` or
+ * `.asResponseInit()` to provide a body and headers to the client to establish
+ * the event connection. This is accomplished by keeping a connection open to
+ * the client by not closing the body, which allows events to be sent down the
+ * connection and processed by the client browser.
+ *
+ * See more about Server-sent events on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+ *
+ * ## Example
+ *
+ * ```ts
+ * import {
+ *   ServerSentEvent,
+ *   ServerSentEventStreamTarget,
+ * } from "jsr:@oak/commons/server_sent_event";
+ *
+ * Deno.serve({ port: 8000 }, (request) => {
+ *   const target = new ServerSentEventStreamTarget();
+ *   let counter = 0;
+ *
+ *   // Sends an event every 2 seconds, incrementing the ID
+ *   const id = setInterval(() => {
+ *     const evt = new ServerSentEvent(
+ *       "message",
+ *       { data: { hello: "world" }, id: counter++ },
+ *     );
+ *     target.dispatchEvent(evt);
+ *   }, 2000);
+ *
+ *   target.addEventListener("close", () => clearInterval(id));
+ *   return target.asResponse();
+ * });
+ * ```
+ *
+ * @module
+ */
+const assert_js_1 = require("../../../@std/assert/1.0.11/assert.js");
+const encoder = new TextEncoder();
+const DEFAULT_KEEP_ALIVE_INTERVAL = 30_000;
+class CloseEvent extends Event {
+    constructor(eventInit) {
+        super("close", eventInit);
+    }
+}
+/**
+ * An event which contains information which will be sent to the remote
+ * connection and be made available in an `EventSource` as an event. A server
+ * creates new events and dispatches them on the target which will then be
+ * sent to a client.
+ *
+ * See more about Server-sent events on [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
+ *
+ * ### Example
+ *
+ * ```ts
+ * import {
+ *   ServerSentEvent,
+ *   ServerSentEventStreamTarget,
+ * } from "jsr:@oak/commons/server_sent_event";
+ *
+ * Deno.serve({ port: 8000 }, (request) => {
+ *   const target = new ServerSentEventStreamTarget();
+ *   const evt = new ServerSentEvent("message", {
+ *     data: { hello: "world" },
+ *     id: 1
+ *   });
+ *   target.dispatchEvent(evt);
+ *   return target.asResponse();
+ * });
+ * ```
+ */
+class ServerSentEvent extends Event {
+    /**
+     * @param type the event type that will be available on the client. The type
+     *             of `"message"` will be handled specifically as a message
+     *             server-side event.
+     * @param eventInit initialization options for the event
+     */
+    constructor(type, eventInit = {}) {
+        super(type, eventInit);
+        _ServerSentEvent_data.set(this, void 0);
+        _ServerSentEvent_id.set(this, void 0);
+        _ServerSentEvent_type.set(this, void 0);
+        const { data, replacer, space } = eventInit;
+        __classPrivateFieldSet(this, _ServerSentEvent_type, type, "f");
+        try {
+            __classPrivateFieldSet(this, _ServerSentEvent_data, typeof data === "string"
+                ? data
+                : data !== undefined
+                    ? JSON.stringify(data, replacer, space)
+                    : "", "f");
+        }
+        catch (e) {
+            (0, assert_js_1.assert)(e instanceof Error);
+            throw new TypeError(`data could not be coerced into a serialized string.\n  ${e.message}`);
+        }
+        const { id } = eventInit;
+        __classPrivateFieldSet(this, _ServerSentEvent_id, id, "f");
+    }
+    /** The data associated with the event, which will be sent to the client and
+     * be made available in the `EventSource`. */
+    get data() {
+        return __classPrivateFieldGet(this, _ServerSentEvent_data, "f");
+    }
+    /** The optional ID associated with the event that will be sent to the client
+     * and be made available in the `EventSource`. */
+    get id() {
+        return __classPrivateFieldGet(this, _ServerSentEvent_id, "f");
+    }
+    toString() {
+        const data = `data: ${__classPrivateFieldGet(this, _ServerSentEvent_data, "f").split("\n").join("\ndata: ")}\n`;
+        return `${__classPrivateFieldGet(this, _ServerSentEvent_type, "f") === "__message" ? "" : `event: ${__classPrivateFieldGet(this, _ServerSentEvent_type, "f")}\n`}${__classPrivateFieldGet(this, _ServerSentEvent_id, "f") ? `id: ${String(__classPrivateFieldGet(this, _ServerSentEvent_id, "f"))}\n` : ""}${data}\n`;
+    }
+}
+exports.ServerSentEvent = ServerSentEvent;
+_ServerSentEvent_data = new WeakMap(), _ServerSentEvent_id = new WeakMap(), _ServerSentEvent_type = new WeakMap();
+const RESPONSE_HEADERS = [
+    ["Connection", "Keep-Alive"],
+    ["Content-Type", "text/event-stream"],
+    ["Cache-Control", "no-cache"],
+    ["Keep-Alive", `timeout=${Number.MAX_SAFE_INTEGER}`],
+];
+/**
+ * An implementation of {@linkcode ServerSentEventTarget} that provides a
+ * readable stream as a body of a response to establish a connection to a
+ * client.
+ */
+class ServerSentEventStreamTarget extends EventTarget {
+    get closed() {
+        return __classPrivateFieldGet(this, _ServerSentEventStreamTarget_closed, "f");
+    }
+    constructor({ keepAlive = false } = {}) {
+        super();
+        _ServerSentEventStreamTarget_instances.add(this);
+        _ServerSentEventStreamTarget_bodyInit.set(this, void 0);
+        _ServerSentEventStreamTarget_closed.set(this, false);
+        _ServerSentEventStreamTarget_controller.set(this, void 0);
+        // we are ignoring any here, because when exporting to npm/Node.js, the timer
+        // handle isn't a number.
+        // deno-lint-ignore no-explicit-any
+        _ServerSentEventStreamTarget_keepAliveId.set(this, void 0);
+        __classPrivateFieldSet(this, _ServerSentEventStreamTarget_bodyInit, new ReadableStream({
+            start: (controller) => {
+                __classPrivateFieldSet(this, _ServerSentEventStreamTarget_controller, controller, "f");
+            },
+            cancel: (error) => {
+                // connections closing are considered "normal" for SSE events and just
+                // mean the far side has closed.
+                if (error instanceof Error && error.message.includes("connection closed")) {
+                    this.close();
+                }
+                else {
+                    __classPrivateFieldGet(this, _ServerSentEventStreamTarget_instances, "m", _ServerSentEventStreamTarget_error).call(this, error);
+                }
+            },
+        }), "f");
+        this.addEventListener("close", () => {
+            __classPrivateFieldSet(this, _ServerSentEventStreamTarget_closed, true, "f");
+            if (__classPrivateFieldGet(this, _ServerSentEventStreamTarget_keepAliveId, "f") !== null && __classPrivateFieldGet(this, _ServerSentEventStreamTarget_keepAliveId, "f") !== undefined) {
+                clearInterval(__classPrivateFieldGet(this, _ServerSentEventStreamTarget_keepAliveId, "f"));
+                __classPrivateFieldSet(this, _ServerSentEventStreamTarget_keepAliveId, undefined, "f");
+            }
+            if (__classPrivateFieldGet(this, _ServerSentEventStreamTarget_controller, "f")) {
+                try {
+                    __classPrivateFieldGet(this, _ServerSentEventStreamTarget_controller, "f").close();
+                }
+                catch {
+                    // we ignore any errors here, as it is likely that the controller
+                    // is already closed
+                }
+            }
+        });
+        if (keepAlive) {
+            const interval = typeof keepAlive === "number"
+                ? keepAlive
+                : DEFAULT_KEEP_ALIVE_INTERVAL;
+            __classPrivateFieldSet(this, _ServerSentEventStreamTarget_keepAliveId, setInterval(() => {
+                this.dispatchComment("keep-alive comment");
+            }, interval), "f");
+        }
+    }
+    /** Returns a {@linkcode Response} which contains the body and headers needed
+     * to initiate a SSE connection with the client. */
+    asResponse(responseInit) {
+        return new Response(...this.asResponseInit(responseInit));
+    }
+    /** Returns a tuple which contains the {@linkcode BodyInit} and
+     * {@linkcode ResponseInit} needed to create a response that will establish
+     * a SSE connection with the client. */
+    asResponseInit(responseInit = {}) {
+        const headers = new Headers(responseInit.headers);
+        for (const [key, value] of RESPONSE_HEADERS) {
+            headers.set(key, value);
+        }
+        responseInit.headers = headers;
+        return [__classPrivateFieldGet(this, _ServerSentEventStreamTarget_bodyInit, "f"), responseInit];
+    }
+    close() {
+        this.dispatchEvent(new CloseEvent({ cancelable: false }));
+        return Promise.resolve();
+    }
+    dispatchComment(comment) {
+        __classPrivateFieldGet(this, _ServerSentEventStreamTarget_instances, "m", _ServerSentEventStreamTarget_push).call(this, `: ${comment.split("\n").join("\n: ")}\n\n`);
+        return true;
+    }
+    // deno-lint-ignore no-explicit-any
+    dispatchMessage(data) {
+        const event = new ServerSentEvent("__message", { data });
+        return this.dispatchEvent(event);
+    }
+    dispatchEvent(event) {
+        const dispatched = super.dispatchEvent(event);
+        if (dispatched && event instanceof ServerSentEvent) {
+            __classPrivateFieldGet(this, _ServerSentEventStreamTarget_instances, "m", _ServerSentEventStreamTarget_push).call(this, String(event));
+        }
+        return dispatched;
+    }
+    [(_ServerSentEventStreamTarget_bodyInit = new WeakMap(), _ServerSentEventStreamTarget_closed = new WeakMap(), _ServerSentEventStreamTarget_controller = new WeakMap(), _ServerSentEventStreamTarget_keepAliveId = new WeakMap(), _ServerSentEventStreamTarget_instances = new WeakSet(), _ServerSentEventStreamTarget_error = function _ServerSentEventStreamTarget_error(error) {
+        this.dispatchEvent(new CloseEvent({ cancelable: false }));
+        const errorEvent = new ErrorEvent("error", { error });
+        this.dispatchEvent(errorEvent);
+    }, _ServerSentEventStreamTarget_push = function _ServerSentEventStreamTarget_push(payload) {
+        if (!__classPrivateFieldGet(this, _ServerSentEventStreamTarget_controller, "f")) {
+            __classPrivateFieldGet(this, _ServerSentEventStreamTarget_instances, "m", _ServerSentEventStreamTarget_error).call(this, new Error("The controller has not been set."));
+            return;
+        }
+        if (__classPrivateFieldGet(this, _ServerSentEventStreamTarget_closed, "f")) {
+            return;
+        }
+        __classPrivateFieldGet(this, _ServerSentEventStreamTarget_controller, "f").enqueue(encoder.encode(payload));
+    }, Symbol.for("Deno.customInspect"))](inspect) {
+        return `${this.constructor.name} ${inspect({ "#bodyInit": __classPrivateFieldGet(this, _ServerSentEventStreamTarget_bodyInit, "f"), "#closed": __classPrivateFieldGet(this, _ServerSentEventStreamTarget_closed, "f") })}`;
+    }
+    [Symbol.for("nodejs.util.inspect.custom")](depth, 
+    // deno-lint-ignore no-explicit-any
+    options, inspect) {
+        if (depth < 0) {
+            return options.stylize(`[${this.constructor.name}]`, "special");
+        }
+        const newOptions = Object.assign({}, options, {
+            depth: options.depth === null ? null : options.depth - 1,
+        });
+        return `${options.stylize(this.constructor.name, "special")} ${inspect({ "#bodyInit": __classPrivateFieldGet(this, _ServerSentEventStreamTarget_bodyInit, "f"), "#closed": __classPrivateFieldGet(this, _ServerSentEventStreamTarget_closed, "f") }, newOptions)}`;
+    }
+}
+exports.ServerSentEventStreamTarget = ServerSentEventStreamTarget;