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

package/esm/deps/jsr.io/@oak/commons/1.0.0/range.js

@@ -1,503 +0,0 @@
-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 __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 _MultiPartByteRangesStream_instances, _MultiPartByteRangesStream_boundary, _MultiPartByteRangesStream_contentLength, _MultiPartByteRangesStream_postscript, _MultiPartByteRangesStream_previous, _MultiPartByteRangesStream_ranges, _MultiPartByteRangesStream_seen, _MultiPartByteRangesStream_source, _MultiPartByteRangesStream_type, _MultiPartByteRangesStream_readRange;
-/**
- * A module which provides capabilities to deal with handling HTTP
- * [range requests](https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests).
- *
- * The {@linkcode range} function can be used to determine if a range can be
- * satisfied for a requested resource. The {@linkcode responseRange} can be used
- * to fulfill range requests.
- *
- * The module provides specific support for {@linkcode Deno.FsFile} to provide
- * an efficient way of send the response to the range request without having to
- * read the whole file into memory by using the `.seek()` API.
- *
- * There are also some lower level constructs which can be used for advanced
- * use cases.
- *
- *   - {@linkcode MultiPartByteRangesStream} is a readable stream which
- *     generates a body that converts the source to a multipart byte range
- *     document.
- *   - {@linkcode RangeByteTransformStream} is a transform stream which will
- *     only stream the bytes indicated by the range.
- *   - {@linkcode contentRange} sets the headers that are appropriate when
- *     sending a range content response.
- *   - {@linkcode multiPartByteRanges} sets the headers that are appropriate
- *     when sending a multi part byte range content response.
- *   - {@linkcode asLimitedReadableStream} leverages the `.seek()` APIs with a
- *     {@linkcode Deno.FsFile} to provide a more performant and memory efficient
- *     way to stream just a range of bytes form a file.
- *
- * @example A simple static webserver supporting range requests
- *
- * ```ts
- * import { range, responseRange } from "jsr:@oak/commons/range";
- * import { typeByExtension } from "jsr:@std/media-types/type-by-extension";
- * import { extname } from "jsr:@std/path/extname";
- *
- * Deno.serve(async (req) => {
- *   const url = new URL(req.url);
- *   const file = await Deno.open(`./static${url.pathname}`);
- *   const fileInfo = await file.stat();
- *   const headers = { "accept-ranges": "bytes", "content-type": type };
- *   if (req.method === "HEAD") {
- *     return new Response(null, {
- *       headers: {
- *         ...headers,
- *         "content-length": String(fileInfo.size),
- *       },
- *     });
- *   }
- *   if (req.method === "GET") {
- *     const result = await range(req, fileInfo);
- *     if (result.ok) {
- *       if (result.ranges) {
- *         return responseRange(file, fileInfo.size, result.ranges, {
- *           headers,
- *         }, { type });
- *       } else {
- *         return new Response(file.readable, {
- *           headers: {
- *             ...headers,
- *             "content-length": String(fileInfo.size),
- *           },
- *         });
- *       }
- *     } else {
- *       return new Response(null, {
- *         status: 416,
- *         statusText: "Range Not Satisfiable",
- *         headers,
- *       });
- *     }
- *   }
- *   return new Response(null, { status: 405, statusText: "Method Not Allowed" });
- * });
- * ```
- *
- * @module
- */
-import * as dntShim from "../../../../../_dnt.shims.js";
-import { assert } from "../../../@std/assert/1.0.11/assert.js";
-import { concat } from "../../../@std/bytes/1.0.5/concat.js";
-import { eTag } from "../../../@std/http/1.0.13/etag.js";
-const DEFAULT_CHUNK_SIZE = 524_288;
-const ETAG_RE = /(?:W\/)?"[ !#-\x7E\x80-\xFF]+"/;
-const encoder = new TextEncoder();
-function isDenoFsFile(value) {
-    if (!value || value === null || !("Deno" in dntShim.dntGlobalThis) || !dntShim.Deno.FsFile) {
-        return false;
-    }
-    return value instanceof dntShim.Deno.FsFile;
-}
-function isFileInfo(value) {
-    return !!(typeof value === "object" && value && "mtime" in value);
-}
-function isModified(value, mtime) {
-    const a = new Date(value).getTime();
-    let b = mtime.getTime();
-    // adjust to the precision of HTTP UTC time
-    b -= b % 1000;
-    return a < b;
-}
-async function readRange(file, { start, end }) {
-    const parts = [];
-    let read = 0;
-    const length = end - start + 1;
-    const pos = await file.seek(start, dntShim.Deno.SeekMode.Start);
-    if (pos !== start) {
-        throw new RangeError("Could not seek to range start.");
-    }
-    while (read < length) {
-        const chunk = new Uint8Array(length - read);
-        const count = await file.read(chunk);
-        if (count === null) {
-            throw new RangeError("Could not read to range end.");
-        }
-        parts.push(chunk);
-        read += count;
-    }
-    return parts.length > 1 ? concat(parts) : parts[0];
-}
-/**
- * A readable stream that will stream a body formatted as a
- * `multipart/byteranges` document. The `source` needs to be a
- * {@linkcode Deno.FsFile}, {@linkcode ReadableStream}, {@linkcode Blob},
- * {@linkcode BufferSource}, or a `string`.
- */
-export class MultiPartByteRangesStream extends ReadableStream {
-    /**
-     * The boundary being used when segmenting different parts of the body
-     * response. This should be reflected in the `Content-Type` header when
-     * being sent to a client.
-     */
-    get boundary() {
-        return __classPrivateFieldGet(this, _MultiPartByteRangesStream_boundary, "f");
-    }
-    /**
-     * The length of the content being supplied by the stream. This should be
-     * reflected in the `Content-Length` header when being sent to a client.
-     */
-    get contentLength() {
-        return __classPrivateFieldGet(this, _MultiPartByteRangesStream_contentLength, "f");
-    }
-    constructor(source, ranges, size, options = {}) {
-        const { autoClose = true, boundary = "OAK-COMMONS-BOUNDARY", type, } = options;
-        super({
-            pull: async (controller) => {
-                const range = __classPrivateFieldGet(this, _MultiPartByteRangesStream_ranges, "f").shift();
-                if (!range) {
-                    controller.enqueue(__classPrivateFieldGet(this, _MultiPartByteRangesStream_postscript, "f"));
-                    controller.close();
-                    if (autoClose && isDenoFsFile(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f"))) {
-                        __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").close();
-                    }
-                    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f") instanceof ReadableStreamDefaultReader) {
-                        __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").releaseLock();
-                    }
-                    return;
-                }
-                const bytes = await __classPrivateFieldGet(this, _MultiPartByteRangesStream_instances, "m", _MultiPartByteRangesStream_readRange).call(this, range);
-                const preamble = encoder.encode(`\r\n--${boundary}\r\nContent-Type: ${__classPrivateFieldGet(this, _MultiPartByteRangesStream_type, "f")}\r\nContent-Range: ${range.start}-${range.end}/${size}\r\n\r\n`);
-                controller.enqueue(concat([preamble, bytes]));
-            },
-        });
-        _MultiPartByteRangesStream_instances.add(this);
-        _MultiPartByteRangesStream_boundary.set(this, void 0);
-        _MultiPartByteRangesStream_contentLength.set(this, void 0);
-        _MultiPartByteRangesStream_postscript.set(this, void 0);
-        _MultiPartByteRangesStream_previous.set(this, void 0);
-        _MultiPartByteRangesStream_ranges.set(this, void 0);
-        _MultiPartByteRangesStream_seen.set(this, 0);
-        _MultiPartByteRangesStream_source.set(this, void 0);
-        _MultiPartByteRangesStream_type.set(this, void 0);
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_boundary, boundary, "f");
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_ranges, [...ranges], "f");
-        __classPrivateFieldGet(this, _MultiPartByteRangesStream_ranges, "f").sort(({ start: a }, { start: b }) => a - b);
-        if (ArrayBuffer.isView(source)) {
-            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, source.buffer, "f");
-        }
-        else if (typeof source === "string") {
-            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, encoder.encode(source).buffer, "f");
-        }
-        else if (source instanceof ReadableStream) {
-            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, source.getReader(), "f");
-        }
-        else {
-            __classPrivateFieldSet(this, _MultiPartByteRangesStream_source, source, "f");
-        }
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_type, type || (source instanceof Blob && source.type) ||
-            "application/octet-stream", "f");
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_postscript, encoder.encode(`\r\n--${boundary}--\r\n`), "f");
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_contentLength, ranges.reduce((prev, { start, end }) => prev +
-            encoder.encode(`\r\n--${boundary}\r\nContent-Type: ${__classPrivateFieldGet(this, _MultiPartByteRangesStream_type, "f")}\r\nContent-Range: ${start}-${end}/${size}\r\n\r\n`).byteLength + (end - start) + 1, __classPrivateFieldGet(this, _MultiPartByteRangesStream_postscript, "f").byteLength), "f");
-    }
-}
-_MultiPartByteRangesStream_boundary = new WeakMap(), _MultiPartByteRangesStream_contentLength = new WeakMap(), _MultiPartByteRangesStream_postscript = new WeakMap(), _MultiPartByteRangesStream_previous = new WeakMap(), _MultiPartByteRangesStream_ranges = new WeakMap(), _MultiPartByteRangesStream_seen = new WeakMap(), _MultiPartByteRangesStream_source = new WeakMap(), _MultiPartByteRangesStream_type = new WeakMap(), _MultiPartByteRangesStream_instances = new WeakSet(), _MultiPartByteRangesStream_readRange = async function _MultiPartByteRangesStream_readRange({ start, end }) {
-    if (isDenoFsFile(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f"))) {
-        return readRange(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f"), { start, end });
-    }
-    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f") instanceof Blob) {
-        return new Uint8Array(await __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").slice(start, end + 1).arrayBuffer());
-    }
-    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f") instanceof ArrayBuffer) {
-        return new Uint8Array(__classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").slice(start, end + 1));
-    }
-    const length = end - start;
-    let read = 0;
-    let result;
-    const processChunk = (chunk) => {
-        if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") + chunk.byteLength >= start) {
-            if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") < start) {
-                chunk = chunk.slice(start - __classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f"));
-                __classPrivateFieldSet(this, _MultiPartByteRangesStream_seen, start, "f");
-            }
-            if (read + chunk.byteLength > length + 1) {
-                __classPrivateFieldSet(this, _MultiPartByteRangesStream_previous, chunk.slice(length - read + 1), "f");
-                chunk = chunk.slice(0, length - read + 1);
-            }
-            read += chunk.byteLength;
-            __classPrivateFieldSet(this, _MultiPartByteRangesStream_seen, __classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") + chunk.byteLength, "f");
-            return chunk;
-        }
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_seen, __classPrivateFieldGet(this, _MultiPartByteRangesStream_seen, "f") + chunk.byteLength, "f");
-    };
-    if (__classPrivateFieldGet(this, _MultiPartByteRangesStream_previous, "f")) {
-        const chunk = __classPrivateFieldGet(this, _MultiPartByteRangesStream_previous, "f");
-        __classPrivateFieldSet(this, _MultiPartByteRangesStream_previous, undefined, "f");
-        const res = processChunk(chunk);
-        if (res) {
-            result = res;
-        }
-    }
-    while (read < length) {
-        const { done, value: chunk } = await __classPrivateFieldGet(this, _MultiPartByteRangesStream_source, "f").read();
-        if (chunk) {
-            const res = processChunk(chunk);
-            if (res) {
-                result = result ? concat([result, res]) : res;
-            }
-        }
-        if (done) {
-            throw new RangeError("Unable to read range.");
-        }
-    }
-    assert(result);
-    return result;
-};
-/**
- * A {@linkcode TransformStream} which will only provide the range of bytes from
- * the source stream.
- */
-export class RangeByteTransformStream extends TransformStream {
-    constructor(range) {
-        const { start, end } = range;
-        const length = end - start;
-        let seen = 0;
-        let read = 0;
-        super({
-            transform(chunk, controller) {
-                if (seen + chunk.byteLength >= start) {
-                    if (seen < start) {
-                        // start is part way through chunk
-                        chunk = chunk.slice(start - seen);
-                        seen = start;
-                    }
-                    if (read + chunk.byteLength > length + 1) {
-                        // chunk extends past end
-                        chunk = chunk.slice(0, length - read + 1);
-                    }
-                    read += chunk.byteLength;
-                    seen += chunk.byteLength;
-                    controller.enqueue(chunk);
-                    if (read >= length) {
-                        controller.terminate();
-                    }
-                }
-                else {
-                    // skip chunk
-                    seen += chunk.byteLength;
-                }
-            },
-        });
-    }
-}
-/**
- * Set {@linkcode Headers} related to returning a content range to the client.
- *
- * This will set the `Accept-Ranges`, `Content-Range` and `Content-Length` as
- * appropriate. If the headers does not contain a `Content-Type` header, and one
- * is supplied, it will be added.
- */
-export function contentRange(headers, range, size, type) {
-    const { start, end } = range;
-    headers.set("accept-ranges", "bytes");
-    headers.set("content-range", `bytes ${start}-${end}/${size}`);
-    headers.set("content-length", String(end - start + 1));
-    if (type && !headers.has("content-type")) {
-        headers.set("content-type", type);
-    }
-}
-/**
- * Set {@linkcode Headers} related to returning a multipart byte range response.
- *
- * This will set the `Content-Type` and `Content-Length` headers as appropriate.
- */
-export function multiPartByteRanges(headers, init) {
-    const { contentLength, boundary } = init;
-    headers.set("content-type", `multipart/byteranges; boundary=${boundary}`);
-    headers.set("content-length", String(contentLength));
-}
-/**
- * Converts a {@linkcode DenoFile} and a {@linkcode ByteRange} into a byte
- * {@linkcode ReadableStream} which will provide just the range of bytes.
- *
- * When the stream is finished being ready, the file will be closed. Changing
- * the option to `autoClose` to `false` will disable this behavior.
- */
-export function asLimitedReadableStream(fsFile, range, options = {}) {
-    const { start, end } = range;
-    const { autoClose = true, chunkSize = DEFAULT_CHUNK_SIZE } = options;
-    let read = 0;
-    const length = end - start + 1;
-    return new ReadableStream({
-        start(controller) {
-            const pos = fsFile.seekSync(start, dntShim.Deno.SeekMode.Start);
-            if (pos !== start) {
-                controller.error(new RangeError("Could not seek to range start."));
-            }
-        },
-        async pull(controller) {
-            const chunk = new Uint8Array(Math.min(length - read, chunkSize));
-            const count = await fsFile.read(chunk);
-            if (count == null) {
-                controller.error(new RangeError("Could not read to range end."));
-                return;
-            }
-            controller.enqueue(chunk);
-            read += count;
-            if (read >= length) {
-                controller.close();
-                if (autoClose) {
-                    fsFile.close();
-                }
-            }
-        },
-        autoAllocateChunkSize: chunkSize,
-        type: "bytes",
-    });
-}
-export async function range(request, entity, fileInfo) {
-    const ifRange = request.headers.get("if-range");
-    if (ifRange) {
-        const matches = ETAG_RE.exec(ifRange);
-        if (matches) {
-            const [match] = matches;
-            // this indicates that it would be a weak tag, and we cannot compare on
-            // weak tags, the full entity should be returned
-            if (!fileInfo || match.startsWith("W")) {
-                return { ok: true, ranges: null };
-            }
-            // @ts-ignore the types for eTag are not correct
-            if (match !== await eTag(entity)) {
-                return { ok: true, ranges: null };
-            }
-        }
-        else {
-            assert(fileInfo || isFileInfo(entity));
-            const { mtime } = fileInfo ?? entity;
-            if (!mtime || isModified(ifRange, mtime)) {
-                return { ok: true, ranges: null };
-            }
-        }
-    }
-    const value = request.headers.get("range");
-    if (!value) {
-        return { ok: true, ranges: null };
-    }
-    const [unit, rangesStr] = value.split("=");
-    if (unit !== "bytes") {
-        return { ok: false, ranges: null };
-    }
-    const ranges = [];
-    for (const range of rangesStr.split(/\s*,\s+/)) {
-        const item = range.split("-");
-        if (item.length !== 2) {
-            return { ok: false, ranges: null };
-        }
-        const { size } = fileInfo ?? entity;
-        const [startStr, endStr] = item;
-        let start;
-        let end;
-        try {
-            if (startStr === "") {
-                start = size - parseInt(endStr, 10) - 1;
-                end = size - 1;
-            }
-            else if (endStr === "") {
-                start = parseInt(startStr, 10);
-                end = size - 1;
-            }
-            else {
-                start = parseInt(startStr, 10);
-                end = parseInt(endStr, 10);
-            }
-        }
-        catch {
-            return { ok: false, ranges: null };
-        }
-        if (start < 0 || start >= size || end < 0 || end >= size || start > end) {
-            return { ok: false, ranges: null };
-        }
-        ranges.push({ start, end });
-    }
-    return { ok: true, ranges };
-}
-/**
- * Resolves with a {@linkcode Response} with a body which is just the range of
- * bytes supplied, along with the appropriate headers which indicate that it is
- * the fulfillment of a range request.
- *
- * The `body` is a {@linkcode Response} {@linkcode BodyInit} with the addition
- * of supporting {@linkcode Deno.FsFile} and does not accept
- * {@linkcode FormData} or {@linkcode URLSearchParams}. When using
- * {@linkcode Deno.FsFile} the seek capabilities in order to read ranges more
- * efficiently.
- *
- * The `size` is the total number of bytes in the resource being responded to.
- * This needs to be provided, because the full size of the resource being
- * requested it may not be easy to determine at the time being requested.
- *
- * @example
- *
- * ```ts
- * import { responseRange } from "jsr:@oak/commons/range";
- *
- * const file = await Deno.open("./movie.mp4");
- * const { size } = await file.stat();
- * const res = responseRange(
- *   file,
- *   size,
- *   { start: 0, end: 1_048_575 },
- *   { headers: { "content-type": "video/mp4" } },
- * );
- * const ab = await res.arrayBuffer();
- * // ab will be the first 1MB of the video file
- * ```
- */
-export function responseRange(body, size, ranges, init = {}, options = {}) {
-    if (!ranges.length) {
-        throw new RangeError("At least one range expected.");
-    }
-    if (ranges.length === 1) {
-        const [range] = ranges;
-        let type = options.type ?? "application/octet-stream";
-        if (isDenoFsFile(body)) {
-            body = asLimitedReadableStream(body, range, options);
-        }
-        else if (body instanceof ReadableStream) {
-            body = body.pipeThrough(new RangeByteTransformStream(range));
-        }
-        else if (body instanceof Blob) {
-            type = body.type;
-            body = body.slice(range.start, range.end + 1);
-        }
-        else if (ArrayBuffer.isView(body)) {
-            body = body.buffer.slice(range.start, range.end + 1);
-        }
-        else if (body instanceof ArrayBuffer) {
-            body = body.slice(range.start, range.end + 1);
-        }
-        else if (typeof body === "string") {
-            body = encoder.encode(body).slice(range.start, range.end + 1);
-        }
-        else {
-            throw TypeError("Invalid body type.");
-        }
-        const res = new Response(body, {
-            ...init,
-            status: 206,
-            statusText: "Partial Content",
-        });
-        contentRange(res.headers, range, size, type);
-        return res;
-    }
-    const stream = new MultiPartByteRangesStream(body, ranges, size, options);
-    const res = new Response(stream, {
-        ...init,
-        status: 206,
-        statusText: "Partial Content",
-    });
-    multiPartByteRanges(res.headers, stream);
-    return res;
-}

package/esm/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/esm/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"}