@netlify/plugin-nextjs 4.40.0 → 4.40.2

package/src/templates/vendor/deno.land/std@0.175.0/_util/asserts.ts

@@ -0,0 +1,25 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
+ */
+
+export class DenoStdInternalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "DenoStdInternalError";
+  }
+}
+
+/** Make an assertion, if not `true`, then throw. */
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new DenoStdInternalError(msg);
+  }
+}
+
+/** Use this to assert unreachable code. */
+export function unreachable(): never {
+  throw new DenoStdInternalError("unreachable");
+}

package/src/templates/vendor/deno.land/std@0.175.0/_util/os.ts

@@ -0,0 +1,23 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+export type OSType = "windows" | "linux" | "darwin" | "freebsd";
+
+export const osType: OSType = (() => {
+  // deno-lint-ignore no-explicit-any
+  const { Deno } = globalThis as any;
+  if (typeof Deno?.build?.os === "string") {
+    return Deno.build.os;
+  }
+
+  // deno-lint-ignore no-explicit-any
+  const { navigator } = globalThis as any;
+  if (navigator?.appVersion?.includes?.("Win")) {
+    return "windows";
+  }
+
+  return "linux";
+})();
+
+export const isWindows = osType === "windows";
+export const isLinux = osType === "linux";

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

@@ -0,0 +1,149 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { deferred } from "./deferred.ts";
+
+/**
+ * Make Promise abortable with the given signal.
+ *
+ * @example
+ * ```typescript
+ * import { abortable } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ * import { delay } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ *
+ * const p = delay(1000);
+ * const c = new AbortController();
+ * setTimeout(() => c.abort(), 100);
+ *
+ * // Below throws `DOMException` after 100 ms
+ * await abortable(p, c.signal);
+ * ```
+ */
+export function abortable<T>(p: Promise<T>, signal: AbortSignal): Promise<T>;
+/**
+ * Make AsyncIterable abortable with the given signal.
+ *
+ * @example
+ * ```typescript
+ * import { abortable } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ * import { delay } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ *
+ * const p = async function* () {
+ *   yield "Hello";
+ *   await delay(1000);
+ *   yield "World";
+ * };
+ * const c = new AbortController();
+ * setTimeout(() => c.abort(), 100);
+ *
+ * // Below throws `DOMException` after 100 ms
+ * // and items become `["Hello"]`
+ * const items: string[] = [];
+ * for await (const item of abortable(p(), c.signal)) {
+ *   items.push(item);
+ * }
+ * ```
+ */
+export function abortable<T>(
+  p: AsyncIterable<T>,
+  signal: AbortSignal,
+): AsyncGenerator<T>;
+export function abortable<T>(
+  p: Promise<T> | AsyncIterable<T>,
+  signal: AbortSignal,
+): Promise<T> | AsyncIterable<T> {
+  if (p instanceof Promise) {
+    return abortablePromise(p, signal);
+  } else {
+    return abortableAsyncIterable(p, signal);
+  }
+}
+
+/**
+ * Make Promise abortable with the given signal.
+ *
+ * @example
+ * ```typescript
+ * import { abortablePromise } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ *
+ * const request = fetch("https://example.com");
+ *
+ * const c = new AbortController();
+ * setTimeout(() => c.abort(), 100);
+ *
+ * const p = abortablePromise(request, c.signal);
+ *
+ * // The below throws if the request didn't resolve in 100ms
+ * await p;
+ * ```
+ */
+export function abortablePromise<T>(
+  p: Promise<T>,
+  signal: AbortSignal,
+): Promise<T> {
+  if (signal.aborted) {
+    return Promise.reject(createAbortError(signal.reason));
+  }
+  const waiter = deferred<never>();
+  const abort = () => waiter.reject(createAbortError(signal.reason));
+  signal.addEventListener("abort", abort, { once: true });
+  return Promise.race([
+    waiter,
+    p.finally(() => {
+      signal.removeEventListener("abort", abort);
+    }),
+  ]);
+}
+
+/**
+ * Make AsyncIterable abortable with the given signal.
+ *
+ * @example
+ * ```typescript
+ * import { abortableAsyncIterable } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ * import { delay } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ *
+ * const p = async function* () {
+ *   yield "Hello";
+ *   await delay(1000);
+ *   yield "World";
+ * };
+ * const c = new AbortController();
+ * setTimeout(() => c.abort(), 100);
+ *
+ * // Below throws `DOMException` after 100 ms
+ * // and items become `["Hello"]`
+ * const items: string[] = [];
+ * for await (const item of abortableAsyncIterable(p(), c.signal)) {
+ *   items.push(item);
+ * }
+ * ```
+ */
+export async function* abortableAsyncIterable<T>(
+  p: AsyncIterable<T>,
+  signal: AbortSignal,
+): AsyncGenerator<T> {
+  if (signal.aborted) {
+    throw createAbortError(signal.reason);
+  }
+  const waiter = deferred<never>();
+  const abort = () => waiter.reject(createAbortError(signal.reason));
+  signal.addEventListener("abort", abort, { once: true });
+
+  const it = p[Symbol.asyncIterator]();
+  while (true) {
+    const { done, value } = await Promise.race([waiter, it.next()]);
+    if (done) {
+      signal.removeEventListener("abort", abort);
+      return;
+    }
+    yield value;
+  }
+}
+
+// This `reason` comes from `AbortSignal` thus must be `any`.
+// deno-lint-ignore no-explicit-any
+function createAbortError(reason?: any): DOMException {
+  return new DOMException(
+    reason ? `Aborted: ${reason}` : "Aborted",
+    "AbortError",
+  );
+}

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

