@versori/run 0.0.1-alpha.1 → 0.0.1-alpha.3

package/esm/deps/jsr.io/@std/http/1.0.13/negotiation.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Returns an array of media types accepted by the request, in order of
+ * preference. If there are no media types supplied in the request, then any
+ * media type selector will be returned.
+ *
+ * @example Usage
+ * ```ts
+ * import { accepts } from "@std/http/negotiation";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const request = new Request("https://example.com/", {
+ *   headers: {
+ *     accept:
+ *       "text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, *\/*;q=0.8",
+ *   },
+ * });
+ *
+ * assertEquals(accepts(request), [
+ *   "text/html",
+ *   "application/xhtml+xml",
+ *   "image/webp",
+ *   "application/xml",
+ *   "*\/*",
+ * ]);
+ * ```
+ *
+ * @param request The request to get the acceptable media types for.
+ * @returns An array of acceptable media types.
+ */
+export declare function accepts(request: Pick<Request, "headers">): string[];
+/**
+ * For a given set of media types, return the best match accepted in the
+ * request. If no media type matches, then the function returns `undefined`.
+ *
+ *  @example Usage
+ * ```ts
+ * import { accepts } from "@std/http/negotiation";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const request = new Request("https://example.com/", {
+ *   headers: {
+ *     accept:
+ *       "text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, *\/*;q=0.8",
+ *   },
+ * });
+ *
+ * assertEquals(accepts(request, "text/html", "image/webp"), "text/html");
+ * ```
+ *
+ * @param request The request to get the acceptable media types for.
+ * @param types An array of media types to find the best matching one from.
+ * @returns The best matching media type, if any match.
+ */
+export declare function accepts(request: Pick<Request, "headers">, ...types: string[]): string | undefined;
+/**
+ * Returns an array of content encodings accepted by the request, in order of
+ * preference. If there are no encoding supplied in the request, then `["*"]`
+ * is returned, implying any encoding is accepted.
+ *
+ * @example Usage
+ * ```ts
+ * import { acceptsEncodings } from "@std/http/negotiation";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const request = new Request("https://example.com/", {
+ *   headers: { "accept-encoding": "deflate, gzip;q=1.0, *;q=0.5" },
+ * });
+ *
+ * assertEquals(acceptsEncodings(request), ["deflate", "gzip", "*"]);
+ * ```
+ *
+ * @param request The request to get the acceptable content encodings for.
+ * @returns An array of content encodings this request accepts.
+ */
+export declare function acceptsEncodings(request: Pick<Request, "headers">): string[];
+/**
+ * For a given set of content encodings, return the best match accepted in the
+ * request. If no content encodings match, then the function returns
+ * `undefined`.
+ *
+ * **NOTE:** You should always supply `identity` as one of the encodings
+ * to ensure that there is a match when the `Accept-Encoding` header is part
+ * of the request.
+ *
+ * @example Usage
+ * ```ts
+ * import { acceptsEncodings } from "@std/http/negotiation";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const request = new Request("https://example.com/", {
+ *   headers: { "accept-encoding": "deflate, gzip;q=1.0, *;q=0.5" },
+ * });
+ *
+ * assertEquals(acceptsEncodings(request, "gzip", "identity"), "gzip");
+ * ```
+ *
+ * @param request The request to get the acceptable content encodings for.
+ * @param encodings An array of encodings to find the best matching one from.
+ * @returns The best matching encoding, if any match.
+ */
+export declare function acceptsEncodings(request: Pick<Request, "headers">, ...encodings: string[]): string | undefined;
+/**
+ * Returns an array of languages accepted by the request, in order of
+ * preference. If there are no languages supplied in the request, then `["*"]`
+ * is returned, imply any language is accepted.
+ *
+ * @example Usage
+ * ```ts
+ * import { acceptsLanguages } from "@std/http/negotiation";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const request = new Request("https://example.com/", {
+ *   headers: {
+ *     "accept-language": "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5",
+ *   },
+ * });
+ *
+ * assertEquals(acceptsLanguages(request), ["fr-CH", "fr", "en", "de", "*"]);
+ * ```
+ *
+ * @param request The request to get the acceptable languages for.
+ * @returns An array of languages this request accepts.
+ */
+export declare function acceptsLanguages(request: Pick<Request, "headers">): string[];
+/**
+ * For a given set of languages, return the best match accepted in the request.
+ * If no languages match, then the function returns `undefined`.
+ *
+ * @example Usage
+ * ```ts
+ * import { acceptsLanguages } from "@std/http/negotiation";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const request = new Request("https://example.com/", {
+ *   headers: {
+ *     "accept-language": "fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5",
+ *   },
+ * });
+ *
+ * assertEquals(acceptsLanguages(request, "en-gb", "en-us", "en"), "en");
+ * ```
+ *
+ * @param request The request to get the acceptable language for.
+ * @param langs An array of languages to find the best matching one from.
+ * @returns The best matching language, if any match.
+ */
+export declare function acceptsLanguages(request: Pick<Request, "headers">, ...langs: string[]): string | undefined;
+//# sourceMappingURL=negotiation.d.ts.map

