@netlify/plugin-nextjs 4.40.1 → 4.40.2

package/src/templates/vendor/deno.land/std@0.175.0/async/retry.ts

@@ -0,0 +1,81 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+export class RetryError extends Error {
+  constructor(cause: unknown, count: number) {
+    super(`Exceeded max retry count (${count})`);
+    this.name = "RetryError";
+    this.cause = cause;
+  }
+}
+
+export interface RetryOptions {
+  /** How much to backoff after each retry. This is `2` by default. */
+  multiplier?: number;
+  /** The maximum milliseconds between retries. This is `60000` by default. */
+  maxTimeout?: number;
+  /** The maximum amount of retries until failure. This is `5` by default. */
+  maxAttempts?: number;
+  /** The inital and minimum amount of milliseconds between retries. This is `1000` by default. */
+  minTimeout?: number;
+}
+
+const defaultRetryOptions = {
+  multiplier: 2,
+  maxTimeout: 60000,
+  maxAttempts: 5,
+  minTimeout: 1000,
+};
+
+/**
+ * Creates a retry promise which resolves to the value of the input using exponential backoff.
+ * If the input promise throws, it will be retried `maxAttempts` number of times.
+ * It will retry the input every certain amount of milliseconds, starting at `minTimeout` and multiplying by the `multiplier` until it reaches the `maxTimeout`
+ *
+ * @example
+ * ```typescript
+ * import { retry } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ * const req = async () => {
+ *  // some function that throws sometimes
+ * };
+ *
+ * // Below resolves to the first non-error result of `req`
+ * const retryPromise = await retry(req, {
+ *  multiplier: 2,
+ *  maxTimeout: 60000,
+ *  maxAttempts: 5,
+ *  minTimeout: 100,
+ * });
+```
+ */
+export async function retry<T>(
+  fn: (() => Promise<T>) | (() => T),
+  opts?: RetryOptions,
+) {
+  const options: Required<RetryOptions> = {
+    ...defaultRetryOptions,
+    ...opts,
+  };
+
+  if (options.maxTimeout >= 0 && options.minTimeout > options.maxTimeout) {
+    throw new RangeError("minTimeout is greater than maxTimeout");
+  }
+
+  let timeout = options.minTimeout;
+  let error: unknown;
+
+  for (let i = 0; i < options.maxAttempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      await new Promise((r) => setTimeout(r, timeout));
+      timeout *= options.multiplier;
+      timeout = Math.max(timeout, options.minTimeout);
+      if (options.maxTimeout >= 0) {
+        timeout = Math.min(timeout, options.maxTimeout);
+      }
+      error = err;
+    }
+  }
+
+  throw new RetryError(error, options.maxAttempts);
+}

package/src/templates/vendor/deno.land/std@0.175.0/async/tee.ts

@@ -0,0 +1,100 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+// Utility for representing n-tuple
+type Tuple<T, N extends number> = N extends N
+  ? number extends N ? T[] : TupleOf<T, N, []>
+  : never;
+type TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N
+  ? R
+  : TupleOf<T, N, [T, ...R]>;
+
+interface QueueNode<T> {
+  value: T;
+  next: QueueNode<T> | undefined;
+}
+
+class Queue<T> {
+  #source: AsyncIterator<T>;
+  #queue: QueueNode<T>;
+  head: QueueNode<T>;
+
+  done: boolean;
+
+  constructor(iterable: AsyncIterable<T>) {
+    this.#source = iterable[Symbol.asyncIterator]();
+    this.#queue = {
+      value: undefined!,
+      next: undefined,
+    };
+    this.head = this.#queue;
+    this.done = false;
+  }
+
+  async next() {
+    const result = await this.#source.next();
+    if (!result.done) {
+      const nextNode: QueueNode<T> = {
+        value: result.value,
+        next: undefined,
+      };
+      this.#queue.next = nextNode;
+      this.#queue = nextNode;
+    } else {
+      this.done = true;
+    }
+  }
+}
+
+/**
+ * Branches the given async iterable into the n branches.
+ *
+ * @example
+ * ```ts
+ * import { tee } from "https://deno.land/std@$STD_VERSION/async/tee.ts";
+ *
+ * const gen = async function* gen() {
+ *   yield 1;
+ *   yield 2;
+ *   yield 3;
+ * };
+ *
+ * const [branch1, branch2] = tee(gen());
+ *
+ * for await (const n of branch1) {
+ *   console.log(n); // => 1, 2, 3
+ * }
+ *
+ * for await (const n of branch2) {
+ *   console.log(n); // => 1, 2, 3
+ * }
+ * ```
+ */
+export function tee<T, N extends number = 2>(
+  iterable: AsyncIterable<T>,
+  n: N = 2 as N,
+): Tuple<AsyncIterable<T>, N> {
+  const queue = new Queue<T>(iterable);
+
+  async function* generator(): AsyncGenerator<T> {
+    let buffer = queue.head;
+    while (true) {
+      if (buffer.next) {
+        buffer = buffer.next;
+        yield buffer.value;
+      } else if (queue.done) {
+        return;
+      } else {
+        await queue.next();
+      }
+    }
+  }
+
+  const branches = Array.from({ length: n }).map(
+    () => generator(),
+  ) as Tuple<
+    AsyncIterable<T>,
+    N
+  >;
+  return branches;
+}

