@mtkruto/node 0.1.125 → 0.1.126

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_match.js

@@ -6,6 +6,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `actual` match RegExp `expected`. If not
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_match.ts";
+ *
+ * assertMatch("Raptor", RegExp(/Raptor/)); // Doesn't throw
+ * assertMatch("Denosaurus", RegExp(/Raptor/)); // Throws
+ * ```
  */
 function assertMatch(actual, expected, msg) {
     if (!expected.test(actual)) {

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_equals.d.ts

@@ -8,7 +8,8 @@
  * ```ts
  * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
  *
- * assertNotEquals<number>(1, 2)
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
  * ```
  */
 export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_equals.js

@@ -14,7 +14,8 @@ const assertion_error_js_1 = require("./assertion_error.js");
  * ```ts
  * import { assertNotEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_equals.ts";
  *
- * assertNotEquals<number>(1, 2)
+ * assertNotEquals(1, 2); // Doesn't throw
+ * assertNotEquals(1, 1); // Throws
  * ```
  */
 function assertNotEquals(actual, expected, msg) {

package/script/deps/deno.land/std@0.209.0/assert/assert_not_instance_of.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `obj` is not an instance of `type`.
+ * If so, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_not_instance_of.ts";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
+ */
+export declare function assertNotInstanceOf<A, T>(actual: A, unexpectedType: new (...args: any[]) => T, msg?: string): asserts actual is Exclude<A, T>;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_instance_of.js

@@ -6,6 +6,14 @@ const assert_false_js_1 = require("./assert_false.js");
 /**
  * Make an assertion that `obj` is not an instance of `type`.
  * If so, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotInstanceOf } from "https://deno.land/std@$STD_VERSION/assert/assert_not_instance_of.ts";
+ *
+ * assertNotInstanceOf(new Date(), Number); // Doesn't throw
+ * assertNotInstanceOf(new Date(), Date); // Throws
+ * ```
  */
 function assertNotInstanceOf(actual, 
 // deno-lint-ignore no-explicit-any

package/script/deps/deno.land/std@0.209.0/assert/assert_not_match.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_not_match.ts";
+ *
+ * assertNotMatch("Denosaurus", RegExp(/Raptor/)); // Doesn't throw
+ * assertNotMatch("Raptor", RegExp(/Raptor/)); // Throws
+ * ```
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_match.js

@@ -6,6 +6,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that `actual` not match RegExp `expected`. If match
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertNotMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_not_match.ts";
+ *
+ * assertNotMatch("Denosaurus", RegExp(/Raptor/)); // Doesn't throw
+ * assertNotMatch("Raptor", RegExp(/Raptor/)); // Throws
+ * ```
  */
 function assertNotMatch(actual, expected, msg) {
     if (expected.test(actual)) {

package/{esm/deps/deno.land/std@0.208.0 → script/deps/deno.land/std@0.209.0}/assert/assert_not_strict_equals.d.ts

@@ -2,10 +2,12 @@
  * Make an assertion that `actual` and `expected` are not strictly equal.
  * If the values are strictly equal then throw.
  *
+ * @example
  * ```ts
  * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
  *
- * assertNotStrictEquals(1, 1)
+ * assertNotStrictEquals(1, 1); // Doesn't throw
+ * assertNotStrictEquals(1, 2); // Throws
  * ```
  */
 export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_not_strict_equals.js

@@ -8,10 +8,12 @@ const _format_js_1 = require("./_format.js");
  * Make an assertion that `actual` and `expected` are not strictly equal.
  * If the values are strictly equal then throw.
  *
+ * @example
  * ```ts
  * import { assertNotStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_not_strict_equals.ts";
  *
- * assertNotStrictEquals(1, 1)
+ * assertNotStrictEquals(1, 1); // Doesn't throw
+ * assertNotStrictEquals(1, 2); // Throws
  * ```
  */
 function assertNotStrictEquals(actual, expected, msg) {

package/script/deps/deno.land/std@0.209.0/assert/assert_object_match.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object,
+ * deeply. If not, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertObjectMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_object_match.ts";
+ *
+ * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
+ * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
+ * ```
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_object_match.js

@@ -4,8 +4,16 @@ exports.assertObjectMatch = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assert_equals_js_1 = require("./assert_equals.js");
 /**
- * Make an assertion that `actual` object is a subset of `expected` object, deeply.
- * If not, then throw.
+ * Make an assertion that `actual` object is a subset of `expected` object,
+ * deeply. If not, then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertObjectMatch } from "https://deno.land/std@$STD_VERSION/assert/assert_object_match.ts";
+ *
+ * assertObjectMatch({ foo: "bar" }, { foo: "bar" }); // Doesn't throw
+ * assertObjectMatch({ foo: "bar" }, { foo: "baz" }); // Throws
+ * ```
  */
 function assertObjectMatch(
 // deno-lint-ignore no-explicit-any

package/script/deps/deno.land/std@0.209.0/assert/assert_rejects.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
+ *
+ * await assertRejects(async () => Promise.reject(new Error())); // Doesn't throw
+ * await assertRejects(async () => console.log("Hello world")); // Throws
+ * ```
+ */
+export declare function assertRejects(fn: () => PromiseLike<unknown>, msg?: string): Promise<unknown>;
+/**
+ * Executes a function which returns a promise, expecting it to reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted.
+ *
+ * @example
+ * ```ts
+ * import { assertRejects } from "https://deno.land/std@$STD_VERSION/assert/assert_rejects.ts";
+ *
+ * await assertRejects(async () => Promise.reject(new Error()), Error); // Doesn't throw
+ * await assertRejects(async () => Promise.reject(new Error()), SyntaxError); // Throws
+ * ```
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => PromiseLike<unknown>, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<E>;

package/{esm/deps/deno.land/std@0.208.0 → script/deps/deno.land/std@0.209.0}/assert/assert_strict_equals.d.ts

@@ -6,18 +6,13 @@
  * ```ts
  * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_strict_equals.ts";
  *
- * Deno.test("isStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = a;
- *   assertStrictEquals(a, b);
- * });
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
  *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
  * ```
  */
 export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_strict_equals.js

@@ -15,18 +15,13 @@ const colors_js_1 = require("../fmt/colors.js");
  * ```ts
  * import { assertStrictEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_strict_equals.ts";
  *
- * Deno.test("isStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = a;
- *   assertStrictEquals(a, b);
- * });
+ * const a = {};
+ * const b = a;
+ * assertStrictEquals(a, b); // Doesn't throw
  *
- * // This test fails
- * Deno.test("isNotStrictlyEqual", function (): void {
- *   const a = {};
- *   const b = {};
- *   assertStrictEquals(a, b);
- * });
+ * const c = {};
+ * const d = {};
+ * assertStrictEquals(c, d); // Throws
  * ```
  */
 function assertStrictEquals(actual, expected, msg) {

package/script/deps/deno.land/std@0.209.0/assert/assert_string_includes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStringIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_string_includes.ts";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_string_includes.js

@@ -6,6 +6,14 @@ const assertion_error_js_1 = require("./assertion_error.js");
 /**
  * Make an assertion that actual includes expected. If not
  * then throw.
+ *
+ * @example
+ * ```ts
+ * import { assertStringIncludes } from "https://deno.land/std@$STD_VERSION/assert/assert_string_includes.ts";
+ *
+ * assertStringIncludes("Hello", "ello"); // Doesn't throw
+ * assertStringIncludes("Hello", "world"); // Throws
+ * ```
  */
 function assertStringIncludes(actual, expected, msg) {
     if (!actual.includes(expected)) {

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assert_throws.d.ts

@@ -6,18 +6,8 @@
  * ```ts
  * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
  *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   });
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
+ * assertThrows(() => { throw new TypeError("hello world!"); }); // Doesn't throw
+ * assertThrows(() => console.log("hello world!")); // Throws
  * ```
  */
 export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
@@ -30,25 +20,8 @@ export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
  * ```ts
  * import { assertThrows } from "https://deno.land/std@$STD_VERSION/assert/assert_throws.ts";
  *
- * Deno.test("doesThrow", function (): void {
- *   assertThrows((): void => {
- *     throw new TypeError("hello world!");
- *   }, TypeError);
- *   assertThrows(
- *     (): void => {
- *       throw new TypeError("hello world!");
- *     },
- *     TypeError,
- *     "hello",
- *   );
- * });
- *
- * // This test will not pass.
- * Deno.test("fails", function (): void {
- *   assertThrows((): void => {
- *     console.log("Hello world");
- *   });
- * });
+ * assertThrows(() => { throw new TypeError("hello world!"); }, TypeError); // Doesn't throw
+ * assertThrows(() => { throw new TypeError("hello world!"); }, RangeError); // Throws
  * ```
  */
 export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: new (...args: any[]) => E, msgIncludes?: string, msg?: string): E;

package/script/deps/deno.land/std@0.209.0/assert/assertion_error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message: string);
+}

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/assertion_error.js

@@ -1,16 +1,22 @@
 "use strict";
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssertionError = void 0;
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
 class AssertionError extends Error {
+    /** Constructs a new instance. */
     constructor(message) {
         super(message);
-        Object.defineProperty(this, "name", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "AssertionError"
-        });
+        this.name = "AssertionError";
     }
 }
 exports.AssertionError = AssertionError;

package/script/deps/deno.land/std@0.209.0/assert/equal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ *
+ * @example
+ * ```ts
+ * import { equal } from "https://deno.land/std@$STD_VERSION/assert/equal.ts";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
+ */
+export declare function equal(c: unknown, d: unknown): boolean;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/equal.js

@@ -14,6 +14,14 @@ function constructorsEqual(a, b) {
  * Deep equality comparison used in assertions
  * @param c actual value
  * @param d expected value
+ *
+ * @example
+ * ```ts
+ * import { equal } from "https://deno.land/std@$STD_VERSION/assert/equal.ts";
+ *
+ * equal({ foo: "bar" }, { foo: "bar" }); // Returns `true`
+ * equal({ foo: "bar" }, { foo: "baz" }); // Returns `false
+ * ```
  */
 function equal(c, d) {
     const seen = new Map();

package/script/deps/deno.land/std@0.209.0/assert/fail.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
+ */
+export declare function fail(msg?: string): never;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/fail.js

@@ -4,7 +4,14 @@ exports.fail = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assert_js_1 = require("./assert.js");
 /**
- * Forcefully throws a failed assertion
+ * Forcefully throws a failed assertion.
+ *
+ * @example
+ * ```ts
+ * import { fail } from "https://deno.land/std@$STD_VERSION/assert/fail.ts";
+ *
+ * fail("Deliberately failed!"); // Throws
+ * ```
  */
 function fail(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";

package/script/deps/deno.land/std@0.209.0/assert/unimplemented.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example
+ * ```ts
+ * import { unimplemented } from "https://deno.land/std@$STD_VERSION/assert/unimplemented.ts";
+ *
+ * unimplemented(); // Throws
+ * ```
+ */
+export declare function unimplemented(msg?: string): never;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unimplemented.js

@@ -3,7 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.unimplemented = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assertion_error_js_1 = require("./assertion_error.js");
-/** Use this to stub out methods that will throw when invoked. */
+/**
+ * Use this to stub out methods that will throw when invoked.
+ *
+ * @example
+ * ```ts
+ * import { unimplemented } from "https://deno.land/std@$STD_VERSION/assert/unimplemented.ts";
+ *
+ * unimplemented(); // Throws
+ * ```
+ */
 function unimplemented(msg) {
     const msgSuffix = msg ? `: ${msg}` : ".";
     throw new assertion_error_js_1.AssertionError(`Unimplemented${msgSuffix}`);

package/script/deps/deno.land/std@0.209.0/assert/unreachable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
+export declare function unreachable(): never;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/assert/unreachable.js

@@ -3,7 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.unreachable = void 0;
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 const assertion_error_js_1 = require("./assertion_error.js");
-/** Use this to assert unreachable code. */
+/**
+ * Use this to assert unreachable code.
+ *
+ * @example
+ * ```ts
+ * import { unreachable } from "https://deno.land/std@$STD_VERSION/assert/unreachable.ts";
+ *
+ * unreachable(); // Throws
+ * ```
+ */
 function unreachable() {
     throw new assertion_error_js_1.AssertionError("unreachable");
 }

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/encoding/base64.d.ts

@@ -1,23 +1,39 @@
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
- *
  * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
  * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
  */
 export declare const encode: typeof encodeBase64;
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
- *
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
  */
 export declare const decode: typeof decodeBase64;
 /**
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export declare function encodeBase64(data: ArrayBuffer | Uint8Array | string): string;
 /**
- * Decodes a given RFC4648 base64 encoded string
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 export declare function decodeBase64(b64: string): Uint8Array;

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/encoding/base64.js

@@ -5,28 +5,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decodeBase64 = exports.encodeBase64 = exports.decode = exports.encode = void 0;
 const _util_js_1 = require("./_util.js");
 /**
- * {@linkcode encodeBase64} and {@linkcode decodeBase64} for
- * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ * Utilities for
+ * [base64]{@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ * encoding and decoding.
  *
  * This module is browser compatible.
  *
- * @example
- * ```ts
- * import {
- *   decodeBase64,
- *   encodeBase64,
- * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
- *
- * const b64Repr = "Zm9vYg==";
- *
- * const binaryData = decodeBase64(b64Repr);
- * console.log(binaryData);
- * // => Uint8Array [ 102, 111, 111, 98 ]
- *
- * console.log(encodeBase64(binaryData));
- * // => Zm9vYg==
- * ```
- *
  * @module
  */
 const base64abc = [
@@ -96,22 +80,29 @@ const base64abc = [
     "/",
 ];
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
- *
  * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
  * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
- * @param data
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode encodeBase64} instead.
  */
 exports.encode = encodeBase64;
 /**
- * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
- *
  * Decodes a given RFC4648 base64 encoded string
- * @param b64
+ *
+ * @deprecated (will be removed in 0.210.0) Use {@linkcode decodeBase64} instead.
  */
 exports.decode = decodeBase64;
 /**
- * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * Converts data into a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 function encodeBase64(data) {
     // CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
@@ -141,7 +132,16 @@ function encodeBase64(data) {
 }
 exports.encodeBase64 = encodeBase64;
 /**
- * Decodes a given RFC4648 base64 encoded string
+ * Decodes a base64-encoded string.
+ *
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
+ *
+ * @example
+ * ```ts
+ * import { encodeBase64 } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * encodeBase64("foobar"); // "Zm9vYmFy"
+ * ```
  */
 function decodeBase64(b64) {
     const binString = atob(b64);

package/script/deps/deno.land/{std@0.208.0 → std@0.209.0}/media_types/content_type.js

@@ -6,7 +6,7 @@ exports.contentType = void 0;
 const parse_media_type_js_1 = require("./parse_media_type.js");
 const get_charset_js_1 = require("./get_charset.js");
 const format_media_type_js_1 = require("./format_media_type.js");
-const _db_js_1 = require("./_db.js");
+const type_by_extension_js_1 = require("./type_by_extension.js");
 /**
  * Given an extension or media type, return a full `Content-Type` or
  * `Content-Disposition` header value.
@@ -39,7 +39,7 @@ function contentType(extensionOrType) {
     try {
         const [mediaType, params = {}] = extensionOrType.includes("/")
             ? (0, parse_media_type_js_1.parseMediaType)(extensionOrType)
-            : [typeByExtension(extensionOrType), undefined];
+            : [(0, type_by_extension_js_1.typeByExtension)(extensionOrType), undefined];
         if (!mediaType) {
             return undefined;
         }
@@ -57,8 +57,3 @@ function contentType(extensionOrType) {
     return undefined;
 }
 exports.contentType = contentType;
-function typeByExtension(extension) {
-    extension = extension.startsWith(".") ? extension.slice(1) : extension;
-    // @ts-ignore workaround around denoland/dnt#148
-    return _db_js_1.types.get(extension.toLowerCase());
-}