package/esm/deps/jsr.io/@std/http/1.0.13/negotiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/http/1.0.13/negotiation.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;AACrE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EACjC,GAAG,KAAK,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAAC;AAatB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EACjC,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAAC;AAetB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,MAAM,EAAE,CAAC;AAC9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,EACjC,GAAG,KAAK,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAAC"}

package/esm/deps/jsr.io/@std/http/1.0.13/negotiation.js

@@ -0,0 +1,37 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Contains the functions {@linkcode accepts}, {@linkcode acceptsEncodings}, and
+ * {@linkcode acceptsLanguages} to provide content negotiation capabilities.
+ *
+ * @module
+ */
+import { preferredEncodings } from "./_negotiation/encoding.js";
+import { preferredLanguages } from "./_negotiation/language.js";
+import { preferredMediaTypes } from "./_negotiation/media_type.js";
+export function accepts(request, ...types) {
+    const accept = request.headers.get("accept");
+    return types.length
+        ? accept ? preferredMediaTypes(accept, types)[0] : types[0]
+        : accept
+            ? preferredMediaTypes(accept)
+            : ["*/*"];
+}
+export function acceptsEncodings(request, ...encodings) {
+    const acceptEncoding = request.headers.get("accept-encoding");
+    return encodings.length
+        ? acceptEncoding
+            ? preferredEncodings(acceptEncoding, encodings)[0]
+            : encodings[0]
+        : acceptEncoding
+            ? preferredEncodings(acceptEncoding)
+            : ["*"];
+}
+export function acceptsLanguages(request, ...langs) {
+    const acceptLanguage = request.headers.get("accept-language");
+    return langs.length
+        ? acceptLanguage ? preferredLanguages(acceptLanguage, langs)[0] : langs[0]
+        : acceptLanguage
+            ? preferredLanguages(acceptLanguage)
+            : ["*"];
+}

package/esm/deps/jsr.io/@std/http/1.0.13/user_agent.d.ts