@@ -0,0 +1,30 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { deferred } from "./deferred.ts";
+
+export class DeadlineError extends Error {
+  constructor() {
+    super("Deadline");
+    this.name = "DeadlineError";
+  }
+}
+
+/**
+ * Create a promise which will be rejected with {@linkcode DeadlineError} when a given delay is exceeded.
+ *
+ * @example
+ * ```typescript
+ * import { deadline } from "https://deno.land/std@$STD_VERSION/async/deadline.ts";
+ * import { delay } from "https://deno.land/std@$STD_VERSION/async/delay.ts";
+ *
+ * const delayedPromise = delay(1000);
+ * // Below throws `DeadlineError` after 10 ms
+ * const result = await deadline(delayedPromise, 10);
+ * ```
+ */
+export function deadline<T>(p: Promise<T>, delay: number): Promise<T> {
+  const d = deferred<never>();
+  const t = setTimeout(() => d.reject(new DeadlineError()), delay);
+  return Promise.race([p, d]).finally(() => clearTimeout(t));
+}

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

@@ -0,0 +1,79 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+/**
+ * A debounced function that will be delayed by a given `wait`
+ * time in milliseconds. If the method is called again before
+ * the timeout expires, the previous call will be aborted.
+ */
+export interface DebouncedFunction<T extends Array<unknown>> {
+  (...args: T): void;
+  /** Clears the debounce timeout and omits calling the debounced function. */
+  clear(): void;
+  /** Clears the debounce timeout and calls the debounced function immediately. */
+  flush(): void;
+  /** Returns a boolean whether a debounce call is pending or not. */
+  readonly pending: boolean;
+}
+
+/**
+ * Creates a debounced function that delays the given `func`
+ * by a given `wait` time in milliseconds. If the method is called
+ * again before the timeout expires, the previous call will be
+ * aborted.
+ *
+ * @example
+ * ```
+ * import { debounce } from "https://deno.land/std@$STD_VERSION/async/debounce.ts";
+ *
+ * const log = debounce(
+ *   (event: Deno.FsEvent) =>
+ *     console.log("[%s] %s", event.kind, event.paths[0]),
+ *   200,
+ * );
+ *
+ * for await (const event of Deno.watchFs("./")) {
+ *   log(event);
+ * }
+ * // wait 200ms ...
+ * // output: Function debounced after 200ms with baz
+ * ```
+ *
+ * @param fn    The function to debounce.
+ * @param wait  The time in milliseconds to delay the function.
+ */
+// deno-lint-ignore no-explicit-any
+export function debounce<T extends Array<any>>(
+  fn: (this: DebouncedFunction<T>, ...args: T) => void,
+  wait: number,
+): DebouncedFunction<T> {
+  let timeout: number | null = null;
+  let flush: (() => void) | null = null;
+
+  const debounced: DebouncedFunction<T> = ((...args: T) => {
+    debounced.clear();
+    flush = () => {
+      debounced.clear();
+      fn.call(debounced, ...args);
+    };
+    timeout = setTimeout(flush, wait);
+  }) as DebouncedFunction<T>;
+
+  debounced.clear = () => {
+    if (typeof timeout === "number") {
+      clearTimeout(timeout);
+      timeout = null;
+      flush = null;
+    }
+  };
+
+  debounced.flush = () => {
+    flush?.();
+  };
+
+  Object.defineProperty(debounced, "pending", {
+    get: () => typeof timeout === "number",
+  });
+
+  return debounced;
+}

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

