@versori/run 0.0.1-alpha.4 → 0.0.1-alpha.6

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

@@ -1,178 +0,0 @@
-/** 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

@@ -1 +0,0 @@
-{"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

@@ -1,267 +0,0 @@
-"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;