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

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

@@ -1,212 +0,0 @@
-"use strict";
-// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
-// deno-lint-ignore-file no-irregular-whitespace
-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 _MediaType_subtype, _MediaType_suffix, _MediaType_type;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MediaType = void 0;
-exports.matches = matches;
-exports.format = format;
-exports.parse = parse;
-/**
- * Several APIs designed for processing of media types in request bodies.
- *
- * `MediaType`, `parse()` and `format()` are inspired media-typer at
- * https://github.com/jshttp/media-typer/ which is licensed as follows:
- *
- * Copyright(c) 2014-2017 Douglas Christopher Wilson
- *
- * MIT License
- *
- * `matches()` is inspired by type-is at https://github.com/jshttp/type-is/
- * which is licensed as follows:
- *
- * Copyright(c) 2014 Jonathan Ong
- * Copyright(c) 2014-2015 Douglas Christopher Wilson
- *
- * MIT License
- *
- * @module
- */
-const type_by_extension_js_1 = require("../../../@std/media-types/1.1.0/type_by_extension.js");
-const SUBTYPE_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.-]{0,126}$/;
-const TYPE_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126}$/;
-const TYPE_RE = /^ *([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126}) *$/;
-function mediaTypeMatch(expected, actual) {
-    if (!expected) {
-        return false;
-    }
-    const actualParts = actual.split("/");
-    const expectedParts = expected.split("/");
-    if (actualParts.length !== 2 || expectedParts.length !== 2) {
-        return false;
-    }
-    const [actualType, actualSubtype] = actualParts;
-    const [expectedType, expectedSubtype] = expectedParts;
-    if (expectedType !== "*" && expectedType !== actualType) {
-        return false;
-    }
-    if (expectedSubtype.substring(0, 2) === "*+") {
-        return expectedSubtype.length <= actualSubtype.length + 1 &&
-            expectedSubtype.substring(1) ===
-                actualSubtype.substring(actualSubtype.length + 1 - expectedSubtype.length);
-    }
-    if (expectedSubtype !== "*" && expectedSubtype !== actualSubtype) {
-        return false;
-    }
-    return true;
-}
-function normalize(mediaType) {
-    if (mediaType === "urlencoded") {
-        return "application/x-www-form-urlencoded";
-    }
-    if (mediaType === "multipart") {
-        return "multipart/*";
-    }
-    if (mediaType.startsWith("+")) {
-        return `*/*${mediaType}`;
-    }
-    return mediaType.includes("/") ? mediaType : (0, type_by_extension_js_1.typeByExtension)(mediaType);
-}
-function normalizeType(value) {
-    try {
-        const [type] = value.split(/\s*;/);
-        const mediaType = MediaType.parse(type);
-        return mediaType.toString();
-    }
-    catch {
-        return undefined;
-    }
-}
-/** A class which encapsulates the information in a media type, allowing
- * inspecting of modifying individual parts of the media type. */
-class MediaType {
-    /** Create an instance of {@linkcode MediaType} by providing the components
-     * of `type`, `subtype` and optionally a `suffix`. */
-    constructor(type, subtype, suffix) {
-        _MediaType_subtype.set(this, void 0);
-        _MediaType_suffix.set(this, void 0);
-        _MediaType_type.set(this, void 0);
-        this.type = type;
-        this.subtype = subtype;
-        if (suffix) {
-            this.suffix = suffix;
-        }
-    }
-    /** The subtype of the media type. */
-    set subtype(value) {
-        if (!SUBTYPE_NAME_RE.test(value)) {
-            throw new TypeError("Invalid subtype.");
-        }
-        __classPrivateFieldSet(this, _MediaType_subtype, value, "f");
-    }
-    /** The subtype of the media type. */
-    get subtype() {
-        return __classPrivateFieldGet(this, _MediaType_subtype, "f");
-    }
-    /** The optional suffix of the media type. */
-    set suffix(value) {
-        if (value && !TYPE_NAME_RE.test(value)) {
-            throw new TypeError("Invalid suffix.");
-        }
-        __classPrivateFieldSet(this, _MediaType_suffix, value, "f");
-    }
-    /** The optional suffix of the media type. */
-    get suffix() {
-        return __classPrivateFieldGet(this, _MediaType_suffix, "f");
-    }
-    /** The type of the media type. */
-    set type(value) {
-        if (!TYPE_NAME_RE.test(value)) {
-            throw new TypeError("Invalid type.");
-        }
-        __classPrivateFieldSet(this, _MediaType_type, value, "f");
-    }
-    /** The type of the media type. */
-    get type() {
-        return __classPrivateFieldGet(this, _MediaType_type, "f");
-    }
-    /** Return the parsed media type in its valid string format. */
-    toString() {
-        return __classPrivateFieldGet(this, _MediaType_suffix, "f")
-            ? `${__classPrivateFieldGet(this, _MediaType_type, "f")}/${__classPrivateFieldGet(this, _MediaType_subtype, "f")}+${__classPrivateFieldGet(this, _MediaType_suffix, "f")}`
-            : `${__classPrivateFieldGet(this, _MediaType_type, "f")}/${__classPrivateFieldGet(this, _MediaType_subtype, "f")}`;
-    }
-    /** Take a string and attempt to parse it into a {@linkcode MediaType}
-     * object. */
-    static parse(value) {
-        const match = TYPE_RE.exec(value.toLowerCase());
-        if (!match) {
-            throw new TypeError("Invalid media type.");
-        }
-        let [, type, subtype] = match;
-        let suffix;
-        const idx = subtype.lastIndexOf("+");
-        if (idx >= 0) {
-            suffix = subtype.substring(idx + 1);
-            subtype = subtype.substring(0, idx);
-        }
-        return new this(type, subtype, suffix);
-    }
-}
-exports.MediaType = MediaType;
-_MediaType_subtype = new WeakMap(), _MediaType_suffix = new WeakMap(), _MediaType_type = new WeakMap();
-/** Determines if the provided media type matches one of the supplied media
- * types. If there is a match, the matched media type is returned, otherwise
- * `undefined` is returned.
- *
- * Each type in the media types array can be one of the following:
- *
- * - A file extension name such as `json`. This name will be returned if
- *   matched.
- * - A media type such as `application/json`.
- * - A media type with a wildcard such as `*​/*` or `*​/json` or `application/*`.
- *   The full media type will be returned if matched.
- * - A suffix such as `+json`. This can be combined with a wildcard such as
- *   `*​/vnd+json` or `application/*+json`. The full mime type will be returned
- *   if matched.
- * - Special cases of `urlencoded` and `multipart` which get normalized to
- *   `application/x-www-form-urlencoded` and `multipart/*` respectively.
- */
-function matches(value, mediaTypes) {
-    const normalized = normalizeType(value);
-    if (!normalized) {
-        return undefined;
-    }
-    if (!mediaTypes.length) {
-        return normalized;
-    }
-    for (const mediaType of mediaTypes) {
-        if (mediaTypeMatch(normalize(mediaType), normalized)) {
-            return mediaType.startsWith("+") || mediaType.includes("*")
-                ? normalized
-                : mediaType;
-        }
-    }
-    return undefined;
-}
-/**
- * Convert a type, subtype and optional suffix of a media type into its valid
- * string form.
- */
-function format(value) {
-    const mediaType = value instanceof MediaType
-        ? value
-        : new MediaType(value.type, value.subtype, value.suffix);
-    return mediaType.toString();
-}
-/** Parses a media type into a {@linkcode MediaType} object which provides
- * parts of the media type as individual properties. */
-function parse(value) {
-    return MediaType.parse(value);
-}

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