@@ -0,0 +1,48 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+// TODO(ry) It'd be better to make Deferred a class that inherits from
+// Promise, rather than an interface. This is possible in ES2016, however
+// typescript produces broken code when targeting ES5 code.
+// See https://github.com/Microsoft/TypeScript/issues/15202
+// At the time of writing, the github issue is closed but the problem remains.
+export interface Deferred<T> extends Promise<T> {
+  readonly state: "pending" | "fulfilled" | "rejected";
+  resolve(value?: T | PromiseLike<T>): void;
+  // deno-lint-ignore no-explicit-any
+  reject(reason?: any): void;
+}
+
+/**
+ * Creates a Promise with the `reject` and `resolve` functions placed as methods
+ * on the promise object itself.
+ *
+ * @example
+ * ```typescript
+ * import { deferred } from "https://deno.land/std@$STD_VERSION/async/deferred.ts";
+ *
+ * const p = deferred<number>();
+ * // ...
+ * p.resolve(42);
+ * ```
+ */
+export function deferred<T>(): Deferred<T> {
+  let methods;
+  let state = "pending";
+  const promise = new Promise<T>((resolve, reject) => {
+    methods = {
+      async resolve(value: T | PromiseLike<T>) {
+        await value;
+        state = "fulfilled";
+        resolve(value);
+      },
+      // deno-lint-ignore no-explicit-any
+      reject(reason?: any) {
+        state = "rejected";
+        reject(reason);
+      },
+    };
+  });
+  Object.defineProperty(promise, "state", { get: () => state });
+  return Object.assign(promise, methods) as Deferred<T>;
+}

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

@@ -0,0 +1,67 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+export interface DelayOptions {
+  /** Signal used to abort the delay. */
+  signal?: AbortSignal;
+  /** Indicates whether the process should continue to run as long as the timer exists.
+   *
+   * @default {true}
+   */
+  persistent?: boolean;
+}
+
+/**
+ * Resolve a Promise after a given amount of milliseconds.
+ *
+ * @example
+ *
+ * ```typescript
+ * import { delay } from "https://deno.land/std@$STD_VERSION/async/delay.ts";
+ *
+ * // ...
+ * const delayedPromise = delay(100);
+ * const result = await delayedPromise;
+ * // ...
+ * ```
+ *
+ * To allow the process to continue to run as long as the timer exists. Requires
+ * `--unstable` flag.
+ *
+ * ```typescript
+ * import { delay } from "https://deno.land/std@$STD_VERSION/async/delay.ts";
+ *
+ * // ...
+ * await delay(100, { persistent: false });
+ * // ...
+ * ```
+ */
+export function delay(ms: number, options: DelayOptions = {}): Promise<void> {
+  const { signal, persistent } = options;
+  if (signal?.aborted) {
+    return Promise.reject(new DOMException("Delay was aborted.", "AbortError"));
+  }
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(i);
+      reject(new DOMException("Delay was aborted.", "AbortError"));
+    };
+    const done = () => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    };
+    const i = setTimeout(done, ms);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (persistent === false) {
+      try {
+        // @ts-ignore For browser compatibility
+        Deno.unrefTimer(i);
+      } catch (error) {
+        if (!(error instanceof ReferenceError)) {
+          throw error;
+        }
+        console.error("`persistent` option is only available in Deno");
+      }
+    }
+  });
+}

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

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+/**
+ * Provide help with asynchronous tasks like delays, debouncing, deferring, or
+ * pooling.
+ *
+ * @module
+ */
+
+export * from "./abortable.ts";
+export * from "./deadline.ts";
+export * from "./debounce.ts";
+export * from "./deferred.ts";
+export * from "./delay.ts";
+export * from "./mux_async_iterator.ts";
+export * from "./pool.ts";
+export * from "./tee.ts";
+export * from "./retry.ts";

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

