From 31db7c4dbafc3d5d4d4ad7629c658a1361c24d31 Mon Sep 17 00:00:00 2001
From: axetroy <troy450409405@gmail.com>
Date: Fri, 24 May 2019 20:28:31 +0800
Subject: rename bytes/bytes.ts to bytes/mod.ts

Original: https://github.com/denoland/deno_std/commit/015cf3e02d5809bf5ba473201183a26e08837c56
---
 bytes/bytes.ts      | 96 -----------------------------------------------------
 bytes/bytes_test.ts | 74 -----------------------------------------
 bytes/mod.ts        | 96 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 bytes/test.ts       | 74 ++++++++++++++++++++++++++++++++++++++++-
 mime/multipart.ts   | 26 +++++++--------
 5 files changed, 182 insertions(+), 184 deletions(-)
 delete mode 100644 bytes/bytes.ts
 delete mode 100644 bytes/bytes_test.ts
 create mode 100644 bytes/mod.ts

diff --git a/bytes/bytes.ts b/bytes/bytes.ts
deleted file mode 100644
index a42eaffd2..000000000
--- a/bytes/bytes.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import { copyBytes } from "../io/util.ts";
-
-/** Find first index of binary pattern from a. If not found, then return -1 **/
-export function findIndex(a: Uint8Array, pat: Uint8Array): number {
-  const s = pat[0];
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== s) continue;
-    const pin = i;
-    let matched = 1,
-      j = i;
-    while (matched < pat.length) {
-      j++;
-      if (a[j] !== pat[j - pin]) {
-        break;
-      }
-      matched++;
-    }
-    if (matched === pat.length) {
-      return pin;
-    }
-  }
-  return -1;
-}
-
-/** Find last index of binary pattern from a. If not found, then return -1 **/
-export function findLastIndex(a: Uint8Array, pat: Uint8Array): number {
-  const e = pat[pat.length - 1];
-  for (let i = a.length - 1; i >= 0; i--) {
-    if (a[i] !== e) continue;
-    const pin = i;
-    let matched = 1,
-      j = i;
-    while (matched < pat.length) {
-      j--;
-      if (a[j] !== pat[pat.length - 1 - (pin - j)]) {
-        break;
-      }
-      matched++;
-    }
-    if (matched === pat.length) {
-      return pin - pat.length + 1;
-    }
-  }
-  return -1;
-}
-
-/** Check whether binary arrays are equal to each other **/
-export function equal(a: Uint8Array, match: Uint8Array): boolean {
-  if (a.length !== match.length) return false;
-  for (let i = 0; i < match.length; i++) {
-    if (a[i] !== match[i]) return false;
-  }
-  return true;
-}
-
-/** Check whether binary array has binary prefix  **/
-export function hasPrefix(a: Uint8Array, prefix: Uint8Array): boolean {
-  for (let i = 0, max = prefix.length; i < max; i++) {
-    if (a[i] !== prefix[i]) return false;
-  }
-  return true;
-}
-
-/**
- * Repeat bytes. returns a new byte slice consisting of `count` copies of `b`.
- * @param b The origin bytes
- * @param count The count you want to repeat.
- */
-export function repeat(b: Uint8Array, count: number): Uint8Array {
-  if (count === 0) {
-    return new Uint8Array();
-  }
-
-  if (count < 0) {
-    throw new Error("bytes: negative repeat count");
-  } else if ((b.length * count) / count !== b.length) {
-    throw new Error("bytes: repeat count causes overflow");
-  }
-
-  const int = Math.floor(count);
-
-  if (int !== count) {
-    throw new Error("bytes: repeat count must be an integer");
-  }
-
-  const nb = new Uint8Array(b.length * count);
-
-  let bp = copyBytes(nb, b);
-
-  for (; bp < nb.length; bp *= 2) {
-    copyBytes(nb, nb.slice(0, bp), bp);
-  }
-
-  return nb;
-}
diff --git a/bytes/bytes_test.ts b/bytes/bytes_test.ts
deleted file mode 100644
index e53f81fcd..000000000
--- a/bytes/bytes_test.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-
-import { findIndex, findLastIndex, equal, hasPrefix, repeat } from "./bytes.ts";
-import { test } from "../testing/mod.ts";
-import { assertEquals, assertThrows } from "../testing/asserts.ts";
-
-test(function bytesfindIndex1(): void {
-  const i = findIndex(
-    new Uint8Array([1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 3]),
-    new Uint8Array([0, 1, 2])
-  );
-  assertEquals(i, 2);
-});
-
-test(function bytesfindIndex2(): void {
-  const i = findIndex(new Uint8Array([0, 0, 1]), new Uint8Array([0, 1]));
-  assertEquals(i, 1);
-});
-
-test(function bytesfindLastIndex1(): void {
-  const i = findLastIndex(
-    new Uint8Array([0, 1, 2, 0, 1, 2, 0, 1, 3]),
-    new Uint8Array([0, 1, 2])
-  );
-  assertEquals(i, 3);
-});
-
-test(function bytesfindLastIndex2(): void {
-  const i = findLastIndex(new Uint8Array([0, 1, 1]), new Uint8Array([0, 1]));
-  assertEquals(i, 0);
-});
-
-test(function bytesBytesequal(): void {
-  const v = equal(new Uint8Array([0, 1, 2, 3]), new Uint8Array([0, 1, 2, 3]));
-  assertEquals(v, true);
-});
-
-test(function byteshasPrefix(): void {
-  const v = hasPrefix(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1]));
-  assertEquals(v, true);
-});
-
-test(function bytesrepeat(): void {
-  // input / output / count / error message
-  const repeatTestCase = [
-    ["", "", 0],
-    ["", "", 1],
-    ["", "", 1.1, "bytes: repeat count must be an integer"],
-    ["", "", 2],
-    ["", "", 0],
-    ["-", "", 0],
-    ["-", "-", -1, "bytes: negative repeat count"],
-    ["-", "----------", 10],
-    ["abc ", "abc abc abc ", 3]
-  ];
-  for (const [input, output, count, errMsg] of repeatTestCase) {
-    if (errMsg) {
-      assertThrows(
-        (): void => {
-          repeat(new TextEncoder().encode(input as string), count as number);
-        },
-        Error,
-        errMsg as string
-      );
-    } else {
-      const newBytes = repeat(
-        new TextEncoder().encode(input as string),
-        count as number
-      );
-
-      assertEquals(new TextDecoder().decode(newBytes), output);
-    }
-  }
-});
diff --git a/bytes/mod.ts b/bytes/mod.ts
new file mode 100644
index 000000000..a42eaffd2
--- /dev/null
+++ b/bytes/mod.ts
@@ -0,0 +1,96 @@
+// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
+import { copyBytes } from "../io/util.ts";
+
+/** Find first index of binary pattern from a. If not found, then return -1 **/
+export function findIndex(a: Uint8Array, pat: Uint8Array): number {
+  const s = pat[0];
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== s) continue;
+    const pin = i;
+    let matched = 1,
+      j = i;
+    while (matched < pat.length) {
+      j++;
+      if (a[j] !== pat[j - pin]) {
+        break;
+      }
+      matched++;
+    }
+    if (matched === pat.length) {
+      return pin;
+    }
+  }
+  return -1;
+}
+
+/** Find last index of binary pattern from a. If not found, then return -1 **/
+export function findLastIndex(a: Uint8Array, pat: Uint8Array): number {
+  const e = pat[pat.length - 1];
+  for (let i = a.length - 1; i >= 0; i--) {
+    if (a[i] !== e) continue;
+    const pin = i;
+    let matched = 1,
+      j = i;
+    while (matched < pat.length) {
+      j--;
+      if (a[j] !== pat[pat.length - 1 - (pin - j)]) {
+        break;
+      }
+      matched++;
+    }
+    if (matched === pat.length) {
+      return pin - pat.length + 1;
+    }
+  }
+  return -1;
+}
+
+/** Check whether binary arrays are equal to each other **/
+export function equal(a: Uint8Array, match: Uint8Array): boolean {
+  if (a.length !== match.length) return false;
+  for (let i = 0; i < match.length; i++) {
+    if (a[i] !== match[i]) return false;
+  }
+  return true;
+}
+
+/** Check whether binary array has binary prefix  **/
+export function hasPrefix(a: Uint8Array, prefix: Uint8Array): boolean {
+  for (let i = 0, max = prefix.length; i < max; i++) {
+    if (a[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+
+/**
+ * Repeat bytes. returns a new byte slice consisting of `count` copies of `b`.
+ * @param b The origin bytes
+ * @param count The count you want to repeat.
+ */
+export function repeat(b: Uint8Array, count: number): Uint8Array {
+  if (count === 0) {
+    return new Uint8Array();
+  }
+
+  if (count < 0) {
+    throw new Error("bytes: negative repeat count");
+  } else if ((b.length * count) / count !== b.length) {
+    throw new Error("bytes: repeat count causes overflow");
+  }
+
+  const int = Math.floor(count);
+
+  if (int !== count) {
+    throw new Error("bytes: repeat count must be an integer");
+  }
+
+  const nb = new Uint8Array(b.length * count);
+
+  let bp = copyBytes(nb, b);
+
+  for (; bp < nb.length; bp *= 2) {
+    copyBytes(nb, nb.slice(0, bp), bp);
+  }
+
+  return nb;
+}
diff --git a/bytes/test.ts b/bytes/test.ts
index 711bf62c4..0a779dd3d 100644
--- a/bytes/test.ts
+++ b/bytes/test.ts
@@ -1,2 +1,74 @@
 // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
-import "./bytes_test.ts";
+
+import { findIndex, findLastIndex, equal, hasPrefix, repeat } from "./mod.ts";
+import { test } from "../testing/mod.ts";
+import { assertEquals, assertThrows } from "../testing/asserts.ts";
+
+test(function bytesfindIndex1(): void {
+  const i = findIndex(
+    new Uint8Array([1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 3]),
+    new Uint8Array([0, 1, 2])
+  );
+  assertEquals(i, 2);
+});
+
+test(function bytesfindIndex2(): void {
+  const i = findIndex(new Uint8Array([0, 0, 1]), new Uint8Array([0, 1]));
+  assertEquals(i, 1);
+});
+
+test(function bytesfindLastIndex1(): void {
+  const i = findLastIndex(
+    new Uint8Array([0, 1, 2, 0, 1, 2, 0, 1, 3]),
+    new Uint8Array([0, 1, 2])
+  );
+  assertEquals(i, 3);
+});
+
+test(function bytesfindLastIndex2(): void {
+  const i = findLastIndex(new Uint8Array([0, 1, 1]), new Uint8Array([0, 1]));
+  assertEquals(i, 0);
+});
+
+test(function bytesBytesequal(): void {
+  const v = equal(new Uint8Array([0, 1, 2, 3]), new Uint8Array([0, 1, 2, 3]));
+  assertEquals(v, true);
+});
+
+test(function byteshasPrefix(): void {
+  const v = hasPrefix(new Uint8Array([0, 1, 2]), new Uint8Array([0, 1]));
+  assertEquals(v, true);
+});
+
+test(function bytesrepeat(): void {
+  // input / output / count / error message
+  const repeatTestCase = [
+    ["", "", 0],
+    ["", "", 1],
+    ["", "", 1.1, "bytes: repeat count must be an integer"],
+    ["", "", 2],
+    ["", "", 0],
+    ["-", "", 0],
+    ["-", "-", -1, "bytes: negative repeat count"],
+    ["-", "----------", 10],
+    ["abc ", "abc abc abc ", 3]
+  ];
+  for (const [input, output, count, errMsg] of repeatTestCase) {
+    if (errMsg) {
+      assertThrows(
+        (): void => {
+          repeat(new TextEncoder().encode(input as string), count as number);
+        },
+        Error,
+        errMsg as string
+      );
+    } else {
+      const newBytes = repeat(
+        new TextEncoder().encode(input as string),
+        count as number
+      );
+
+      assertEquals(new TextDecoder().decode(newBytes), output);
+    }
+  }
+});
diff --git a/mime/multipart.ts b/mime/multipart.ts
index 22af98cf1..55d8da1c4 100644
--- a/mime/multipart.ts
+++ b/mime/multipart.ts
@@ -6,7 +6,7 @@ type Reader = Deno.Reader;
 type ReadResult = Deno.ReadResult;
 type Writer = Deno.Writer;
 import { FormFile } from "../multipart/formfile.ts";
-import { findIndex, findLastIndex, hasPrefix, equal } from "../bytes/bytes.ts";
+import * as bytes from "../bytes/mod.ts";
 import { copyN } from "../io/ioutil.ts";
 import { MultiReader } from "../io/readers.ts";
 import { tempFile } from "../io/util.ts";
@@ -55,7 +55,7 @@ export function scanUntilBoundary(
   state: BufState
 ): [number, BufState] {
   if (total === 0) {
-    if (hasPrefix(buf, dashBoundary)) {
+    if (bytes.hasPrefix(buf, dashBoundary)) {
       switch (matchAfterPrefix(buf, dashBoundary, state)) {
         case -1:
           return [dashBoundary.length, null];
@@ -64,12 +64,12 @@ export function scanUntilBoundary(
         case 1:
           return [0, "EOF"];
       }
-      if (hasPrefix(dashBoundary, buf)) {
+      if (bytes.hasPrefix(dashBoundary, buf)) {
         return [0, state];
       }
     }
   }
-  const i = findIndex(buf, newLineDashBoundary);
+  const i = bytes.findIndex(buf, newLineDashBoundary);
   if (i >= 0) {
     switch (matchAfterPrefix(buf.slice(i), newLineDashBoundary, state)) {
       case -1:
@@ -81,11 +81,11 @@ export function scanUntilBoundary(
         return [i, "EOF"];
     }
   }
-  if (hasPrefix(newLineDashBoundary, buf)) {
+  if (bytes.hasPrefix(newLineDashBoundary, buf)) {
     return [0, state];
   }
-  const j = findLastIndex(buf, newLineDashBoundary.slice(0, 1));
-  if (j >= 0 && hasPrefix(newLineDashBoundary, buf.slice(j))) {
+  const j = bytes.findLastIndex(buf, newLineDashBoundary.slice(0, 1));
+  if (j >= 0 && bytes.hasPrefix(newLineDashBoundary, buf.slice(j))) {
     return [j, null];
   }
   return [buf.length, state];
@@ -294,7 +294,7 @@ export class MultipartReader {
     if (this.currentPart) {
       this.currentPart.close();
     }
-    if (equal(this.dashBoundary, encoder.encode("--"))) {
+    if (bytes.equal(this.dashBoundary, encoder.encode("--"))) {
       throw new Error("boundary is empty");
     }
     let expectNewPart = false;
@@ -326,7 +326,7 @@ export class MultipartReader {
       if (this.partsRead === 0) {
         continue;
       }
-      if (equal(line, this.newLine)) {
+      if (bytes.equal(line, this.newLine)) {
         expectNewPart = true;
         continue;
       }
@@ -335,19 +335,19 @@ export class MultipartReader {
   }
 
   private isFinalBoundary(line: Uint8Array): boolean {
-    if (!hasPrefix(line, this.dashBoundaryDash)) {
+    if (!bytes.hasPrefix(line, this.dashBoundaryDash)) {
       return false;
     }
     let rest = line.slice(this.dashBoundaryDash.length, line.length);
-    return rest.length === 0 || equal(skipLWSPChar(rest), this.newLine);
+    return rest.length === 0 || bytes.equal(skipLWSPChar(rest), this.newLine);
   }
 
   private isBoundaryDelimiterLine(line: Uint8Array): boolean {
-    if (!hasPrefix(line, this.dashBoundary)) {
+    if (!bytes.hasPrefix(line, this.dashBoundary)) {
       return false;
     }
     const rest = line.slice(this.dashBoundary.length);
-    return equal(skipLWSPChar(rest), this.newLine);
+    return bytes.equal(skipLWSPChar(rest), this.newLine);
   }
 }
 
-- 
cgit v1.2.3