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

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

@@ -0,0 +1,536 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeByteTransformStream = exports.MultiPartByteRangesStream = void 0;
+exports.contentRange = contentRange;
+exports.multiPartByteRanges = multiPartByteRanges;
+exports.asLimitedReadableStream = asLimitedReadableStream;
+exports.range = range;
+exports.responseRange = responseRange;
+/**
+ * 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
+ */
+const dntShim = __importStar(require("../../../../../_dnt.shims.js"));
+const assert_js_1 = require("../../../@std/assert/1.0.11/assert.js");
+const concat_js_1 = require("../../../@std/bytes/1.0.5/concat.js");
+const etag_js_1 = require("../../../@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 ? (0, concat_js_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`.
+ */
+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((0, concat_js_1.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");
+    }
+}
+exports.MultiPartByteRangesStream = MultiPartByteRangesStream;
+_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 ? (0, concat_js_1.concat)([result, res]) : res;
+            }
+        }
+        if (done) {
+            throw new RangeError("Unable to read range.");
+        }
+    }
+    (0, assert_js_1.assert)(result);
+    return result;
+};
+/**
+ * A {@linkcode TransformStream} which will only provide the range of bytes from
+ * the source stream.
+ */
+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;
+                }
+            },
+        });
+    }
+}
+exports.RangeByteTransformStream = RangeByteTransformStream;
+/**
+ * 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.
+ */
+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.
+ */
+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.
+ */
+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",
+    });
+}
+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 (0, etag_js_1.eTag)(entity)) {
+                return { ok: true, ranges: null };
+            }
+        }
+        else {
+            (0, assert_js_1.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
+ * ```
+ */
+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;
+}