@@ -0,0 +1,97 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+
+import { Deferred, deferred } from "./deferred.ts";
+
+interface TaggedYieldedValue<T> {
+  iterator: AsyncIterator<T>;
+  value: T;
+}
+
+/**
+ * The MuxAsyncIterator class multiplexes multiple async iterators into a single
+ * stream. It currently makes an assumption that the final result (the value
+ * returned and not yielded from the iterator) does not matter; if there is any
+ * result, it is discarded.
+ *
+ * @example
+ * ```typescript
+ * import { MuxAsyncIterator } from "https://deno.land/std@$STD_VERSION/async/mod.ts";
+ *
+ * async function* gen123(): AsyncIterableIterator<number> {
+ *   yield 1;
+ *   yield 2;
+ *   yield 3;
+ * }
+ *
+ * async function* gen456(): AsyncIterableIterator<number> {
+ *   yield 4;
+ *   yield 5;
+ *   yield 6;
+ * }
+ *
+ * const mux = new MuxAsyncIterator<number>();
+ * mux.add(gen123());
+ * mux.add(gen456());
+ * for await (const value of mux) {
+ *   // ...
+ * }
+ * // ..
+ * ```
+ */
+export class MuxAsyncIterator<T> implements AsyncIterable<T> {
+  #iteratorCount = 0;
+  #yields: Array<TaggedYieldedValue<T>> = [];
+  // deno-lint-ignore no-explicit-any
+  #throws: any[] = [];
+  #signal: Deferred<void> = deferred();
+
+  add(iterable: AsyncIterable<T>) {
+    ++this.#iteratorCount;
+    this.#callIteratorNext(iterable[Symbol.asyncIterator]());
+  }
+
+  async #callIteratorNext(
+    iterator: AsyncIterator<T>,
+  ) {
+    try {
+      const { value, done } = await iterator.next();
+      if (done) {
+        --this.#iteratorCount;
+      } else {
+        this.#yields.push({ iterator, value });
+      }
+    } catch (e) {
+      this.#throws.push(e);
+    }
+    this.#signal.resolve();
+  }
+
+  async *iterate(): AsyncIterableIterator<T> {
+    while (this.#iteratorCount > 0) {
+      // Sleep until any of the wrapped iterators yields.
+      await this.#signal;
+
+      // Note that while we're looping over `yields`, new items may be added.
+      for (let i = 0; i < this.#yields.length; i++) {
+        const { iterator, value } = this.#yields[i];
+        yield value;
+        this.#callIteratorNext(iterator);
+      }
+
+      if (this.#throws.length) {
+        for (const e of this.#throws) {
+          throw e;
+        }
+        this.#throws.length = 0;
+      }
+      // Clear the `yields` list and reset the `signal` promise.
+      this.#yields.length = 0;
+      this.#signal = deferred();
+    }
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<T> {
+    return this.iterate();
+  }
+}

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

@@ -0,0 +1,95 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+export const ERROR_WHILE_MAPPING_MESSAGE = "Threw while mapping.";
+
+/**
+ * pooledMap transforms values from an (async) iterable into another async
+ * iterable. The transforms are done concurrently, with a max concurrency
+ * defined by the poolLimit.
+ *
+ * If an error is thrown from `iterableFn`, no new transformations will begin.
+ * All currently executing transformations are allowed to finish and still
+ * yielded on success. After that, the rejections among them are gathered and
+ * thrown by the iterator in an `AggregateError`.
+ *
+ * @example
+ * ```typescript
+ * import { pooledMap } from "https://deno.land/std@$STD_VERSION/async/pool.ts";
+ *
+ * const results = pooledMap(
+ *   2,
+ *   [1, 2, 3],
+ *   (i) => new Promise((r) => setTimeout(() => r(i), 1000)),
+ * );
+ *
+ * for await (const value of results) {
+ *   // ...
+ * }
+ * ```
+ *
+ * @param poolLimit The maximum count of items being processed concurrently.
+ * @param array The input array for mapping.
+ * @param iteratorFn The function to call for every item of the array.
+ */
+export function pooledMap<T, R>(
+  poolLimit: number,
+  array: Iterable<T> | AsyncIterable<T>,
+  iteratorFn: (data: T) => Promise<R>,
+): AsyncIterableIterator<R> {
+  // Create the async iterable that is returned from this function.
+  const res = new TransformStream<Promise<R>, R>({
+    async transform(
+      p: Promise<R>,
+      controller: TransformStreamDefaultController<R>,
+    ) {
+      try {
+        const s = await p;
+        controller.enqueue(s);
+      } catch (e) {
+        if (
+          e instanceof AggregateError &&
+          e.message == ERROR_WHILE_MAPPING_MESSAGE
+        ) {
+          controller.error(e as unknown);
+        }
+      }
+    },
+  });
+  // Start processing items from the iterator
+  (async () => {
+    const writer = res.writable.getWriter();
+    const executing: Array<Promise<unknown>> = [];
+    try {
+      for await (const item of array) {
+        const p = Promise.resolve().then(() => iteratorFn(item));
+        // Only write on success. If we `writer.write()` a rejected promise,
+        // that will end the iteration. We don't want that yet. Instead let it
+        // fail the race, taking us to the catch block where all currently
+        // executing jobs are allowed to finish and all rejections among them
+        // can be reported together.
+        writer.write(p);
+        const e: Promise<unknown> = p.then(() =>
+          executing.splice(executing.indexOf(e), 1)
+        );
+        executing.push(e);
+        if (executing.length >= poolLimit) {
+          await Promise.race(executing);
+        }
+      }
+      // Wait until all ongoing events have processed, then close the writer.
+      await Promise.all(executing);
+      writer.close();
+    } catch {
+      const errors = [];
+      for (const result of await Promise.allSettled(executing)) {
+        if (result.status == "rejected") {
+          errors.push(result.reason);
+        }
+      }
+      writer.write(Promise.reject(
+        new AggregateError(errors, ERROR_WHILE_MAPPING_MESSAGE),
+      )).catch(() => {});
+    }
+  })();
+  return res.readable[Symbol.asyncIterator]();
+}