Started to implement server

2023-06-11 15:43:45 -04:00
1 parent 1f2ea8b7e5
commit 17a1b4bed3
@@ -0,0 +1,161 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * An abstraction of multiple Uint8Arrays
+ */
+export class BytesList {
+  #len = 0;
+  #chunks: {
+    value: Uint8Array;
+    start: number; // start offset from head of chunk
+    end: number; // end offset from head of chunk
+    offset: number; // offset of head in all bytes
+  }[] = [];
+  constructor() {}
+
+  /**
+   * Total size of bytes
+   */
+  size() {
+    return this.#len;
+  }
+  /**
+   * Push bytes with given offset infos
+   */
+  add(value: Uint8Array, start = 0, end = value.byteLength) {
+    if (value.byteLength === 0 || end - start === 0) {
+      return;
+    }
+    checkRange(start, end, value.byteLength);
+    this.#chunks.push({
+      value,
+      end,
+      start,
+      offset: this.#len,
+    });
+    this.#len += end - start;
+  }
+
+  /**
+   * Drop head `n` bytes.
+   */
+  shift(n: number) {
+    if (n === 0) {
+      return;
+    }
+    if (this.#len <= n) {
+      this.#chunks = [];
+      this.#len = 0;
+      return;
+    }
+    const idx = this.getChunkIndex(n);
+    this.#chunks.splice(0, idx);
+    const [chunk] = this.#chunks;
+    if (chunk) {
+      const diff = n - chunk.offset;
+      chunk.start += diff;
+    }
+    let offset = 0;
+    for (const chunk of this.#chunks) {
+      chunk.offset = offset;
+      offset += chunk.end - chunk.start;
+    }
+    this.#len = offset;
+  }
+
+  /**
+   * Find chunk index in which `pos` locates by binary-search
+   * returns -1 if out of range
+   */
+  getChunkIndex(pos: number): number {
+    let max = this.#chunks.length;
+    let min = 0;
+    while (true) {
+      const i = min + Math.floor((max - min) / 2);
+      if (i < 0 || this.#chunks.length <= i) {
+        return -1;
+      }
+      const { offset, start, end } = this.#chunks[i];
+      const len = end - start;
+      if (offset <= pos && pos < offset + len) {
+        return i;
+      } else if (offset + len <= pos) {
+        min = i + 1;
+      } else {
+        max = i - 1;
+      }
+    }
+  }
+
+  /**
+   * Get indexed byte from chunks
+   */
+  get(i: number): number {
+    if (i < 0 || this.#len <= i) {
+      throw new Error("out of range");
+    }
+    const idx = this.getChunkIndex(i);
+    const { value, offset, start } = this.#chunks[idx];
+    return value[start + i - offset];
+  }
+
+  /**
+   * Iterator of bytes from given position
+   */
+  *iterator(start = 0): IterableIterator<number> {
+    const startIdx = this.getChunkIndex(start);
+    if (startIdx < 0) return;
+    const first = this.#chunks[startIdx];
+    let firstOffset = start - first.offset;
+    for (let i = startIdx; i < this.#chunks.length; i++) {
+      const chunk = this.#chunks[i];
+      for (let j = chunk.start + firstOffset; j < chunk.end; j++) {
+        yield chunk.value[j];
+      }
+      firstOffset = 0;
+    }
+  }
+
+  /**
+   * Returns subset of bytes copied
+   */
+  slice(start: number, end: number = this.#len): Uint8Array {
+    if (end === start) {
+      return new Uint8Array();
+    }
+    checkRange(start, end, this.#len);
+    const result = new Uint8Array(end - start);
+    const startIdx = this.getChunkIndex(start);
+    const endIdx = this.getChunkIndex(end - 1);
+    let written = 0;
+    for (let i = startIdx; i < endIdx; i++) {
+      const chunk = this.#chunks[i];
+      const len = chunk.end - chunk.start;
+      result.set(chunk.value.subarray(chunk.start, chunk.end), written);
+      written += len;
+    }
+    const last = this.#chunks[endIdx];
+    const rest = end - start - written;
+    result.set(last.value.subarray(last.start, last.start + rest), written);
+    return result;
+  }
+  /**
+   * Concatenate chunks into single Uint8Array copied.
+   */
+  concat(): Uint8Array {
+    const result = new Uint8Array(this.#len);
+    let sum = 0;
+    for (const { value, start, end } of this.#chunks) {
+      result.set(value.subarray(start, end), sum);
+      sum += end - start;
+    }
+    return result;
+  }
+}
+
+function checkRange(start: number, end: number, len: number) {
+  if (start < 0 || len < start || end < 0 || len < end || end < start) {
+    throw new Error("invalid range");
+  }
+}
@@ -0,0 +1,26 @@
+// Copyright 2018-2023 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/concat.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;
+}
@@ -0,0 +1,38 @@
+// Copyright 2018-2023 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/copy.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/copy.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;
+}
@@ -0,0 +1,25 @@
+// Copyright 2018-2023 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/ends_with.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;
+}
@@ -0,0 +1,44 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/** Check whether binary arrays are equal to each other using 8-bit comparisons.
+ * @private
+ * @param a first array to check equality
+ * @param b second array to check equality
+ */
+function equalsNaive(a: Uint8Array, b: Uint8Array): boolean {
+  for (let i = 0; i < b.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+/** Check whether binary arrays are equal to each other using 32-bit comparisons.
+ * @private
+ * @param a first array to check equality
+ * @param b second array to check equality
+ */
+function equals32Bit(a: Uint8Array, b: Uint8Array): boolean {
+  const len = a.length;
+  const compressable = Math.floor(len / 4);
+  const compressedA = new Uint32Array(a.buffer, 0, compressable);
+  const compressedB = new Uint32Array(b.buffer, 0, compressable);
+  for (let i = compressable * 4; i < len; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  for (let i = 0; i < compressedA.length; i++) {
+    if (compressedA[i] !== compressedB[i]) return false;
+  }
+  return true;
+}
+
+/** Check whether binary arrays are equal to each other.
+ * @param a first array to check equality
+ * @param b second array to check equality
+ */
+export function equals(a: Uint8Array, b: Uint8Array): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.length < 1000 ? equalsNaive(a, b) : equals32Bit(a, b);
+}
@@ -0,0 +1,27 @@
+// Copyright 2018-2023 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/includes_needle.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;
+}
@@ -0,0 +1,49 @@
+// Copyright 2018-2023 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/index_of_needle.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;
+}
@@ -0,0 +1,49 @@
+// Copyright 2018-2023 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.
+ *
+ * A start index can be specified as the third argument that begins the search
+ * at that given index. The start index defaults to the end of the array.
+ *
+ * The complexity of this function is O(source.lenth * needle.length).
+ *
+ * ```ts
+ * import { lastIndexOfNeedle } from "https://deno.land/std@$STD_VERSION/bytes/last_index_of_needle.ts";
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const needle = new Uint8Array([1, 2]);
+ * console.log(lastIndexOfNeedle(source, needle)); // 5
+ * console.log(lastIndexOfNeedle(source, needle, 4)); // 3
+ * ```
+ */
+export function lastIndexOfNeedle(
+  source: Uint8Array,
+  needle: Uint8Array,
+  start = source.length - 1,
+): number {
+  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;
+    const pin = i;
+    let matched = 1;
+    let j = i;
+    while (matched < needle.length) {
+      j--;
+      if (source[j] !== needle[needle.length - 1 - (pin - j)]) {
+        break;
+      }
+      matched++;
+    }
+    if (matched === needle.length) {
+      return pin - needle.length + 1;
+    }
+  }
+  return -1;
+}
@@ -0,0 +1,20 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * Provides helper functions to manipulate `Uint8Array` byte slices that are not
+ * included on the `Uint8Array` prototype.
+ *
+ * @module
+ */
+
+export * from "./bytes_list.ts";
+export * from "./concat.ts";
+export * from "./copy.ts";
+export * from "./ends_with.ts";
+export * from "./equals.ts";
+export * from "./includes_needle.ts";
+export * from "./index_of_needle.ts";
+export * from "./last_index_of_needle.ts";
+export * from "./repeat.ts";
+export * from "./starts_with.ts";
@@ -0,0 +1,40 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { copy } from "./copy.ts";
+
+/** Returns a new Uint8Array composed of `count` repetitions of the `source`
+ * array.
+ *
+ * If `count` is negative, a `RangeError` is thrown.
+ *
+ * ```ts
+ * import { repeat } from "https://deno.land/std@$STD_VERSION/bytes/repeat.ts";
+ * const source = new Uint8Array([0, 1, 2]);
+ * console.log(repeat(source, 3)); // [0, 1, 2, 0, 1, 2, 0, 1, 2]
+ * console.log(repeat(source, 0)); // []
+ * console.log(repeat(source, -1)); // RangeError
+ * ```
+ */
+export function repeat(source: Uint8Array, count: number): Uint8Array {
+  if (count === 0) {
+    return new Uint8Array();
+  }
+
+  if (count < 0) {
+    throw new RangeError("bytes: negative repeat count");
+  }
+
+  if (!Number.isInteger(count)) {
+    throw new Error("bytes: repeat count must be an integer");
+  }
+
+  const nb = new Uint8Array(source.length * count);
+
+  let bp = copy(source, nb);
+
+  for (; bp < nb.length; bp *= 2) {
+    copy(nb.slice(0, bp), nb, bp);
+  }
+
+  return nb;
+}
@@ -0,0 +1,21 @@
+// Copyright 2018-2023 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).
+ *
+ * ```ts
+ * import { startsWith } from "https://deno.land/std@$STD_VERSION/bytes/starts_with.ts";
+ * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);
+ * const prefix = new Uint8Array([0, 1, 2]);
+ * console.log(startsWith(source, prefix)); // true
+ * ```
+ */
+export function startsWith(source: Uint8Array, prefix: Uint8Array): boolean {
+  for (let i = 0, max = prefix.length; i < max; i++) {
+    if (source[i] !== prefix[i]) return false;
+  }
+  return true;
+}