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

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

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