@@ -1,29 +0,0 @@
-/**
- * Contains the constant {@linkcode HTTP_METHODS} and the type
- * {@linkcode HttpMethod} and the type guard {@linkcode isHttpMethod} for
- * working with HTTP methods with type safety.
- *
- * @example
- * ```ts
- * import { isHttpMethod } from "jsr:@oak/commons/method";
- *
- * console.log(isMethod("GET")); // true
- * ```
- *
- * @module
- */
-/**
- * A constant array of common HTTP methods.
- *
- * This list is compatible with Node.js `http` module.
- */
-export declare const HTTP_METHODS: readonly ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE", "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "REBIND", "REPORT", "SEARCH", "SOURCE", "SUBSCRIBE", "TRACE", "UNBIND", "UNLINK", "UNLOCK", "UNSUBSCRIBE"];
-/**
- * A type representing string literals of each of the common HTTP method.
- */
-export type HttpMethod = typeof HTTP_METHODS[number];
-/**
- * A type guard that determines if a value is a valid HTTP method.
- */
-export declare function isHttpMethod(value: unknown): value is HttpMethod;
-//# sourceMappingURL=method.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"method.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/method.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY,8VAmCf,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;AAErD;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

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

@@ -1,66 +0,0 @@
-"use strict";
-// Copyright 2018-2024 the oak authors. All rights reserved. MIT license.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTP_METHODS = void 0;
-exports.isHttpMethod = isHttpMethod;
-/**
- * Contains the constant {@linkcode HTTP_METHODS} and the type
- * {@linkcode HttpMethod} and the type guard {@linkcode isHttpMethod} for
- * working with HTTP methods with type safety.
- *
- * @example
- * ```ts
- * import { isHttpMethod } from "jsr:@oak/commons/method";
- *
- * console.log(isMethod("GET")); // true
- * ```
- *
- * @module
- */
-/**
- * A constant array of common HTTP methods.
- *
- * This list is compatible with Node.js `http` module.
- */
-exports.HTTP_METHODS = [
-    "ACL",
-    "BIND",
-    "CHECKOUT",
-    "CONNECT",
-    "COPY",
-    "DELETE",
-    "GET",
-    "HEAD",
-    "LINK",
-    "LOCK",
-    "M-SEARCH",
-    "MERGE",
-    "MKACTIVITY",
-    "MKCALENDAR",
-    "MKCOL",
-    "MOVE",
-    "NOTIFY",
-    "OPTIONS",
-    "PATCH",
-    "POST",
-    "PROPFIND",
-    "PROPPATCH",
-    "PURGE",
-    "PUT",
-    "REBIND",
-    "REPORT",
-    "SEARCH",
-    "SOURCE",
-    "SUBSCRIBE",
-    "TRACE",
-    "UNBIND",
-    "UNLINK",
-    "UNLOCK",
-    "UNSUBSCRIBE",
-];
-/**
- * A type guard that determines if a value is a valid HTTP method.
- */
-function isHttpMethod(value) {
-    return exports.HTTP_METHODS.includes(value);
-}

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