package/src/templates/vendor/deno.land/std@0.175.0/bytes/index_of_needle.ts

@@ -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;
+}

package/src/templates/vendor/deno.land/std@0.175.0/crypto/timing_safe_equal.ts

@@ -0,0 +1,29 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import { assert } from "../_util/asserts.ts";
+
+/** Compare to array buffers or data views in a way that timing based attacks
+ * cannot gain information about the platform. */
+export function timingSafeEqual(
+  a: ArrayBufferView | ArrayBufferLike | DataView,
+  b: ArrayBufferView | ArrayBufferLike | DataView,
+): boolean {
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  if (!(a instanceof DataView)) {
+    a = new DataView(ArrayBuffer.isView(a) ? a.buffer : a);
+  }
+  if (!(b instanceof DataView)) {
+    b = new DataView(ArrayBuffer.isView(b) ? b.buffer : b);
+  }
+  assert(a instanceof DataView);
+  assert(b instanceof DataView);
+  const length = a.byteLength;
+  let out = 0;
+  let i = -1;
+  while (++i < length) {
+    out |= a.getUint8(i) ^ b.getUint8(i);
+  }
+  return out === 0;
+}

package/src/templates/vendor/deno.land/std@0.175.0/datetime/to_imf.ts

@@ -0,0 +1,45 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * Formats the given date to IMF date time format. (Reference:
+ * https://tools.ietf.org/html/rfc7231#section-7.1.1.1).
+ * IMF is the time format to use when generating times in HTTP
+ * headers. The time being formatted must be in UTC for Format to
+ * generate the correct format.
+ *
+ * @example
+ * ```ts
+ * import { toIMF } from "https://deno.land/std@$STD_VERSION/datetime/to_imf.ts";
+ *
+ * toIMF(new Date(0)); // => returns "Thu, 01 Jan 1970 00:00:00 GMT"
+ * ```
+ * @param date Date to parse
+ * @return IMF date formatted string
+ */
+export function toIMF(date: Date): string {
+  function dtPad(v: string, lPad = 2): string {
+    return v.padStart(lPad, "0");
+  }
+  const d = dtPad(date.getUTCDate().toString());
+  const h = dtPad(date.getUTCHours().toString());
+  const min = dtPad(date.getUTCMinutes().toString());
+  const s = dtPad(date.getUTCSeconds().toString());
+  const y = date.getUTCFullYear();
+  const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const months = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+  ];
+  return `${days[date.getUTCDay()]}, ${d} ${
+    months[date.getUTCMonth()]
+  } ${y} ${h}:${min}:${s} GMT`;
+}

package/src/templates/vendor/deno.land/std@0.175.0/encoding/base64.ts

