refactor(bytes): move to single-export files (denoland#2955)

bytes/concat.ts

@@ -0,0 +1,26 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Concatenate the given arrays into a new Uint8Array.
+ *
+ * ```ts
+ * import { concat } from "https://deno.land/std@$STD_VERSION/bytes/mod.ts";
+ * const a = new Uint8Array([0, 1, 2]);
+ * const b = new Uint8Array([3, 4, 5]);
+ * console.log(concat(a, b)); // [0, 1, 2, 3, 4, 5]
+ */
+export function concat(...buf: Uint8Array[]): Uint8Array {
+ let length = 0;
+ for (const b of buf) {
+ length += b.length;
+ }
+
+ const output = new Uint8Array(length);
+ let index = 0;
+ for (const b of buf) {
+ output.set(b, index);
+ index += b.length;
+ }
+
+ return output;
+}

bytes/concat_test.ts

@@ -0,0 +1,36 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+import { assert, assertEquals } from "../testing/asserts.ts";
+import { concat } from "./concat.ts";
+
+Deno.test("[bytes] concat", () => {
+ const encoder = new TextEncoder();
+ const u1 = encoder.encode("Hello ");
+ const u2 = encoder.encode("World");
+ const joined = concat(u1, u2);
+ assertEquals(new TextDecoder().decode(joined), "Hello World");
+ assert(u1 !== joined);
+ assert(u2 !== joined);
+});
+
+Deno.test("[bytes] concat empty arrays", () => {
+ const u1 = new Uint8Array();
+ const u2 = new Uint8Array();
+ const joined = concat(u1, u2);
+ assertEquals(joined.byteLength, 0);
+ assert(u1 !== joined);
+ assert(u2 !== joined);
+});
+
+Deno.test("[bytes] concat multiple arrays", () => {
+ const encoder = new TextEncoder();
+ const u1 = encoder.encode("Hello ");
+ const u2 = encoder.encode("W");
+ const u3 = encoder.encode("o");
+ const u4 = encoder.encode("r");
+ const u5 = encoder.encode("l");
+ const u6 = encoder.encode("d");
+ const joined = concat(u1, u2, u3, u4, u5, u6);
+ assertEquals(new TextDecoder().decode(joined), "Hello World");
+ assert(u1 !== joined);
+ assert(u2 !== joined);
+});

bytes/copy.ts

@@ -0,0 +1,38 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Copy bytes from the `src` array to the `dst` array. Returns the number of
+ * bytes copied.
+ *
+ * If the `src` array is larger than what the `dst` array can hold, only the
+ * amount of bytes that fit in the `dst` array are copied.
+ *
+ * An offset can be specified as the third argument that begins the copy at
+ * that given index in the `dst` array. The offset defaults to the beginning of
+ * the array.
+ *
+ * ```ts
+ * import { copy } from "https://deno.land/std@$STD_VERSION/bytes/mod.ts";
+ * const src = new Uint8Array([9, 8, 7]);
+ * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);
+ * console.log(copy(src, dst)); // 3
+ * console.log(dst); // [9, 8, 7, 3, 4, 5]
+ * ```
+ *
+ * ```ts
+ * import { copy } from "https://deno.land/std@$STD_VERSION/bytes/mod.ts";
+ * const src = new Uint8Array([1, 1, 1, 1]);
+ * const dst = new Uint8Array([0, 0, 0, 0]);
+ * console.log(copy(src, dst, 1)); // 3
+ * console.log(dst); // [0, 1, 1, 1]
+ * ```
+ */
+export function copy(src: Uint8Array, dst: Uint8Array, off = 0): number {
+ off = Math.max(0, Math.min(off, dst.byteLength));
+ const dstBytesAvailable = dst.byteLength - off;
+ if (src.byteLength > dstBytesAvailable) {
+ src = src.subarray(0, dstBytesAvailable);
+ }
+ dst.set(src, off);
+ return src.byteLength;
+}

bytes/copy_test.ts

@@ -0,0 +1,37 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+import { assert, assertEquals } from "../testing/asserts.ts";
+import { copy } from "./copy.ts";
+
+Deno.test("[bytes] copy", function () {
+ const dst = new Uint8Array(4);
+
+ dst.fill(0);
+ let src = Uint8Array.of(1, 2);
+ let len = copy(src, dst, 0);
+ assert(len === 2);
+ assertEquals(dst, Uint8Array.of(1, 2, 0, 0));
+
+ dst.fill(0);
+ src = Uint8Array.of(1, 2);
+ len = copy(src, dst, 1);
+ assert(len === 2);
+ assertEquals(dst, Uint8Array.of(0, 1, 2, 0));
+
+ dst.fill(0);
+ src = Uint8Array.of(1, 2, 3, 4, 5);
+ len = copy(src, dst);
+ assert(len === 4);
+ assertEquals(dst, Uint8Array.of(1, 2, 3, 4));
+
+ dst.fill(0);
+ src = Uint8Array.of(1, 2);
+ len = copy(src, dst, 100);
+ assert(len === 0);
+ assertEquals(dst, Uint8Array.of(0, 0, 0, 0));
+
+ dst.fill(0);
+ src = Uint8Array.of(3, 4);
+ len = copy(src, dst, -2);
+ assert(len === 2);
+ assertEquals(dst, Uint8Array.of(3, 4, 0, 0));
+});

bytes/ends_with.ts

@@ -0,0 +1,25 @@
+// Copyright 2018-2022 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).
+ *
+ * ```ts
+ * import { endsWith } from "https://deno.land/std@$STD_VERSION/bytes/mod.ts";
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const suffix = new Uint8Array([1, 2, 3]);
+ * console.log(endsWith(source, suffix)); // true
+ * ```
+ */
+export function endsWith(source: Uint8Array, suffix: Uint8Array): boolean {
+ for (
+ let srci = source.length - 1, sfxi = suffix.length - 1;
+ sfxi >= 0;
+ srci--, sfxi--
+ ) {
+ if (source[srci] !== suffix[sfxi]) return false;
+ }
+ return true;
+}

bytes/ends_with_test.ts

@@ -0,0 +1,13 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+import { assert } from "../testing/asserts.ts";
+import { endsWith } from "./ends_with.ts";
+
+Deno.test("[bytes] endsWith", () => {
+ const v = endsWith(new Uint8Array([0, 1, 2]), new Uint8Array([1, 2]));
+ const v2 = endsWith(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1]));
+ const v3 = endsWith(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1, 2, 3]));
+ assert(v);
+ assert(!v2);
+ assert(!v3);
+});

bytes/equals.ts

@@ -6,7 +6,7 @@
  * @param a first array to check equality
  * @param b second array to check equality
  */
-export function equalsNaive(a: Uint8Array, b: Uint8Array): boolean {
+function equalsNaive(a: Uint8Array, b: Uint8Array): boolean {
  if (a.length !== b.length) return false;
  for (let i = 0; i < b.length; i++) {
  if (a[i] !== b[i]) return false;
@@ -19,7 +19,7 @@ export function equalsNaive(a: Uint8Array, b: Uint8Array): boolean {
  * @param a first array to check equality
  * @param b second array to check equality
  */
-export function equals32Bit(a: Uint8Array, b: Uint8Array): boolean {
+function equals32Bit(a: Uint8Array, b: Uint8Array): boolean {
  if (a.length !== b.length) return false;
  const len = a.length;
  const compressable = Math.floor(len / 4);

bytes/equals_test.ts

@@ -0,0 +1,34 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+import { equals } from "./equals.ts";
+import { assert } from "../testing/asserts.ts";
+
+Deno.test("[bytes] equals", () => {
+ const v = equals(new Uint8Array([0, 1, 2, 3]), new Uint8Array([0, 1, 2, 3]));
+ const v2 = equals(new Uint8Array([0, 1, 2, 2]), new Uint8Array([0, 1, 2, 3]));
+ const v3 = equals(new Uint8Array([0, 1, 2, 3]), new Uint8Array([0, 1, 2]));
+ assert(v);
+ assert(!v2);
+ assert(!v3);
+});
+
+Deno.test("[bytes] equals randomized testing", () => {
+ // run tests before and after cutoff
+ for (let len = 995; len <= 1005; len++) {
+ const arr1 = crypto.getRandomValues(new Uint8Array(len));
+ const arr2 = crypto.getRandomValues(new Uint8Array(len));
+ const arr3 = arr1.slice(0);
+ // the chance of arr1 equaling arr2 is basically 0
+ // but introduce an inequality at the end just in case
+ arr2[arr2.length - 1] = arr1[arr1.length - 1] ^ 1;
+ // arr3 is arr1 but with an inequality in the very last element
+ // this is to test the equality check when length isn't a multiple of 4
+ arr3[arr3.length - 1] ^= 1;
+ // arrays with same underlying ArrayBuffer should be equal
+ assert(equals(arr1, arr1));
+ // equal arrays with different underlying ArrayBuffers should be equal
+ assert(equals(arr1, arr1.slice(0)));
+ // inequal arrays should be inequal
+ assert(!equals(arr1, arr2));
+ assert(!equals(arr1, arr3));
+ }
+});

bytes/includes_needle.ts

@@ -0,0 +1,27 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { indexOfNeedle } from "./index_of_needle.ts";
+
+/** Returns true if the source array contains the needle array, false otherwise.
+ *
+ * A start index can be specified as the third argument that begins the search
+ * at that given index. The start index defaults to the beginning of the array.
+ *
+ * The complexity of this function is O(source.length * needle.length).
+ *
+ * ```ts
+ * import { includesNeedle } from "https://deno.land/std@$STD_VERSION/bytes/mod.ts";
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * console.log(includesNeedle(source, needle)); // true
+ * console.log(includesNeedle(source, needle, 6)); // false
+ * ```
+ */
+export function includesNeedle(
+ source: Uint8Array,
+ needle: Uint8Array,
+ start = 0,
+): boolean {
+ return indexOfNeedle(source, needle, start) !== -1;
+}

bytes/includes_needle_test.ts

@@ -0,0 +1,15 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+import { includesNeedle } from "./includes_needle.ts";
+import { assert } from "../testing/asserts.ts";
+
+Deno.test("[bytes] includesNeedle", () => {
+ const encoder = new TextEncoder();
+ const source = encoder.encode("deno.land");
+ const pattern = encoder.encode("deno");
+
+ assert(includesNeedle(source, pattern));
+ assert(includesNeedle(new Uint8Array([0, 1, 2, 3]), new Uint8Array([2, 3])));
+
+ assert(includesNeedle(source, pattern, -10));
+ assert(!includesNeedle(source, pattern, -1));
+});

bytes/index_of_needle.ts

@@ -0,0 +1,49 @@
+// Copyright 2018-2022 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.lenth * needle.length).
+ *
+ * ```ts
+ * import { indexOfNeedle } from "https://deno.land/std@$STD_VERSION/bytes/mod.ts";
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * console.log(indexOfNeedle(source, needle)); // 1
+ * console.log(indexOfNeedle(source, needle, 2)); // 3
+ * ```
+ */
+export function indexOfNeedle(
+ source: Uint8Array,
+ needle: Uint8Array,
+ start = 0,
+): number {
+ 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;
+ const pin = i;
+ let matched = 1;
+ let j = i;
+ while (matched < needle.length) {
+ j++;
+ if (source[j] !== needle[j - pin]) {
+ break;
+ }
+ matched++;
+ }
+ if (matched === needle.length) {
+ return pin;
+ }
+ }
+ return -1;
+}