@fedify/fedify 1.6.0-dev.778 → 1.6.0-dev.795

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

@@ -1,50 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const src = new Uint8Array([9, 8, 7]);
- * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
- *
- * assertEquals(copy(src, dst), 3);
- * assertEquals(dst, new Uint8Array([9, 8, 7, 3, 4, 5]));
- * ```
- *
- * @example Copy with offset
- * ```ts
- * import { copy } from "@std/bytes/copy";
- * import { assertEquals } from "@std/assert";
- *
- * const src = new Uint8Array([1, 1, 1, 1]);
- * const dst = new Uint8Array([0, 0, 0, 0]);
- *
- * assertEquals(copy(src, dst, 1), 3);
- * assertEquals(dst, new Uint8Array([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/1.0.5/ends_with.js

@@ -1,36 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const suffix = new Uint8Array([1, 2, 3]);
- *
- * assertEquals(endsWith(source, suffix), true);
- * ```
- */
-export function endsWith(source, suffix) {
-    const diff = source.length - suffix.length;
-    if (diff < 0) {
-        return false;
-    }
-    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/1.0.5/equals.js

@@ -1,82 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const a = new Uint8Array([1, 2, 3]);
- * const b = new Uint8Array([1, 2, 3]);
- * const c = new Uint8Array([4, 5, 6]);
- *
- * assertEquals(equals(a, b), true);
- * assertEquals(equals(a, 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/1.0.5/includes_needle.js

@@ -1,42 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(includesNeedle(source, needle), true);
- * ```
- *
- * @example Start index
- * ```ts
- * import { includesNeedle } from "@std/bytes/includes-needle";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(includesNeedle(source, needle, 3), true);
- * assertEquals(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/1.0.5/index_of_needle.js

@@ -1,68 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- * const notNeedle = new Uint8Array([5, 0]);
- *
- * assertEquals(indexOfNeedle(source, needle), 1);
- * assertEquals(indexOfNeedle(source, notNeedle), -1);
- * ```
- *
- * @example Start index
- * ```ts
- * import { indexOfNeedle } from "@std/bytes/index-of-needle";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(indexOfNeedle(source, needle, 2), 3);
- * assertEquals(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 < 0) {
-        start = Math.max(0, source.length + start);
-    }
-    if (needle.length > source.length - start) {
-        return -1;
-    }
-    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/1.0.5/last_index_of_needle.js

@@ -1,65 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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
- * `source.length - 1`.
- * @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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- * const notNeedle = new Uint8Array([5, 0]);
- *
- * assertEquals(lastIndexOfNeedle(source, needle), 5);
- * assertEquals(lastIndexOfNeedle(source, notNeedle), -1);
- * ```
- *
- * @example Start index
- * ```ts
- * import { lastIndexOfNeedle } from "@std/bytes/last-index-of-needle";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(lastIndexOfNeedle(source, needle, 2), 1);
- * assertEquals(lastIndexOfNeedle(source, needle, 6), 5);
- * ```
- * 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/1.0.5/mod.js

@@ -1,34 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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.
- *
- * ```ts
- * import { concat, indexOfNeedle, endsWith } from "@std/bytes";
- * import { assertEquals } from "@std/assert";
- *
- * const a = new Uint8Array([0, 1, 2]);
- * const b = new Uint8Array([3, 4, 5]);
- *
- * const c = concat([a, b]);
- *
- * assertEquals(c, new Uint8Array([0, 1, 2, 3, 4, 5]));
- *
- * assertEquals(indexOfNeedle(c, new Uint8Array([2, 3])), 2);
- *
- * assertEquals(endsWith(c, b), 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/1.0.5/repeat.js

@@ -1,43 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2]);
- *
- * assertEquals(repeat(source, 3), new Uint8Array([0, 1, 2, 0, 1, 2, 0, 1, 2]));
- * ```
- *
- * @example Zero count
- * ```ts
- * import { repeat } from "@std/bytes/repeat";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2]);
- *
- * assertEquals(repeat(source, 0), new Uint8Array());
- * ```
- */
-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/1.0.5/starts_with.js

@@ -1,34 +0,0 @@
-// Copyright 2018-2025 the Deno authors. 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const prefix = new Uint8Array([0, 1, 2]);
- *
- * assertEquals(startsWith(source, prefix), true);
- * ```
- */
-export function startsWith(source, prefix) {
-    if (prefix.length > source.length) {
-        return false;
-    }
-    for (let i = 0; i < prefix.length; i++) {
-        if (source[i] !== prefix[i])
-            return false;
-    }
-    return true;
-}

package/types/deps/jsr.io/@std/bytes/1.0.5/copy.d.ts

@@ -1,41 +0,0 @@
-/**
- * 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";
- * import { assertEquals } from "@std/assert";
- *
- * const src = new Uint8Array([9, 8, 7]);
- * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
- *
- * assertEquals(copy(src, dst), 3);
- * assertEquals(dst, new Uint8Array([9, 8, 7, 3, 4, 5]));
- * ```
- *
- * @example Copy with offset
- * ```ts
- * import { copy } from "@std/bytes/copy";
- * import { assertEquals } from "@std/assert";
- *
- * const src = new Uint8Array([1, 1, 1, 1]);
- * const dst = new Uint8Array([0, 0, 0, 0]);
- *
- * assertEquals(copy(src, dst, 1), 3);
- * assertEquals(dst, new Uint8Array([0, 1, 1, 1]));
- * ```
- * Defining an offset will start copying at the specified index in the
- * destination array.
- */
-export declare function copy(src: Uint8Array, dst: Uint8Array, offset?: number): number;
-//# sourceMappingURL=copy.d.ts.map

package/types/deps/jsr.io/@std/bytes/1.0.5/copy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/copy.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,MAAM,CAQzE"}

package/types/deps/jsr.io/@std/bytes/1.0.5/ends_with.d.ts

@@ -1,24 +0,0 @@
-/**
- * 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const suffix = new Uint8Array([1, 2, 3]);
- *
- * assertEquals(endsWith(source, suffix), true);
- * ```
- */
-export declare function endsWith(source: Uint8Array, suffix: Uint8Array): boolean;
-//# sourceMappingURL=ends_with.d.ts.map

package/types/deps/jsr.io/@std/bytes/1.0.5/ends_with.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ends_with.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/ends_with.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,CAWxE"}

package/types/deps/jsr.io/@std/bytes/1.0.5/equals.d.ts

@@ -1,22 +0,0 @@
-/**
- * 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";
- * import { assertEquals } from "@std/assert";
- *
- * const a = new Uint8Array([1, 2, 3]);
- * const b = new Uint8Array([1, 2, 3]);
- * const c = new Uint8Array([4, 5, 6]);
- *
- * assertEquals(equals(a, b), true);
- * assertEquals(equals(a, c), false);
- * ```
- */
-export declare function equals(a: Uint8Array, b: Uint8Array): boolean;
-//# sourceMappingURL=equals.d.ts.map

package/types/deps/jsr.io/@std/bytes/1.0.5/equals.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"equals.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/equals.ts"],"names":[],"mappings":"AA6DA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAQ5D"}

package/types/deps/jsr.io/@std/bytes/1.0.5/includes_needle.d.ts

@@ -1,38 +0,0 @@
-/**
- * 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(includesNeedle(source, needle), true);
- * ```
- *
- * @example Start index
- * ```ts
- * import { includesNeedle } from "@std/bytes/includes-needle";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(includesNeedle(source, needle, 3), true);
- * assertEquals(includesNeedle(source, needle, 6), false);
- * ```
- * The search will start at the specified index in the source array.
- */
-export declare function includesNeedle(source: Uint8Array, needle: Uint8Array, start?: number): boolean;
-//# sourceMappingURL=includes_needle.d.ts.map

package/types/deps/jsr.io/@std/bytes/1.0.5/includes_needle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"includes_needle.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/includes_needle.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,EAClB,KAAK,SAAI,GACR,OAAO,CAET"}

package/types/deps/jsr.io/@std/bytes/1.0.5/index_of_needle.d.ts

@@ -1,45 +0,0 @@
-/**
- * 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";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- * const notNeedle = new Uint8Array([5, 0]);
- *
- * assertEquals(indexOfNeedle(source, needle), 1);
- * assertEquals(indexOfNeedle(source, notNeedle), -1);
- * ```
- *
- * @example Start index
- * ```ts
- * import { indexOfNeedle } from "@std/bytes/index-of-needle";
- * import { assertEquals } from "@std/assert";
- *
- * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
- * const needle = new Uint8Array([1, 2]);
- *
- * assertEquals(indexOfNeedle(source, needle, 2), 3);
- * assertEquals(indexOfNeedle(source, needle, 6), -1);
- * ```
- * Defining a start index will begin the search at the specified index in the
- * source array.
- */
-export declare function indexOfNeedle(source: Uint8Array, needle: Uint8Array, start?: number): number;
-//# sourceMappingURL=index_of_needle.d.ts.map

package/types/deps/jsr.io/@std/bytes/1.0.5/index_of_needle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index_of_needle.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/bytes/1.0.5/index_of_needle.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,UAAU,EAClB,KAAK,SAAI,GACR,MAAM,CAqBR"}