@@ -0,0 +1,144 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+/**
+ * {@linkcode encode} and {@linkcode decode} for
+ * [base64](https://en.wikipedia.org/wiki/Base64) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * const b64Repr = "Zm9vYg==";
+ *
+ * const binaryData = decode(b64Repr);
+ * console.log(binaryData);
+ * // => Uint8Array [ 102, 111, 111, 98 ]
+ *
+ * console.log(encode(binaryData));
+ * // => Zm9vYg==
+ * ```
+ *
+ * @module
+ */
+
+const base64abc = [
+  "A",
+  "B",
+  "C",
+  "D",
+  "E",
+  "F",
+  "G",
+  "H",
+  "I",
+  "J",
+  "K",
+  "L",
+  "M",
+  "N",
+  "O",
+  "P",
+  "Q",
+  "R",
+  "S",
+  "T",
+  "U",
+  "V",
+  "W",
+  "X",
+  "Y",
+  "Z",
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z",
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "+",
+  "/",
+];
+
+/**
+ * CREDIT: https://gist.github.com/enepomnyaschih/72c423f727d395eeaa09697058238727
+ * Encodes a given Uint8Array, ArrayBuffer or string into RFC4648 base64 representation
+ * @param data
+ */
+export function encode(data: ArrayBuffer | string): string {
+  const uint8 = typeof data === "string"
+    ? new TextEncoder().encode(data)
+    : data instanceof Uint8Array
+    ? data
+    : new Uint8Array(data);
+  let result = "",
+    i;
+  const l = uint8.length;
+  for (i = 2; i < l; i += 3) {
+    result += base64abc[uint8[i - 2] >> 2];
+    result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+    result += base64abc[((uint8[i - 1] & 0x0f) << 2) | (uint8[i] >> 6)];
+    result += base64abc[uint8[i] & 0x3f];
+  }
+  if (i === l + 1) {
+    // 1 octet yet to write
+    result += base64abc[uint8[i - 2] >> 2];
+    result += base64abc[(uint8[i - 2] & 0x03) << 4];
+    result += "==";
+  }
+  if (i === l) {
+    // 2 octets yet to write
+    result += base64abc[uint8[i - 2] >> 2];
+    result += base64abc[((uint8[i - 2] & 0x03) << 4) | (uint8[i - 1] >> 4)];
+    result += base64abc[(uint8[i - 1] & 0x0f) << 2];
+    result += "=";
+  }
+  return result;
+}
+
+/**
+ * Decodes a given RFC4648 base64 encoded string
+ * @param b64
+ */
+export function decode(b64: string): Uint8Array {
+  const binString = atob(b64);
+  const size = binString.length;
+  const bytes = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    bytes[i] = binString.charCodeAt(i);
+  }
+  return bytes;
+}

package/src/templates/vendor/deno.land/std@0.175.0/encoding/base64url.ts

@@ -0,0 +1,70 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+/**
+ * {@linkcode encode} and {@linkcode decode} for
+ * [base64 URL safe](https://en.wikipedia.org/wiki/Base64#URL_applications) encoding.
+ *
+ * This module is browser compatible.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64url.ts";
+ *
+ * const binary = new TextEncoder().encode("foobar");
+ * const encoded = encode(binary);
+ * console.log(encoded);
+ * // => "Zm9vYmFy"
+ *
+ * console.log(decode(encoded));
+ * // => Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * ```
+ *
+ * @module
+ */
+
+import * as base64 from "./base64.ts";
+
+/*
+ * Some variants allow or require omitting the padding '=' signs:
+ * https://en.wikipedia.org/wiki/Base64#The_URL_applications
+ * @param base64url
+ */
+function addPaddingToBase64url(base64url: string): string {
+  if (base64url.length % 4 === 2) return base64url + "==";
+  if (base64url.length % 4 === 3) return base64url + "=";
+  if (base64url.length % 4 === 1) {
+    throw new TypeError("Illegal base64url string!");
+  }
+  return base64url;
+}
+
+function convertBase64urlToBase64(b64url: string): string {
+  if (!/^[-_A-Z0-9]*?={0,2}$/i.test(b64url)) {
+    // Contains characters not part of base64url spec.
+    throw new TypeError("Failed to decode base64url: invalid character");
+  }
+  return addPaddingToBase64url(b64url).replace(/\-/g, "+").replace(/_/g, "/");
+}
+
+function convertBase64ToBase64url(b64: string): string {
+  return b64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+
+/**
+ * Encodes a given ArrayBuffer or string into a base64url representation
+ * @param data
+ */
+export function encode(data: ArrayBuffer | string): string {
+  return convertBase64ToBase64url(base64.encode(data));
+}
+
+/**
+ * Converts given base64url encoded data back to original
+ * @param b64url
+ */
+export function decode(b64url: string): Uint8Array {
+  return base64.decode(convertBase64urlToBase64(b64url));
+}