@mtkruto/node 0.2.30 → 0.2.31

package/esm/deps/jsr.io/@std/media-types/1.0.2/all_extensions.js

@@ -0,0 +1,34 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { parseMediaType } from "./parse_media_type.js";
+import { extensions } from "./_db.js";
+/**
+ * Returns all the extensions known to be associated with the media type `type`, or
+ * `undefined` if no extensions are found.
+ *
+ * Extensions are returned without a leading `.`.
+ *
+ * @param type The media type to get the extensions for.
+ *
+ * @returns The extensions for the given media type, or `undefined` if no
+ * extensions are found.
+ *
+ * @example Usage
+ * ```ts
+ * import { allExtensions } from "@std/media-types/all-extensions";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(allExtensions("application/json"), ["json", "map"]);
+ * assertEquals(allExtensions("text/html; charset=UTF-8"), ["html", "htm", "shtml"]);
+ * assertEquals(allExtensions("application/foo"), undefined);
+ * ```
+ */
+export function allExtensions(type) {
+    try {
+        const [mediaType] = parseMediaType(type);
+        return extensions.get(mediaType);
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+}

package/esm/deps/jsr.io/@std/media-types/1.0.2/content_type.d.ts

@@ -0,0 +1,43 @@
+import type { db } from "./_db.js";
+/** MIME-types database. */
+export type DB = typeof db;
+/** Maps content types to their corresponding file extensions. */
+export type ContentTypeToExtension = {
+    [K in keyof DB]: DB[K] extends {
+        "extensions": readonly string[];
+    } ? DB[K]["extensions"][number] : never;
+};
+/** Known extension or type. Used in {@linkcode contentType}. */
+export type KnownExtensionOrType = keyof ContentTypeToExtension | ContentTypeToExtension[keyof ContentTypeToExtension] | `.${ContentTypeToExtension[keyof ContentTypeToExtension]}`;
+/**
+ * Returns the full `Content-Type` or `Content-Disposition` header value for the
+ * given extension or media type.
+ *
+ * The function will treat the `extensionOrType` as a media type when it
+ * contains a `/`, otherwise it will process it as an extension, with or without
+ * the leading `.`.
+ *
+ * Returns `undefined` if unable to resolve the media type.
+ *
+ * @typeParam T Type of the extension or media type to resolve.
+ *
+ * @param extensionOrType The extension or media type to resolve.
+ *
+ * @returns The full `Content-Type` or `Content-Disposition` header value, or
+ * `undefined` if unable to resolve the media type.
+ *
+ * @example Usage
+ * ```ts
+ * import { contentType } from "@std/media-types/content-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(contentType(".json"), "application/json; charset=UTF-8");
+ * assertEquals(contentType("text/html"), "text/html; charset=UTF-8");
+ * assertEquals(contentType("text/html; charset=UTF-8"), "text/html; charset=UTF-8");
+ * assertEquals(contentType("txt"), "text/plain; charset=UTF-8");
+ * assertEquals(contentType("foo"), undefined);
+ * assertEquals(contentType("file.json"), undefined);
+ * ```
+ */
+export declare function contentType<T extends (string & {}) | KnownExtensionOrType>(extensionOrType: T): Lowercase<T> extends KnownExtensionOrType ? string : string | undefined;
+//# sourceMappingURL=content_type.d.ts.map

package/esm/deps/jsr.io/@std/media-types/1.0.2/content_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content_type.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/media-types/1.0.2/content_type.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC,2BAA2B;AAC3B,MAAM,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC;AAC3B,iEAAiE;AACjE,MAAM,MAAM,sBAAsB,GAAG;KAIlC,CAAC,IAAI,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS;QAAE,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE,GAC9D,EAAE,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,GAC3B,KAAK;CACV,CAAC;AAEF,gEAAgE;AAChE,MAAM,MAAM,oBAAoB,GAC5B,MAAM,sBAAsB,GAC5B,sBAAsB,CAAC,MAAM,sBAAsB,CAAC,GACpD,IAAI,sBAAsB,CAAC,MAAM,sBAAsB,CAAC,EAAE,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CAGzB,CAAC,SAAS,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,oBAAoB,EAE9C,eAAe,EAAE,CAAC,GACjB,SAAS,CAAC,CAAC,CAAC,SAAS,oBAAoB,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAqBzE"}

package/esm/deps/jsr.io/@std/media-types/1.0.2/content_type.js

@@ -0,0 +1,57 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { parseMediaType } from "./parse_media_type.js";
+import { getCharset } from "./get_charset.js";
+import { formatMediaType } from "./format_media_type.js";
+import { typeByExtension } from "./type_by_extension.js";
+/**
+ * Returns the full `Content-Type` or `Content-Disposition` header value for the
+ * given extension or media type.
+ *
+ * The function will treat the `extensionOrType` as a media type when it
+ * contains a `/`, otherwise it will process it as an extension, with or without
+ * the leading `.`.
+ *
+ * Returns `undefined` if unable to resolve the media type.
+ *
+ * @typeParam T Type of the extension or media type to resolve.
+ *
+ * @param extensionOrType The extension or media type to resolve.
+ *
+ * @returns The full `Content-Type` or `Content-Disposition` header value, or
+ * `undefined` if unable to resolve the media type.
+ *
+ * @example Usage
+ * ```ts
+ * import { contentType } from "@std/media-types/content-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(contentType(".json"), "application/json; charset=UTF-8");
+ * assertEquals(contentType("text/html"), "text/html; charset=UTF-8");
+ * assertEquals(contentType("text/html; charset=UTF-8"), "text/html; charset=UTF-8");
+ * assertEquals(contentType("txt"), "text/plain; charset=UTF-8");
+ * assertEquals(contentType("foo"), undefined);
+ * assertEquals(contentType("file.json"), undefined);
+ * ```
+ */
+export function contentType(extensionOrType) {
+    try {
+        const [mediaType, params = {}] = extensionOrType.includes("/")
+            ? parseMediaType(extensionOrType)
+            : [typeByExtension(extensionOrType), undefined];
+        if (!mediaType) {
+            return undefined;
+        }
+        if (!("charset" in params)) {
+            const charset = getCharset(mediaType);
+            if (charset) {
+                params.charset = charset;
+            }
+        }
+        return formatMediaType(mediaType, params);
+    }
+    catch {
+        // just swallow returning undefined
+    }
+    return undefined;
+}

package/esm/deps/jsr.io/@std/media-types/1.0.2/extension.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Returns the most relevant extension for the given media type, or `undefined`
+ * if no extension can be found.
+ *
+ * Extensions are returned without a leading `.`.
+ *
+ * @param type The media type to get the extension for.
+ *
+ * @returns The extension for the given media type, or `undefined` if no
+ * extension is found.
+ *
+ * @example Usage
+ * ```ts
+ * import { extension } from "@std/media-types/extension";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(extension("text/plain"), "txt");
+ * assertEquals(extension("application/json"), "json");
+ * assertEquals(extension("text/html; charset=UTF-8"), "html");
+ * assertEquals(extension("application/foo"), undefined);
+ * ```
+ */
+export declare function extension(type: string): string | undefined;
+//# sourceMappingURL=extension.d.ts.map

package/esm/deps/jsr.io/@std/media-types/1.0.2/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/media-types/1.0.2/extension.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D"}

package/esm/deps/jsr.io/@std/media-types/1.0.2/extension.js

@@ -0,0 +1,28 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { allExtensions } from "./all_extensions.js";
+/**
+ * Returns the most relevant extension for the given media type, or `undefined`
+ * if no extension can be found.
+ *
+ * Extensions are returned without a leading `.`.
+ *
+ * @param type The media type to get the extension for.
+ *
+ * @returns The extension for the given media type, or `undefined` if no
+ * extension is found.
+ *
+ * @example Usage
+ * ```ts
+ * import { extension } from "@std/media-types/extension";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(extension("text/plain"), "txt");
+ * assertEquals(extension("application/json"), "json");
+ * assertEquals(extension("text/html; charset=UTF-8"), "html");
+ * assertEquals(extension("application/foo"), undefined);
+ * ```
+ */
+export function extension(type) {
+    return allExtensions(type)?.[0];
+}

package/esm/deps/jsr.io/@std/media-types/1.0.2/format_media_type.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Serializes the media type and the optional parameters as a media type
+ * conforming to {@link https://www.rfc-editor.org/rfc/rfc2045.html | RFC 2045} and
+ * {@link https://www.rfc-editor.org/rfc/rfc2616.html | RFC 2616}.
+ *
+ * The type and parameter names are written in lower-case.
+ *
+ * When any of the arguments results in a standard violation then the return
+ * value will be an empty string (`""`).
+ *
+ * @param type The media type to serialize.
+ * @param param Optional parameters to serialize.
+ *
+ * @returns The serialized media type.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { formatMediaType } from "@std/media-types/format-media-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(formatMediaType("text/plain"), "text/plain");
+ * ```
+ *
+ * @example With parameters
+ * ```ts
+ * import { formatMediaType } from "@std/media-types/format-media-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(formatMediaType("text/plain", { charset: "UTF-8" }), "text/plain; charset=UTF-8");
+ * ```
+ */
+export declare function formatMediaType(type: string, param?: Record<string, string> | Iterable<[string, string]>): string;
+//# sourceMappingURL=format_media_type.d.ts.map

package/esm/deps/jsr.io/@std/media-types/1.0.2/format_media_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format_media_type.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/media-types/1.0.2/format_media_type.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC1D,MAAM,CA8CR"}

package/esm/deps/jsr.io/@std/media-types/1.0.2/format_media_type.js

@@ -0,0 +1,77 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { isIterator, isToken, needsEncoding } from "./_util.js";
+/**
+ * Serializes the media type and the optional parameters as a media type
+ * conforming to {@link https://www.rfc-editor.org/rfc/rfc2045.html | RFC 2045} and
+ * {@link https://www.rfc-editor.org/rfc/rfc2616.html | RFC 2616}.
+ *
+ * The type and parameter names are written in lower-case.
+ *
+ * When any of the arguments results in a standard violation then the return
+ * value will be an empty string (`""`).
+ *
+ * @param type The media type to serialize.
+ * @param param Optional parameters to serialize.
+ *
+ * @returns The serialized media type.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { formatMediaType } from "@std/media-types/format-media-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(formatMediaType("text/plain"), "text/plain");
+ * ```
+ *
+ * @example With parameters
+ * ```ts
+ * import { formatMediaType } from "@std/media-types/format-media-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(formatMediaType("text/plain", { charset: "UTF-8" }), "text/plain; charset=UTF-8");
+ * ```
+ */
+export function formatMediaType(type, param) {
+    let serializedMediaType = "";
+    const [major = "", sub] = type.split("/");
+    if (!sub) {
+        if (!isToken(type)) {
+            return "";
+        }
+        serializedMediaType += type.toLowerCase();
+    }
+    else {
+        if (!isToken(major) || !isToken(sub)) {
+            return "";
+        }
+        serializedMediaType += `${major.toLowerCase()}/${sub.toLowerCase()}`;
+    }
+    if (param) {
+        param = isIterator(param) ? Object.fromEntries(param) : param;
+        const attrs = Object.keys(param);
+        attrs.sort();
+        for (const attribute of attrs) {
+            if (!isToken(attribute)) {
+                return "";
+            }
+            const value = param[attribute];
+            serializedMediaType += `; ${attribute.toLowerCase()}`;
+            const needEnc = needsEncoding(value);
+            if (needEnc) {
+                serializedMediaType += "*";
+            }
+            serializedMediaType += "=";
+            if (needEnc) {
+                serializedMediaType += `utf-8''${encodeURIComponent(value)}`;
+                continue;
+            }
+            if (isToken(value)) {
+                serializedMediaType += value;
+                continue;
+            }
+            serializedMediaType += `"${value.replace(/["\\]/gi, (m) => `\\${m}`)}"`;
+        }
+    }
+    return serializedMediaType;
+}

package/esm/deps/jsr.io/@std/media-types/1.0.2/get_charset.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Given a media type or header value, identify the encoding charset. If the
+ * charset cannot be determined, the function returns `undefined`.
+ *
+ * @param type The media type or header value to get the charset for.
+ *
+ * @returns The charset for the given media type or header value, or `undefined`
+ * if the charset cannot be determined.
+ *
+ * @example Usage
+ * ```ts
+ * import { getCharset } from "@std/media-types/get-charset";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(getCharset("text/plain"), "UTF-8");
+ * assertEquals(getCharset("application/foo"), undefined);
+ * assertEquals(getCharset("application/news-checkgroups"), "US-ASCII");
+ * assertEquals(getCharset("application/news-checkgroups; charset=UTF-8"), "UTF-8");
+ * ```
+ */
+export declare function getCharset(type: string): string | undefined;
+//# sourceMappingURL=get_charset.d.ts.map

package/esm/deps/jsr.io/@std/media-types/1.0.2/get_charset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get_charset.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/media-types/1.0.2/get_charset.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiB3D"}

package/esm/deps/jsr.io/@std/media-types/1.0.2/get_charset.js

@@ -0,0 +1,43 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { parseMediaType } from "./parse_media_type.js";
+import { db } from "./_db.js";
+/**
+ * Given a media type or header value, identify the encoding charset. If the
+ * charset cannot be determined, the function returns `undefined`.
+ *
+ * @param type The media type or header value to get the charset for.
+ *
+ * @returns The charset for the given media type or header value, or `undefined`
+ * if the charset cannot be determined.
+ *
+ * @example Usage
+ * ```ts
+ * import { getCharset } from "@std/media-types/get-charset";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(getCharset("text/plain"), "UTF-8");
+ * assertEquals(getCharset("application/foo"), undefined);
+ * assertEquals(getCharset("application/news-checkgroups"), "US-ASCII");
+ * assertEquals(getCharset("application/news-checkgroups; charset=UTF-8"), "UTF-8");
+ * ```
+ */
+export function getCharset(type) {
+    try {
+        const [mediaType, params] = parseMediaType(type);
+        if (params?.charset) {
+            return params.charset;
+        }
+        const entry = db[mediaType];
+        if (entry?.charset) {
+            return entry.charset;
+        }
+        if (mediaType.startsWith("text/")) {
+            return "UTF-8";
+        }
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+    return undefined;
+}

package/esm/deps/jsr.io/@std/media-types/1.0.2/parse_media_type.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Parses the media type and any optional parameters, per
+ * {@link https://www.rfc-editor.org/rfc/rfc1521.html | RFC 1521}.
+ *
+ * Media types are the values in `Content-Type` and `Content-Disposition`
+ * headers. On success the function returns a tuple where the first element is
+ * the media type and the second element is the optional parameters or
+ * `undefined` if there are none.
+ *
+ * The function will throw if the parsed value is invalid.
+ *
+ * The returned media type will be normalized to be lower case, and returned
+ * params keys will be normalized to lower case, but preserves the casing of
+ * the value.
+ *
+ * @param type The media type to parse.
+ *
+ * @returns A tuple where the first element is the media type and the second
+ * element is the optional parameters or `undefined` if there are none.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseMediaType } from "@std/media-types/parse-media-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(parseMediaType("application/JSON"), ["application/json", undefined]);
+ * assertEquals(parseMediaType("text/html; charset=UTF-8"), ["text/html", { charset: "UTF-8" }]);
+ * ```
+ */
+export declare function parseMediaType(type: string): [mediaType: string, params: Record<string, string> | undefined];
+//# sourceMappingURL=parse_media_type.d.ts.map

package/esm/deps/jsr.io/@std/media-types/1.0.2/parse_media_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse_media_type.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/media-types/1.0.2/parse_media_type.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,GACX,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC,CAqFjE"}

package/esm/deps/jsr.io/@std/media-types/1.0.2/parse_media_type.js

@@ -0,0 +1,113 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { consumeMediaParam, decode2331Encoding } from "./_util.js";
+/**
+ * Parses the media type and any optional parameters, per
+ * {@link https://www.rfc-editor.org/rfc/rfc1521.html | RFC 1521}.
+ *
+ * Media types are the values in `Content-Type` and `Content-Disposition`
+ * headers. On success the function returns a tuple where the first element is
+ * the media type and the second element is the optional parameters or
+ * `undefined` if there are none.
+ *
+ * The function will throw if the parsed value is invalid.
+ *
+ * The returned media type will be normalized to be lower case, and returned
+ * params keys will be normalized to lower case, but preserves the casing of
+ * the value.
+ *
+ * @param type The media type to parse.
+ *
+ * @returns A tuple where the first element is the media type and the second
+ * element is the optional parameters or `undefined` if there are none.
+ *
+ * @example Usage
+ * ```ts
+ * import { parseMediaType } from "@std/media-types/parse-media-type";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(parseMediaType("application/JSON"), ["application/json", undefined]);
+ * assertEquals(parseMediaType("text/html; charset=UTF-8"), ["text/html", { charset: "UTF-8" }]);
+ * ```
+ */
+export function parseMediaType(type) {
+    const [base] = type.split(";");
+    const mediaType = base.toLowerCase().trim();
+    const params = {};
+    // Map of base parameter name -> parameter name -> value
+    // for parameters containing a '*' character.
+    const continuation = new Map();
+    type = type.slice(base.length);
+    while (type.length) {
+        type = type.trimStart();
+        if (type.length === 0) {
+            break;
+        }
+        const [key, value, rest] = consumeMediaParam(type);
+        if (!key) {
+            if (rest.trim() === ";") {
+                // ignore trailing semicolons
+                break;
+            }
+            throw new TypeError("Invalid media parameter.");
+        }
+        let pmap = params;
+        const [baseName, rest2] = key.split("*");
+        if (baseName && rest2 !== undefined) {
+            if (!continuation.has(baseName)) {
+                continuation.set(baseName, {});
+            }
+            pmap = continuation.get(baseName);
+        }
+        if (key in pmap) {
+            throw new TypeError("Duplicate key parsed.");
+        }
+        pmap[key] = value;
+        type = rest;
+    }
+    // Stitch together any continuations or things with stars
+    // (i.e. RFC 2231 things with stars: "foo*0" or "foo*")
+    let str = "";
+    for (const [key, pieceMap] of continuation) {
+        const singlePartKey = `${key}*`;
+        const type = pieceMap[singlePartKey];
+        if (type) {
+            const decv = decode2331Encoding(type);
+            if (decv) {
+                params[key] = decv;
+            }
+            continue;
+        }
+        str = "";
+        let valid = false;
+        for (let n = 0;; n++) {
+            const simplePart = `${key}*${n}`;
+            let type = pieceMap[simplePart];
+            if (type) {
+                valid = true;
+                str += type;
+                continue;
+            }
+            const encodedPart = `${simplePart}*`;
+            type = pieceMap[encodedPart];
+            if (!type) {
+                break;
+            }
+            valid = true;
+            if (n === 0) {
+                const decv = decode2331Encoding(type);
+                if (decv) {
+                    str += decv;
+                }
+            }
+            else {
+                const decv = decodeURI(type);
+                str += decv;
+            }
+        }
+        if (valid) {
+            params[key] = str;
+        }
+    }
+    return [mediaType, Object.keys(params).length ? params : undefined];
+}

package/esm/deps/jsr.io/@std/media-types/1.0.2/type_by_extension.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Returns the media type associated with the file extension, or `undefined` if
+ * no media type is found.
+ *
+ * Values are normalized to lower case and matched irrespective of a leading
+ * `.`.
+ *
+ * @param extension The file extension to get the media type for.
+ *
+ * @returns The media type associated with the file extension, or `undefined` if
+ * no media type is found.
+ *
+ * @example Usage
+ * ```ts
+ * import { typeByExtension } from "@std/media-types/type-by-extension";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(typeByExtension("js"), "text/javascript");
+ * assertEquals(typeByExtension(".HTML"), "text/html");
+ * assertEquals(typeByExtension("foo"), undefined);
+ * assertEquals(typeByExtension("file.json"), undefined);
+ * ```
+ */
+export declare function typeByExtension(extension: string): string | undefined;
+//# sourceMappingURL=type_by_extension.d.ts.map

package/esm/deps/jsr.io/@std/media-types/1.0.2/type_by_extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_by_extension.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/media-types/1.0.2/type_by_extension.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIrE"}

package/esm/deps/jsr.io/@std/media-types/1.0.2/type_by_extension.js

@@ -0,0 +1,31 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { types } from "./_db.js";
+/**
+ * Returns the media type associated with the file extension, or `undefined` if
+ * no media type is found.
+ *
+ * Values are normalized to lower case and matched irrespective of a leading
+ * `.`.
+ *
+ * @param extension The file extension to get the media type for.
+ *
+ * @returns The media type associated with the file extension, or `undefined` if
+ * no media type is found.
+ *
+ * @example Usage
+ * ```ts
+ * import { typeByExtension } from "@std/media-types/type-by-extension";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(typeByExtension("js"), "text/javascript");
+ * assertEquals(typeByExtension(".HTML"), "text/html");
+ * assertEquals(typeByExtension("foo"), undefined);
+ * assertEquals(typeByExtension("file.json"), undefined);
+ * ```
+ */
+export function typeByExtension(extension) {
+    extension = extension.startsWith(".") ? extension.slice(1) : extension;
+    // @ts-ignore Work around https://github.com/denoland/dnt/issues/148
+    return types.get(extension.toLowerCase());
+}