@mtkruto/node 0.1.124 → 0.1.126

package/esm/deps/deno.land/std@0.209.0/media_types/get_charset.js

@@ -0,0 +1,37 @@
+// Copyright 2018-2023 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`.
+ *
+ * @example
+ * ```ts
+ * import { getCharset } from "https://deno.land/std@$STD_VERSION/media_types/get_charset.ts";
+ *
+ * getCharset("text/plain"); // `UTF-8`
+ * getCharset("application/foo"); // undefined
+ * getCharset("application/news-checkgroups"); // `US-ASCII`
+ * getCharset("application/news-checkgroups; charset=UTF-8"); // `UTF-8`
+ * ```
+ */
+export function getCharset(type) {
+    try {
+        const [mediaType, params] = parseMediaType(type);
+        if (params && params["charset"]) {
+            return params["charset"];
+        }
+        const entry = db[mediaType];
+        if (entry && entry.charset) {
+            return entry.charset;
+        }
+        if (mediaType.startsWith("text/")) {
+            return "UTF-8";
+        }
+    }
+    catch {
+        // just swallow errors, returning undefined
+    }
+    return undefined;
+}

package/esm/deps/deno.land/std@0.209.0/media_types/parse_media_type.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Parses the media type and any optional parameters, per
+ * [RFC 1521](https://datatracker.ietf.org/doc/html/rfc1521). 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.
+ *
+ * @example
+ * ```ts
+ * import { parseMediaType } from "https://deno.land/std@$STD_VERSION/media_types/parse_media_type.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(
+ *   parseMediaType("application/JSON"),
+ *   [
+ *     "application/json",
+ *     undefined
+ *   ]
+ * );
+ *
+ * assertEquals(
+ *   parseMediaType("text/html; charset=UTF-8"),
+ *   [
+ *     "text/html",
+ *     { charset: "UTF-8" },
+ *   ]
+ * );
+ * ```
+ */
+export declare function parseMediaType(v: string): [mediaType: string, params: Record<string, string> | undefined];

package/esm/deps/deno.land/std@0.209.0/media_types/parse_media_type.js

@@ -0,0 +1,122 @@
+// Copyright 2018-2023 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
+ * [RFC 1521](https://datatracker.ietf.org/doc/html/rfc1521). 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.
+ *
+ * @example
+ * ```ts
+ * import { parseMediaType } from "https://deno.land/std@$STD_VERSION/media_types/parse_media_type.ts";
+ * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
+ *
+ * assertEquals(
+ *   parseMediaType("application/JSON"),
+ *   [
+ *     "application/json",
+ *     undefined
+ *   ]
+ * );
+ *
+ * assertEquals(
+ *   parseMediaType("text/html; charset=UTF-8"),
+ *   [
+ *     "text/html",
+ *     { charset: "UTF-8" },
+ *   ]
+ * );
+ * ```
+ */
+export function parseMediaType(v) {
+    const [base] = v.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();
+    v = v.slice(base.length);
+    while (v.length) {
+        v = v.trimStart();
+        if (v.length === 0) {
+            break;
+        }
+        const [key, value, rest] = consumeMediaParam(v);
+        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;
+        v = 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 v = pieceMap[singlePartKey];
+        if (v) {
+            const decv = decode2331Encoding(v);
+            if (decv) {
+                params[key] = decv;
+            }
+            continue;
+        }
+        str = "";
+        let valid = false;
+        for (let n = 0;; n++) {
+            const simplePart = `${key}*${n}`;
+            let v = pieceMap[simplePart];
+            if (v) {
+                valid = true;
+                str += v;
+                continue;
+            }
+            const encodedPart = `${simplePart}*`;
+            v = pieceMap[encodedPart];
+            if (!v) {
+                break;
+            }
+            valid = true;
+            if (n === 0) {
+                const decv = decode2331Encoding(v);
+                if (decv) {
+                    str += decv;
+                }
+            }
+            else {
+                const decv = decodeURI(v);
+                str += decv;
+            }
+        }
+        if (valid) {
+            params[key] = str;
+        }
+    }
+    return Object.keys(params).length
+        ? [mediaType, params]
+        : [mediaType, undefined];
+}

package/esm/deps/deno.land/std@0.209.0/media_types/type_by_extension.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns the media type associated with the file extension. Values are
+ * normalized to lower case and matched irrespective of a leading `.`.
+ *
+ * When `extension` has no associated type, the function returns `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { typeByExtension } from "https://deno.land/std@$STD_VERSION/media_types/type_by_extension.ts";
+ *
+ * typeByExtension("js"); // `application/json`
+ * typeByExtension(".HTML"); // `text/html`
+ * typeByExtension("foo"); // undefined
+ * typeByExtension("file.json"); // undefined
+ * ```
+ */
+export declare function typeByExtension(extension: string): string | undefined;

package/esm/deps/deno.land/std@0.209.0/media_types/type_by_extension.js

@@ -0,0 +1,24 @@
+// Copyright 2018-2023 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. Values are
+ * normalized to lower case and matched irrespective of a leading `.`.
+ *
+ * When `extension` has no associated type, the function returns `undefined`.
+ *
+ * @example
+ * ```ts
+ * import { typeByExtension } from "https://deno.land/std@$STD_VERSION/media_types/type_by_extension.ts";
+ *
+ * typeByExtension("js"); // `application/json`
+ * typeByExtension(".HTML"); // `text/html`
+ * typeByExtension("foo"); // undefined
+ * typeByExtension("file.json"); // undefined
+ * ```
+ */
+export function typeByExtension(extension) {
+    extension = extension.startsWith(".") ? extension.slice(1) : extension;
+    // @ts-ignore workaround around denoland/dnt#148
+    return types.get(extension.toLowerCase());
+}