@fedify/fedify 0.8.0-dev.153 → 0.8.0-dev.154

package/esm/deps/jsr.io/@std/bytes/{0.220.1 → 0.224.0}/concat.js

@@ -1,27 +1,31 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 // This module is browser compatible.
 /**
- * Concatenate an array of {@linkcode Uint8Array}s.
+ * Concatenate an array of byte slices into a single slice.
  *
- * @example
+ * @param buffers Array of byte slices to concatenate.
+ * @returns Hello
+ *
+ * @example Basic usage
  * ```ts
  * import { concat } from "@std/bytes/concat";
  *
  * const a = new Uint8Array([0, 1, 2]);
  * const b = new Uint8Array([3, 4, 5]);
+ *
  * concat([a, b]); // Uint8Array(6) [ 0, 1, 2, 3, 4, 5 ]
  * ```
  */
-export function concat(buf) {
+export function concat(buffers) {
     let length = 0;
-    for (const b of buf) {
-        length += b.length;
+    for (const buffer of buffers) {
+        length += buffer.length;
     }
     const output = new Uint8Array(length);
     let index = 0;
-    for (const b of buf) {
-        output.set(b, index);
-        index += b.length;
+    for (const buffer of buffers) {
+        output.set(buffer, index);
+        index += buffer.length;
     }
     return output;
 }

package/esm/deps/jsr.io/@std/bytes/0.224.0/copy.js

@@ -0,0 +1,48 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Copy bytes from the source array to the destination array and returns the
+ * number of bytes copied.
+ *
+ * If the source array is larger than what the `dst` array can hold, only the
+ * amount of bytes that fit in the `dst` array are copied.
+ *
+ * @param src Source array to copy from.
+ * @param dst Destination array to copy to.
+ * @param offset Offset in the destination array to start copying to. Defaults
+ * to 0.
+ * @returns Number of bytes copied.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ *
+ * const src = new Uint8Array([9, 8, 7]);
+ * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
+ *
+ * copy(src, dst); // 3
+ * dst; // Uint8Array(6) [9, 8, 7, 3, 4, 5]
+ * ```
+ *
+ * @example Copy with offset
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ *
+ * const src = new Uint8Array([1, 1, 1, 1]);
+ * const dst = new Uint8Array([0, 0, 0, 0]);
+ *
+ * copy(src, dst, 1); // 3
+ * dst; // Uint8Array(4) [0, 1, 1, 1]
+ * ```
+ * Defining an offset will start copying at the specified index in the
+ * destination array.
+ */
+export function copy(src, dst, offset = 0) {
+    offset = Math.max(0, Math.min(offset, dst.byteLength));
+    const dstBytesAvailable = dst.byteLength - offset;
+    if (src.byteLength > dstBytesAvailable) {
+        src = src.subarray(0, dstBytesAvailable);
+    }
+    dst.set(src, offset);
+    return src.byteLength;
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/ends_with.js

@@ -0,0 +1,32 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Returns `true` if the suffix array appears at the end of the source array,
+ * `false` otherwise.
+ *
+ * The complexity of this function is `O(suffix.length)`.
+ *
+ * @param source Source array to check.
+ * @param suffix Suffix array to check for.
+ * @returns `true` if the suffix array appears at the end of the source array,
+ * `false` otherwise.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { endsWith } from "@std/bytes/ends-with";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const suffix = new Uint8Array([1, 2, 3]);
+ *
+ * endsWith(source, suffix); // true
+ * ```
+ */
+export function endsWith(source, suffix) {
+    const diff = source.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; i--) {
+        if (source[diff + i] !== suffix[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/equals.js

@@ -0,0 +1,81 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Check whether byte slices are equal to each other using 8-bit comparisons.
+ *
+ * @param a First array to check equality
+ * @param b Second array to check equality
+ * @returns `true` if the arrays are equal, `false` otherwise
+ *
+ * @private
+ */
+function equalsNaive(a, b) {
+    for (let i = 0; i < b.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/** Check whether byte slices are equal to each other using 32-bit comparisons.
+ *
+ * @param a First array to check equality.
+ * @param b Second array to check equality.
+ * @returns `true` if the arrays are equal, `false` otherwise.
+ *
+ * @private
+ */
+function equals32Bit(a, b) {
+    const len = a.length;
+    const compactOffset = 3 - ((a.byteOffset + 3) % 4);
+    const compactLen = Math.floor((len - compactOffset) / 4);
+    const compactA = new Uint32Array(a.buffer, a.byteOffset + compactOffset, compactLen);
+    const compactB = new Uint32Array(b.buffer, b.byteOffset + compactOffset, compactLen);
+    for (let i = 0; i < compactOffset; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    for (let i = 0; i < compactA.length; i++) {
+        if (compactA[i] !== compactB[i])
+            return false;
+    }
+    for (let i = compactOffset + compactLen * 4; i < len; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+/**
+ * Byte length threshold for when to use 32-bit comparisons, based on
+ * benchmarks.
+ *
+ * @see {@link https://github.com/denoland/deno_std/pull/4635}
+ */
+const THRESHOLD_32_BIT = 160;
+/**
+ * Check whether byte slices are equal to each other.
+ *
+ * @param a First array to check equality.
+ * @param b Second array to check equality.
+ * @returns `true` if the arrays are equal, `false` otherwise.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { equals } from "@std/bytes/equals";
+ *
+ * const a = new Uint8Array([1, 2, 3]);
+ * const b = new Uint8Array([1, 2, 3]);
+ * const c = new Uint8Array([4, 5, 6]);
+ *
+ * equals(a, b); // true
+ * equals(b, c); // false
+ * ```
+ */
+export function equals(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return a.length >= THRESHOLD_32_BIT &&
+        (a.byteOffset % 4) === (b.byteOffset % 4)
+        ? equals32Bit(a, b)
+        : equalsNaive(a, b);
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/includes_needle.js

@@ -0,0 +1,39 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { indexOfNeedle } from "./index_of_needle.js";
+/**
+ * Determines whether the source array contains the needle array.
+ *
+ * The complexity of this function is `O(source.length * needle.length)`.
+ *
+ * @param source Source array to check.
+ * @param needle Needle array to check for.
+ * @param start Start index in the source array to begin the search. Defaults to
+ * 0.
+ * @returns `true` if the source array contains the needle array, `false`
+ * otherwise.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { includesNeedle } from "@std/bytes/includes-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ *
+ * includesNeedle(source, needle); // true
+ * ```
+ *
+ * @example Start index
+ * ```ts
+ * import { includesNeedle } from "@std/bytes/includes-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ *
+ * includesNeedle(source, needle, 6); // false
+ * ```
+ * The search will start at the specified index in the source array.
+ */
+export function includesNeedle(source, needle, start = 0) {
+    return indexOfNeedle(source, needle, start) !== -1;
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/index_of_needle.js

@@ -0,0 +1,66 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Returns the index of the first occurrence of the needle array in the source
+ * array, or -1 if it is not present.
+ *
+ * A start index can be specified as the third argument that begins the search
+ * at that given index. The start index defaults to the start of the array.
+ *
+ * The complexity of this function is `O(source.length * needle.length)`.
+ *
+ * @param source Source array to check.
+ * @param needle Needle array to check for.
+ * @param start Start index in the source array to begin the search. Defaults to
+ * 0.
+ * @returns Index of the first occurrence of the needle array in the source
+ * array, or -1 if it is not present.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { indexOfNeedle } from "@std/bytes/index-of-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * const notNeedle = new Uint8Array([5, 0]);
+ *
+ * indexOfNeedle(source, needle); // 1
+ * indexOfNeedle(source, notNeedle); // -1
+ * ```
+ *
+ * @example Start index
+ * ```ts
+ * import { indexOfNeedle } from "@std/bytes/index-of-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ *
+ * indexOfNeedle(source, needle, 2); // 3
+ * indexOfNeedle(source, needle, 6); // -1
+ * ```
+ * Defining a start index will begin the search at the specified index in the
+ * source array.
+ */
+export function indexOfNeedle(source, needle, start = 0) {
+    if (start >= source.length) {
+        return -1;
+    }
+    if (start < 0) {
+        start = Math.max(0, source.length + start);
+    }
+    const s = needle[0];
+    for (let i = start; i < source.length; i++) {
+        if (source[i] !== s)
+            continue;
+        let matched = 1;
+        let j = i + 1;
+        while (matched < needle.length && source[j] === needle[j - i]) {
+            matched++;
+            j++;
+        }
+        if (matched === needle.length) {
+            return i;
+        }
+    }
+    return -1;
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/last_index_of_needle.js

@@ -0,0 +1,63 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Returns the index of the last occurrence of the needle array in the source
+ * array, or -1 if it is not present.
+ *
+ * The complexity of this function is `O(source.length * needle.length)`.
+ *
+ * @param source Source array to check.
+ * @param needle Needle array to check for.
+ * @param start Start index in the source array to begin the search. Defaults to
+ * the end of the array.
+ * @returns Index of the last occurrence of the needle array in the source
+ * array, or -1 if it is not present.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * const notNeedle = new Uint8Array([5, 0]);
+ *
+ * lastIndexOfNeedle(source, needle); // 5
+ * lastIndexOfNeedle(source, notNeedle); // -1
+ * ```
+ *
+ * @example Start index
+ * ```ts
+ * import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ *
+ * lastIndexOfNeedle(source, needle, 2); // 1
+ * lastIndexOfNeedle(source, needle, 6); // 3
+ * ```
+ * Defining a start index will begin the search at the specified index in the
+ * source array.
+ */
+export function lastIndexOfNeedle(source, needle, start = source.length - 1) {
+    if (start < 0) {
+        return -1;
+    }
+    if (start >= source.length) {
+        start = source.length - 1;
+    }
+    const e = needle[needle.length - 1];
+    for (let i = start; i >= 0; i--) {
+        if (source[i] !== e)
+            continue;
+        let matched = 1;
+        let j = i;
+        while (matched < needle.length &&
+            source[--j] === needle[needle.length - 1 - (i - j)]) {
+            matched++;
+        }
+        if (matched === needle.length) {
+            return i - needle.length + 1;
+        }
+    }
+    return -1;
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/mod.js

@@ -0,0 +1,151 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Helper functions for working with
+ * {@linkcode https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array | Uint8Array}
+ * byte slices.
+ *
+ * ## Concatenate byte slices
+ *
+ * {@linkcode concat} concatenates an array of byte slices into a single slice.
+ *
+ * ```ts
+ * import { concat } from "@std/bytes/concat";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ * concat([a, b]); // Uint8Array(6) [ 0, 1, 2, 3, 4, 5 ]
+ * ```
+ *
+ * ## Copy byte slices
+ *
+ * {@linkcode copy} copies bytes from the `src` array to the `dst` array and
+ * returns the number of bytes copied.
+ *
+ * ```ts
+ * import { copy } from "@std/bytes/copy";
+ *
+ * const src = new Uint8Array([9, 8, 7]);
+ * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
+ *
+ * copy(src, dst); // 3
+ * dst; // Uint8Array(6) [9, 8, 7, 3, 4, 5]
+ * ```
+ *
+ * ## Check if a byte slice ends with another byte slice
+ *
+ * {@linkcode endsWith} returns `true` if the suffix array appears at the end of
+ * the source array, `false` otherwise.
+ *
+ * ```ts
+ * import { endsWith } from "@std/bytes/ends-with";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const suffix = new Uint8Array([1, 2, 3]);
+ *
+ * endsWith(source, suffix); // true
+ * ```
+ *
+ * ## Check if two byte slices are equal
+ *
+ * {@linkcode equals} checks whether byte slices are equal to each other.
+ *
+ * ```ts
+ * import { equals } from "@std/bytes/equals";
+ *
+ * const a = new Uint8Array([1, 2, 3]);
+ * const b = new Uint8Array([1, 2, 3]);
+ * const c = new Uint8Array([4, 5, 6]);
+ *
+ * equals(a, b); // true
+ * equals(b, c); // false
+ * ```
+ *
+ * ## Check if a byte slice includes another byte slice
+ *
+ * {@linkcode includesNeedle} determines whether the source array contains the
+ * needle array.
+ *
+ * ```ts
+ * import { includesNeedle } from "@std/bytes/includes-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ *
+ * includesNeedle(source, needle); // true
+ * ```
+ *
+ * ## Find the index of a byte slice in another byte slice
+ *
+ * {@linkcode indexOfNeedle} returns the index of the first occurrence of the
+ * needle array in the source array, or -1 if it is not present.
+ *
+ * ```ts
+ * import { indexOfNeedle } from "@std/bytes/index-of-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * const notNeedle = new Uint8Array([5, 0]);
+ *
+ * indexOfNeedle(source, needle); // 1
+ * indexOfNeedle(source, notNeedle); // -1
+ * ```
+ *
+ * ## Find the last index of a byte slice in another byte slice
+ *
+ * {@linkcode lastIndexOfNeedle} returns the index of the last occurrence of the
+ * needle array in the source array, or -1 if it is not present.
+ *
+ * ```ts
+ * import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * const notNeedle = new Uint8Array([5, 0]);
+ *
+ * lastIndexOfNeedle(source, needle); // 5
+ * lastIndexOfNeedle(source, notNeedle); // -1
+ * ```
+ *
+ * ## Repeat a byte slice
+ *
+ * {@linkcode repeat} returns a new byte slice composed of `count` repetitions
+ * of the `source` array.
+ *
+ * ```ts
+ * import { repeat } from "@std/bytes/repeat";
+ *
+ * const source = new Uint8Array([0, 1, 2]);
+ *
+ * repeat(source, 3); // Uint8Array(9) [0, 1, 2, 0, 1, 2, 0, 1, 2]
+ *
+ * repeat(source, 0); // Uint8Array(0) []
+ *
+ * repeat(source, -1); // Throws `RangeError`
+ * ```
+ *
+ * ## Check if a byte slice starts with another byte slice
+ *
+ * {@linkcode startsWith} returns `true` if the prefix array appears at the start
+ * of the source array, `false` otherwise.
+ *
+ * ```ts
+ * import { startsWith } from "@std/bytes/starts-with";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const prefix = new Uint8Array([0, 1, 2]);
+ *
+ * startsWith(source, prefix); // true
+ * ```
+ *
+ * @module
+ */
+export * from "./concat.js";
+export * from "./copy.js";
+export * from "./ends_with.js";
+export * from "./equals.js";
+export * from "./includes_needle.js";
+export * from "./index_of_needle.js";
+export * from "./last_index_of_needle.js";
+export * from "./repeat.js";
+export * from "./starts_with.js";

package/esm/deps/jsr.io/@std/bytes/0.224.0/repeat.js

@@ -0,0 +1,36 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { copy } from "./copy.js";
+/**
+ * Returns a new byte slice composed of `count` repetitions of the `source`
+ * array.
+ *
+ * @param source Source array to repeat.
+ * @param count Number of times to repeat the source array.
+ * @returns A new byte slice composed of `count` repetitions of the `source`
+ * array.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { repeat } from "@std/bytes/repeat";
+ *
+ * const source = new Uint8Array([0, 1, 2]);
+ *
+ * repeat(source, 3); // Uint8Array(9) [0, 1, 2, 0, 1, 2, 0, 1, 2]
+ *
+ * repeat(source, 0); // Uint8Array(0) []
+ *
+ * repeat(source, -1); // Throws `RangeError`
+ * ```
+ */
+export function repeat(source, count) {
+    if (count < 0 || !Number.isInteger(count)) {
+        throw new RangeError("Count must be a non-negative integer");
+    }
+    const repeated = new Uint8Array(source.length * count);
+    let offset = 0;
+    while (offset < repeated.length) {
+        offset += copy(source, repeated, offset);
+    }
+    return repeated;
+}

package/esm/deps/jsr.io/@std/bytes/0.224.0/starts_with.js

@@ -0,0 +1,30 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/**
+ * Returns `true` if the prefix array appears at the start of the source array,
+ * `false` otherwise.
+ *
+ * The complexity of this function is `O(prefix.length)`.
+ *
+ * @param source Source array to check.
+ * @param prefix Prefix array to check for.
+ * @returns `true` if the prefix array appears at the start of the source array,
+ * `false` otherwise.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { startsWith } from "@std/bytes/starts-with";
+ *
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const prefix = new Uint8Array([0, 1, 2]);
+ *
+ * startsWith(source, prefix); // true
+ * ```
+ */
+export function startsWith(source, prefix) {
+    for (let i = 0; i < prefix.length; i++) {
+        if (source[i] !== prefix[i])
+            return false;
+    }
+    return true;
+}

package/esm/deps/jsr.io/@std/encoding/{0.220.1 → 0.224.0}/base64.js

@@ -7,6 +7,17 @@
  *
  * This module is browser compatible.
  *
+ * ```ts
+ * import {
+ *   encodeBase64,
+ *   decodeBase64,
+ * } from "@std/encoding/base64";
+ *
+ * const encoded = encodeBase64("foobar"); // "Zm9vYmFy"
+ *
+ * decodeBase64(encoded); // Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * ```
+ *
  * @module
  */
 import { validateBinaryLike } from "./_util.js";
@@ -81,6 +92,9 @@ const base64abc = [
  *
  * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
  *
+ * @param data The data to encode.
+ * @returns The base64-encoded string.
+ *
  * @example
  * ```ts
  * import { encodeBase64 } from "@std/encoding/base64";
@@ -123,11 +137,14 @@ export function encodeBase64(data) {
  *
  * @see {@link https://datatracker.ietf.org/doc/html/rfc4648#section-4}
  *
+ * @param b64 The base64-encoded string to decode.
+ * @returns The decoded data.
+ *
  * @example
  * ```ts
- * import { encodeBase64 } from "@std/encoding/base64";
+ * import { decodeBase64 } from "@std/encoding/base64";
  *
- * encodeBase64("foobar"); // "Zm9vYmFy"
+ * decodeBase64("Zm9vYmFy"); // Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
  * ```
  */
 export function decodeBase64(b64) {

package/esm/deps/jsr.io/@std/encoding/{0.220.1 → 0.224.0}/hex.js

@@ -9,20 +9,15 @@
  *
  * This module is browser compatible.
  *
- * @example
  * ```ts
  * import {
  *   decodeHex,
  *   encodeHex,
  * } from "@std/encoding/hex";
  *
- * const binary = new TextEncoder().encode("abc");
- * const encoded = encodeHex(binary);
- * console.log(encoded);
- * // => "616263"
+ * const encoded = encodeHex("abc"); // "616263"
  *
- * console.log(decodeHex(encoded));
- * // => Uint8Array(3) [ 97, 98, 99 ]
+ * decodeHex(encoded); // Uint8Array(3) [ 97, 98, 99 ]
  * ```
  *
  * @module