@@ -1,324 +0,0 @@
-/**
- * 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 { type FileInfo } from "../../../@std/http/1.0.13/etag.js";
-/**
- * A descriptor for the start and end of a byte range, which are inclusive of
- * the bytes.
- */
-export interface ByteRange {
-    /** The start byte of the range. The number is zero indexed. */
-    start: number;
-    /** The last byte to be included in the range. The number is zero indexed. */
-    end: number;
-}
-/**
- * Options which can be used when creating a
- * {@linkcode MultiPartByteRangesStream}.
- */
-interface MultiPartByteRangeStreamOptions {
-    /**
-     * If the source is a {@linkcode Deno.FsFile}, close the file once the ranges
-     * have been read from the file. This defaults to `true`.
-     */
-    autoClose?: boolean;
-    /**
-     * The boundary that should be used when creating parts of the response. A
-     * default one is used if none is supplied.
-     */
-    boundary?: string;
-    /**
-     * A content type to be used with the parts of the response. If one is not
-     * supplied and the source is a {@linkcode Blob}, the blob's `.type` will be
-     * used, otherwise `"application/octet-stream"`.
-     */
-    type?: string;
-}
-/**
- * Like {@linkcode BodyInit} but only accepts the bodies which can be provided
- * as ranges as well as adds {@linkcode Deno.FsFile}.
- */
-export type RangeBodyInit = Blob | BufferSource | ReadableStream<Uint8Array> | string | dntShim.Deno.FsFile;
-/**
- * The results object when calling {@linkcode range}.
- */
-export type RangeResult = {
-    ok: true;
-    ranges: ByteRange[] | null;
-} | {
-    ok: false;
-    ranges: null;
-};
-/**
- * Options which can be set with {@linkcode responseRange} or
- * {@linkcode asLimitedReadableStream}.
- */
-export interface ResponseRangeOptions {
-    /**
-     * Once the stream or body is finished being read, close the source
-     * {@linkcode Deno.FsFile}.
-     *
-     * @default true
-     */
-    autoClose?: boolean;
-    /**
-     * When handling multiple ranges and sending a multiple response, override
-     * the default boundary.
-     */
-    boundary?: string;
-    /**
-     * The size of which chunks are attempted to be read. This defaults to 512k.
-     * The value is specified in number of bytes.
-     */
-    chunkSize?: number;
-    /**
-     * Provide a content type for the response. This will override any automatic
-     * determination of the type.
-     */
-    type?: string;
-}
-/**
- * The valid forms of an entity which can be used with the range functions.
- */
-export type Entity = FileInfo | string | Uint8Array;
-/**
- * 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 declare class MultiPartByteRangesStream extends ReadableStream<Uint8Array> {
-    #private;
-    /**
-     * 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(): string;
-    /**
-     * 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(): number;
-    constructor(source: RangeBodyInit, ranges: ByteRange[], size: number, options?: MultiPartByteRangeStreamOptions);
-}
-/**
- * A {@linkcode TransformStream} which will only provide the range of bytes from
- * the source stream.
- */
-export declare class RangeByteTransformStream extends TransformStream<Uint8Array, Uint8Array> {
-    constructor(range: ByteRange);
-}
-/**
- * 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 declare function contentRange(headers: Headers, range: ByteRange, size: number, type?: string): void;
-/**
- * Set {@linkcode Headers} related to returning a multipart byte range response.
- *
- * This will set the `Content-Type` and `Content-Length` headers as appropriate.
- */
-export declare function multiPartByteRanges(headers: Headers, init: {
-    contentLength: number;
-    boundary: string;
-}): void;
-/**
- * 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 declare function asLimitedReadableStream(fsFile: dntShim.Deno.FsFile, range: ByteRange, options?: ResponseRangeOptions): ReadableStream<Uint8Array>;
-/**
- * Determine if a requested byte range can be fulfilled. Both the `Range` and
- * `If-Range` header will be inspected if present to determine if the request
- * can be fulfilled.
- *
- * The `request` is the current {@linkcode Request}, the `entity` is the
- * resource being requested. If {@linkcode FileInfo} is being used for the
- * entity, no further information needs to be provided, but if the entity is a
- * `string` or {@linkcode Uint8Array}, the `fileInfo` argument also needs to
- * be provided.
- *
- * Three different scenarios can result:
- *
- * | Result | Typical Response |
- * | - | - |
- * | Ok and byte ranges supplied | The range request can be fulfilled. The response should be a `206 Partial Content` and provide the requested bytes. |
- * | Ok and ranges are `null` | A range was requested, but the request is out of date. The response should be a `200 Ok` and the full entity be provided. |
- * | Not ok | A range was requested, but cannot be fulfilled. The response should be a `416 Range Not Satisfiable` and no content should be provided. |
- *
- * @example
- *
- * ```ts
- * import { range } from "jsr:/@oak/commons/range";
- *
- * const req = new Request(
- *   "https://localhost:8080/movie.mp4",
- *   { headers: { "Range": "bytes=0-499" } }
- * );
- * const res = range(req, { size: 5000, mtime: null });
- * if (res.ok && res.range) {
- *   // respond with 206 Partial Content
- * } else if (res.ok) {
- *   // response with 200 OK
- * } else {
- *   // respond with 416 Range Not Satisfiable
- * }
- * ```
- */
-export declare function range(request: Request, entity: FileInfo): Promise<RangeResult>;
-/**
- * Determine if a requested byte range can be fulfilled. Both the `Range` and
- * `If-Range` header will be inspected if present to determine if the request
- * can be fulfilled.
- *
- * The `request` is the current {@linkcode Request}, the `entity` is the
- * resource being requested. If {@linkcode FileInfo} is being used for the
- * entity, no further information needs to be provided, but if the entity is a
- * `string` or {@linkcode Uint8Array}, the `fileInfo` argument also needs to
- * be provided.
- *
- * Three different scenarios can result:
- *
- * | Result | Typical Response |
- * | - | - |
- * | Ok and byte ranges supplied | The range request can be fulfilled. The response should be a `206 Partial Content` and provide the requested bytes. |
- * | Ok and ranges are `null` | A range was requested, but the request is out of date. The response should be a `200 Ok` and the full entity be provided. |
- * | Not ok | A range was requested, but cannot be fulfilled. The response should be a `416 Range Not Satisfiable` and no content should be provided. |
- *
- * @example
- *
- * ```ts
- * import { range } from "jsr:/@oak/commons/range";
- *
- * const req = new Request(
- *   "https://localhost:8080/movie.mp4",
- *   { headers: { "Range": "bytes=0-499" } }
- * );
- * const res = range(req, { size: 5000, mtime: null });
- * if (res.ok && res.range) {
- *   // respond with 206 Partial Content
- * } else if (res.ok) {
- *   // response with 200 OK
- * } else {
- *   // respond with 416 Range Not Satisfiable
- * }
- * ```
- */
-export declare function range(request: Request, entity: string | Uint8Array, fileInfo: FileInfo): Promise<RangeResult>;
-/**
- * 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 declare function responseRange(body: RangeBodyInit, size: number, ranges: ByteRange[], init?: ResponseInit, options?: ResponseRangeOptions): Response;
-export {};
-//# sourceMappingURL=range.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@oak/commons/1.0.0/range.ts"],"names":[],"mappings":"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"}