@@ -0,0 +1,200 @@
+/** The browser as described by a user agent string. */
+export interface Browser {
+    /** The major version of a browser. */
+    readonly major: string | undefined;
+    /** The name of a browser. */
+    readonly name: string | undefined;
+    /** The version of a browser. */
+    readonly version: string | undefined;
+}
+/** The device as described by a user agent string. */
+export interface Device {
+    /** The model of the device. */
+    readonly model: string | undefined;
+    /** The type of device. */
+    readonly type: "console" | "embedded" | "mobile" | "tablet" | "smarttv" | "wearable" | undefined;
+    /** The vendor of the device. */
+    readonly vendor: string | undefined;
+}
+/** The browser engine as described by a user agent string. */
+export interface Engine {
+    /** The browser engine name. */
+    readonly name: string | undefined;
+    /** The browser engine version. */
+    readonly version: string | undefined;
+}
+/** The OS as described by a user agent string. */
+export interface Os {
+    /** The OS name. */
+    readonly name: string | undefined;
+    /** The OS version. */
+    readonly version: string | undefined;
+}
+/** The CPU information as described by a user agent string. */
+export interface Cpu {
+    /** The CPU architecture.  */
+    readonly architecture: string | undefined;
+}
+/**
+ * A representation of user agent string, which can be used to determine
+ * environmental information represented by the string. All properties are
+ * determined lazily.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { UserAgent } from "@std/http/user-agent";
+ *
+ * Deno.serve((req) => {
+ *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+ *   return new Response(`Hello, ${userAgent.browser.name}
+ *     on ${userAgent.os.name} ${userAgent.os.version}!`);
+ * });
+ * ```
+ */
+export declare class UserAgent {
+    #private;
+    /**
+     * Constructs a new instance.
+     *
+     * @param ua The user agent string to construct this instance with.
+     */
+    constructor(ua: string | null);
+    /**
+     * The name and version of the browser extracted from the user agent
+     * string.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.browser.name}!`);
+     * });
+     * ```
+     *
+     * @returns An object with information about the user agent's browser.
+     */
+    get browser(): Browser;
+    /**
+     * The architecture of the CPU extracted from the user agent string.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.cpu.architecture}!`);
+     * });
+     * ```
+     *
+     * @returns An object with information about the user agent's CPU.
+     */
+    get cpu(): Cpu;
+    /**
+     * The model, type, and vendor of a device if present in a user agent
+     * string.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.device.model}!`);
+     * });
+     * ```
+     *
+     * @returns An object with information about the user agent's device.
+     */
+    get device(): Device;
+    /**
+     * The name and version of the browser engine in a user agent string.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.engine.name}!`);
+     * });
+     * ```
+     *
+     * @returns An object with information about the user agent's browser engine.
+     */
+    get engine(): Engine;
+    /**
+     * The name and version of the operating system in a user agent string.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.os.name}!`);
+     * });
+     * ```
+     *
+     * @returns An object with information about the user agent's OS.
+     */
+    get os(): Os;
+    /**
+     * A read only version of the user agent string related to the instance.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.ua}!`);
+     * });
+     * ```
+     *
+     * @returns The user agent string.
+     */
+    get ua(): string;
+    /**
+     * Converts the current instance to a JSON representation.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${JSON.stringify(userAgent.toJSON())}!`);
+     * });
+     * ```
+     *
+     * @returns A JSON representation on this user agent instance.
+     */
+    toJSON(): {
+        browser: Browser;
+        cpu: Cpu;
+        device: Device;
+        engine: Engine;
+        os: Os;
+        ua: string;
+    };
+    /**
+     * Converts the current instance to a string.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { UserAgent } from "@std/http/user-agent";
+     *
+     * Deno.serve((req) => {
+     *   const userAgent = new UserAgent(req.headers.get("user-agent") ?? "");
+     *   return new Response(`Hello, ${userAgent.toString()}!`);
+     * });
+     * ```
+     *
+     * @returns The user agent string.
+     */
+    toString(): string;
+}
+//# sourceMappingURL=user_agent.d.ts.map

package/esm/deps/jsr.io/@std/http/1.0.13/user_agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user_agent.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/http/1.0.13/user_agent.ts"],"names":[],"mappings":"AAsEA,uDAAuD;AACvD,MAAM,WAAW,OAAO;IACtB,sCAAsC;IACtC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,sDAAsD;AACtD,MAAM,WAAW,MAAM;IACrB,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EACT,SAAS,GACT,UAAU,GACV,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,UAAU,GACV,SAAS,CAAC;IACd,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC;AAED,8DAA8D;AAC9D,MAAM,WAAW,MAAM;IACrB,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,kCAAkC;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,kDAAkD;AAClD,MAAM,WAAW,EAAE;IACjB,mBAAmB;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,sBAAsB;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,+DAA+D;AAC/D,MAAM,WAAW,GAAG;IAClB,6BAA6B;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3C;AAg1BD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,SAAS;;IAQpB;;;;OAIG;gBACS,EAAE,EAAE,MAAM,GAAG,IAAI;IAI7B;;;;;;;;;;;;;;;OAeG;IACH,IAAI,OAAO,IAAI,OAAO,CASrB;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,GAAG,IAAI,GAAG,CAOb;IAED;;;;;;;;;;;;;;;OAeG;IACH,IAAI,MAAM,IAAI,MAAM,CAOnB;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,MAAM,IAAI,MAAM,CAOnB;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,EAAE,IAAI,EAAE,CAOX;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,EAAE,IAAI,MAAM,CAEf;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,IAAI;QACR,OAAO,EAAE,OAAO,CAAC;QACjB,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,EAAE,EAAE,EAAE,CAAC;QACP,EAAE,EAAE,MAAM,CAAC;KACZ;IAKD;;;;;;;;;;;;;;OAcG;IACH,QAAQ,IAAI,MAAM;CA0EnB"}