@visulima/bytes 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,287 @@
+import { Buffer } from 'node:buffer';
+
+/**
+ * Concatenate an array of byte slices into a single slice.
+ *
+ * @param buffers Array of byte slices to concatenate.
+ * @returns A new byte slice containing all the input slices concatenated.
+ *
+ * @example Basic usage
+ * ```ts
+ * import { concat } from "@std/bytes/concat";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ *
+ * assertEquals(concat([a, b]), new Uint8Array([0, 1, 2, 3, 4, 5]));
+ * ```
+ */ declare function concat(buffers: readonly Uint8Array[]): Uint8Array_;
+
+/**
+ * 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.
+ */ declare function copy(src: Uint8Array, dst: Uint8Array, offset?: number): number;
+
+/**
+ * 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);
+ * ```
+ */ declare function endsWith(source: Uint8Array, suffix: Uint8Array): boolean;
+
+/**
+ * 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);
+ * ```
+ */ declare function equals(a: Uint8Array, b: Uint8Array): boolean;
+
+/**
+ * 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.
+ */ declare function includesNeedle(source: Uint8Array, needle: Uint8Array, start?: number): boolean;
+
+/**
+ * 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.
+ */ declare function indexOfNeedle(source: Uint8Array, needle: Uint8Array, start?: number): number;
+
+/**
+ * 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.
+ */ declare function lastIndexOfNeedle(source: Uint8Array, needle: Uint8Array, start?: number): number;
+
+/**
+ * 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());
+ * ```
+ */ declare function repeat(source: Uint8Array, count: number): Uint8Array_;
+
+/**
+ * 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);
+ * ```
+ */ declare function startsWith(source: Uint8Array, prefix: Uint8Array): boolean;
+
+declare const bufferToUint8Array: (buf: Buffer) => Uint8Array;
+declare const isUint8Array: (x: unknown) => x is Uint8Array;
+declare const asciiToUint8Array: (txt: TemplateStringsArray | string | [string]) => Uint8Array;
+declare const utf8ToUint8Array: (txt: TemplateStringsArray | [string] | string) => Uint8Array;
+declare const toUint8Array: (data: unknown) => Uint8Array;
+
+export { asciiToUint8Array, bufferToUint8Array, concat, copy, endsWith, equals, includesNeedle, indexOfNeedle, isUint8Array, lastIndexOfNeedle, repeat, startsWith, toUint8Array, utf8ToUint8Array };
+export type { Uint8Array_ };

package/dist/index.mjs

@@ -0,0 +1,59 @@
+import { Buffer } from 'node:buffer';
+export { concat } from './packem_shared/concat-CrMUrqFR.mjs';
+export { copy } from './packem_shared/copy-DrPnASpi.mjs';
+export { endsWith } from './packem_shared/endsWith-0SUmpwo5.mjs';
+export { equals } from './packem_shared/equals-QKFTA-PW.mjs';
+export { includesNeedle } from './packem_shared/includesNeedle-DrBfDWAu.mjs';
+export { indexOfNeedle } from './packem_shared/indexOfNeedle-DNPShVZm.mjs';
+export { lastIndexOfNeedle } from './packem_shared/lastIndexOfNeedle-YY1XC9fo.mjs';
+export { repeat } from './packem_shared/repeat-D9RZrtYr.mjs';
+export { startsWith } from './packem_shared/startsWith-CC5eK1Xp.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const bufferToUint8Array = /* @__PURE__ */ __name((buf) => new Uint8Array(buf.buffer, buf.byteOffset, buf.length), "bufferToUint8Array");
+const isUint8Array = typeof Buffer === "function" ? (x) => x instanceof Uint8Array || Buffer.isBuffer(x) : (x) => x instanceof Uint8Array;
+const asciiToUint8Array = /* @__PURE__ */ __name((txt) => {
+  if (typeof txt === "string")
+    return asciiToUint8Array([txt]);
+  const [input] = Array.isArray(txt) ? txt : [String.raw(txt)];
+  const inputLength = input.length;
+  const result = new Uint8Array(inputLength);
+  for (let index = 0; index < inputLength; index += 1) {
+    result[index] = input.charCodeAt(index) & 255;
+  }
+  return result;
+}, "asciiToUint8Array");
+const utf8ToUint8Array = /* @__PURE__ */ __name((txt) => {
+  if (typeof txt === "string")
+    return utf8ToUint8Array([txt]);
+  const [input] = Array.isArray(txt) ? txt : [String.raw(txt)];
+  return bufferToUint8Array(Buffer.from(input, "utf8"));
+}, "utf8ToUint8Array");
+const toUint8Array = /* @__PURE__ */ __name((data) => {
+  if (typeof Buffer === "function" && Buffer.isBuffer(data)) {
+    return bufferToUint8Array(data);
+  }
+  if (data instanceof Uint8Array) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer)
+    return new Uint8Array(data);
+  if (Array.isArray(data) && data.every((item) => typeof item === "number")) {
+    return new Uint8Array(data);
+  }
+  if (typeof Buffer === "function") {
+    if (Buffer.isBuffer(data)) {
+      return bufferToUint8Array(data);
+    }
+    if (typeof data === "string") {
+      try {
+        return bufferToUint8Array(Buffer.from(data));
+      } catch {
+      }
+    }
+  }
+  throw new Error("UINT8ARRAY_INCOMPATIBLE: Cannot convert data to Uint8Array");
+}, "toUint8Array");
+
+export { asciiToUint8Array, bufferToUint8Array, isUint8Array, toUint8Array, utf8ToUint8Array };

package/dist/packem_shared/concat-CrMUrqFR.mjs

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function concat(buffers) {
+  let length = 0;
+  for (const buffer of buffers) {
+    length += buffer.length;
+  }
+  const output = new Uint8Array(length);
+  let index = 0;
+  for (const buffer of buffers) {
+    output.set(buffer, index);
+    index += buffer.length;
+  }
+  return output;
+}
+__name(concat, "concat");
+
+export { concat };

package/dist/packem_shared/concat-DO5DD91d.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function concat(buffers) {
+  let length = 0;
+  for (const buffer of buffers) {
+    length += buffer.length;
+  }
+  const output = new Uint8Array(length);
+  let index = 0;
+  for (const buffer of buffers) {
+    output.set(buffer, index);
+    index += buffer.length;
+  }
+  return output;
+}
+__name(concat, "concat");
+
+exports.concat = concat;

package/dist/packem_shared/copy-Bx6bRT8N.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(copy, "copy");
+
+exports.copy = copy;

package/dist/packem_shared/copy-DrPnASpi.mjs

@@ -0,0 +1,14 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(copy, "copy");
+
+export { copy };

package/dist/packem_shared/endsWith-0SUmpwo5.mjs

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(endsWith, "endsWith");
+
+export { endsWith };

package/dist/packem_shared/endsWith-D8qAxWS-.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(endsWith, "endsWith");
+
+exports.endsWith = endsWith;

package/dist/packem_shared/equals-QKFTA-PW.mjs

@@ -0,0 +1,37 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function equalsNaive(a, b) {
+  for (let i = 0; i < b.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+__name(equalsNaive, "equalsNaive");
+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;
+}
+__name(equals32Bit, "equals32Bit");
+const THRESHOLD_32_BIT = 160;
+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);
+}
+__name(equals, "equals");
+
+export { equals };

package/dist/packem_shared/equals-lBip8nIE.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function equalsNaive(a, b) {
+  for (let i = 0; i < b.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+__name(equalsNaive, "equalsNaive");
+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;
+}
+__name(equals32Bit, "equals32Bit");
+const THRESHOLD_32_BIT = 160;
+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);
+}
+__name(equals, "equals");
+
+exports.equals = equals;

package/dist/packem_shared/includesNeedle-DrBfDWAu.mjs

@@ -0,0 +1,10 @@
+import { indexOfNeedle } from './indexOfNeedle-DNPShVZm.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function includesNeedle(source, needle, start = 0) {
+  return indexOfNeedle(source, needle, start) !== -1;
+}
+__name(includesNeedle, "includesNeedle");
+
+export { includesNeedle };

package/dist/packem_shared/includesNeedle-rD-vGkdN.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+const indexOfNeedle = require('./indexOfNeedle-ByhaFu9G.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function includesNeedle(source, needle, start = 0) {
+  return indexOfNeedle.indexOfNeedle(source, needle, start) !== -1;
+}
+__name(includesNeedle, "includesNeedle");
+
+exports.includesNeedle = includesNeedle;

package/dist/packem_shared/indexOfNeedle-ByhaFu9G.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(indexOfNeedle, "indexOfNeedle");
+
+exports.indexOfNeedle = indexOfNeedle;

package/dist/packem_shared/indexOfNeedle-DNPShVZm.mjs

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(indexOfNeedle, "indexOfNeedle");
+
+export { indexOfNeedle };

package/dist/packem_shared/lastIndexOfNeedle-Bw_wLjkK.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(lastIndexOfNeedle, "lastIndexOfNeedle");
+
+exports.lastIndexOfNeedle = lastIndexOfNeedle;

package/dist/packem_shared/lastIndexOfNeedle-YY1XC9fo.mjs

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(lastIndexOfNeedle, "lastIndexOfNeedle");
+
+export { lastIndexOfNeedle };