@netlify/plugin-nextjs 4.40.0 → 4.40.2

package/src/templates/vendor/deno.land/std@0.175.0/node/_global.d.ts

@@ -0,0 +1,66 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { EventEmitter } from "./_events.d.ts";
+import { Buffer } from "./buffer.ts";
+
+/** One of:
+ * | "ascii"
+ * | "utf8"
+ * | "utf-8"
+ * | "utf16le"
+ * | "ucs2"
+ * | "ucs-2"
+ * | "base64"
+ * | "base64url"
+ * | "latin1"
+ * | "binary"
+ * | "hex";
+ */
+export type BufferEncoding = string;
+
+export interface Buffered {
+  chunk: Buffer;
+  encoding: string;
+  callback: (err?: Error | null) => void;
+}
+
+export interface ErrnoException extends Error {
+  errno?: number | undefined;
+  code?: string | undefined;
+  path?: string | undefined;
+  syscall?: string | undefined;
+}
+
+export interface ReadableStream extends EventEmitter {
+  readable: boolean;
+  read(size?: number): string | Buffer;
+  setEncoding(encoding: BufferEncoding): this;
+  pause(): this;
+  resume(): this;
+  isPaused(): boolean;
+  pipe<T extends WritableStream>(
+    destination: T,
+    options?: { end?: boolean | undefined },
+  ): T;
+  unpipe(destination?: WritableStream): this;
+  unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
+  wrap(oldStream: ReadableStream): this;
+  [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
+}
+
+export interface WritableStream extends EventEmitter {
+  writable: boolean;
+  write(
+    buffer: Uint8Array | string,
+    cb?: (err?: Error | null) => void,
+  ): boolean;
+  write(
+    str: string,
+    encoding?: BufferEncoding,
+    cb?: (err?: Error | null) => void,
+  ): boolean;
+  end(cb?: () => void): void;
+  end(data: string | Uint8Array, cb?: () => void): void;
+  end(str: string, encoding?: BufferEncoding, cb?: () => void): void;
+}
+
+export interface ReadWriteStream extends ReadableStream, WritableStream {}

package/src/templates/vendor/deno.land/std@0.175.0/node/_next_tick.ts

@@ -0,0 +1,173 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and other Node contributors.
+
+// deno-lint-ignore-file no-inner-declarations
+
+import { core } from "./_core.ts";
+import { validateFunction } from "./internal/validators.mjs";
+import { _exiting } from "./_process/exiting.ts";
+import { FixedQueue } from "./internal/fixed_queue.ts";
+
+interface Tock {
+  callback: (...args: Array<unknown>) => void;
+  args: Array<unknown>;
+}
+
+const queue = new FixedQueue();
+
+// deno-lint-ignore no-explicit-any
+let _nextTick: any;
+
+export function processTicksAndRejections() {
+  let tock;
+  do {
+    // deno-lint-ignore no-cond-assign
+    while (tock = queue.shift()) {
+      // FIXME(bartlomieju): Deno currently doesn't support async hooks
+      // const asyncId = tock[async_id_symbol];
+      // emitBefore(asyncId, tock[trigger_async_id_symbol], tock);
+
+      try {
+        const callback = (tock as Tock).callback;
+        if ((tock as Tock).args === undefined) {
+          callback();
+        } else {
+          const args = (tock as Tock).args;
+          switch (args.length) {
+            case 1:
+              callback(args[0]);
+              break;
+            case 2:
+              callback(args[0], args[1]);
+              break;
+            case 3:
+              callback(args[0], args[1], args[2]);
+              break;
+            case 4:
+              callback(args[0], args[1], args[2], args[3]);
+              break;
+            default:
+              callback(...args);
+          }
+        }
+      } finally {
+        // FIXME(bartlomieju): Deno currently doesn't support async hooks
+        // if (destroyHooksExist())
+        // emitDestroy(asyncId);
+      }
+
+      // FIXME(bartlomieju): Deno currently doesn't support async hooks
+      // emitAfter(asyncId);
+    }
+    core.runMicrotasks();
+    // FIXME(bartlomieju): Deno currently doesn't unhandled rejections
+    // } while (!queue.isEmpty() || processPromiseRejections());
+  } while (!queue.isEmpty());
+  core.setHasTickScheduled(false);
+  // FIXME(bartlomieju): Deno currently doesn't unhandled rejections
+  // setHasRejectionToWarn(false);
+}
+
+if (typeof core.setNextTickCallback !== "undefined") {
+  function runNextTicks() {
+    // FIXME(bartlomieju): Deno currently doesn't unhandled rejections
+    // if (!hasTickScheduled() && !hasRejectionToWarn())
+    //   runMicrotasks();
+    // if (!hasTickScheduled() && !hasRejectionToWarn())
+    //   return;
+    if (!core.hasTickScheduled()) {
+      core.runMicrotasks();
+    }
+    if (!core.hasTickScheduled()) {
+      return true;
+    }
+
+    processTicksAndRejections();
+    return true;
+  }
+
+  core.setNextTickCallback(processTicksAndRejections);
+  core.setMacrotaskCallback(runNextTicks);
+
+  function __nextTickNative<T extends Array<unknown>>(
+    this: unknown,
+    callback: (...args: T) => void,
+    ...args: T
+  ) {
+    validateFunction(callback, "callback");
+
+    if (_exiting) {
+      return;
+    }
+
+    // TODO(bartlomieju): seems superfluous if we don't depend on `arguments`
+    let args_;
+    switch (args.length) {
+      case 0:
+        break;
+      case 1:
+        args_ = [args[0]];
+        break;
+      case 2:
+        args_ = [args[0], args[1]];
+        break;
+      case 3:
+        args_ = [args[0], args[1], args[2]];
+        break;
+      default:
+        args_ = new Array(args.length);
+        for (let i = 0; i < args.length; i++) {
+          args_[i] = args[i];
+        }
+    }
+
+    if (queue.isEmpty()) {
+      core.setHasTickScheduled(true);
+    }
+    // FIXME(bartlomieju): Deno currently doesn't support async hooks
+    // const asyncId = newAsyncId();
+    // const triggerAsyncId = getDefaultTriggerAsyncId();
+    const tickObject = {
+      // FIXME(bartlomieju): Deno currently doesn't support async hooks
+      // [async_id_symbol]: asyncId,
+      // [trigger_async_id_symbol]: triggerAsyncId,
+      callback,
+      args: args_,
+    };
+    // FIXME(bartlomieju): Deno currently doesn't support async hooks
+    // if (initHooksExist())
+    //   emitInit(asyncId, 'TickObject', triggerAsyncId, tickObject);
+    queue.push(tickObject);
+  }
+  _nextTick = __nextTickNative;
+} else {
+  function __nextTickQueueMicrotask<T extends Array<unknown>>(
+    this: unknown,
+    callback: (...args: T) => void,
+    ...args: T
+  ) {
+    if (args) {
+      queueMicrotask(() => callback.call(this, ...args));
+    } else {
+      queueMicrotask(callback);
+    }
+  }
+
+  _nextTick = __nextTickQueueMicrotask;
+}
+
+// `nextTick()` will not enqueue any callback when the process is about to
+// exit since the callback would not have a chance to be executed.
+export function nextTick(this: unknown, callback: () => void): void;
+export function nextTick<T extends Array<unknown>>(
+  this: unknown,
+  callback: (...args: T) => void,
+  ...args: T
+): void;
+export function nextTick<T extends Array<unknown>>(
+  this: unknown,
+  callback: (...args: T) => void,
+  ...args: T
+) {
+  _nextTick(callback, ...args);
+}

package/src/templates/vendor/deno.land/std@0.175.0/node/_process/exiting.ts

@@ -0,0 +1,4 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore prefer-const
+export let _exiting = false;

package/src/templates/vendor/deno.land/std@0.175.0/node/_process/process.ts

@@ -0,0 +1,131 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
+
+// The following are all the process APIs that don't depend on the stream module
+// They have to be split this way to prevent a circular dependency
+
+import { isWindows } from "../../_util/os.ts";
+import { nextTick as _nextTick } from "../_next_tick.ts";
+import { _exiting } from "./exiting.ts";
+
+/** Returns the operating system CPU architecture for which the Deno binary was compiled */
+function _arch(): string {
+  if (Deno.build.arch == "x86_64") {
+    return "x64";
+  } else if (Deno.build.arch == "aarch64") {
+    return "arm64";
+  } else {
+    throw Error("unreachable");
+  }
+}
+
+/** https://nodejs.org/api/process.html#process_process_arch */
+export const arch = _arch();
+
+/** https://nodejs.org/api/process.html#process_process_chdir_directory */
+export const chdir = Deno.chdir;
+
+/** https://nodejs.org/api/process.html#process_process_cwd */
+export const cwd = Deno.cwd;
+
+/** https://nodejs.org/api/process.html#process_process_nexttick_callback_args */
+export const nextTick = _nextTick;
+
+/** Wrapper of Deno.env.get, which doesn't throw type error when
+ * the env name has "=" or "\0" in it. */
+function denoEnvGet(name: string) {
+  try {
+    return Deno.env.get(name);
+  } catch (e) {
+    if (e instanceof TypeError) {
+      return undefined;
+    }
+    throw e;
+  }
+}
+
+const OBJECT_PROTO_PROP_NAMES = Object.getOwnPropertyNames(Object.prototype);
+/**
+ * https://nodejs.org/api/process.html#process_process_env
+ * Requires env permissions
+ */
+export const env: InstanceType<ObjectConstructor> & Record<string, string> =
+  new Proxy(Object(), {
+    get: (target, prop) => {
+      if (typeof prop === "symbol") {
+        return target[prop];
+      }
+
+      const envValue = denoEnvGet(prop);
+
+      if (envValue) {
+        return envValue;
+      }
+
+      if (OBJECT_PROTO_PROP_NAMES.includes(prop)) {
+        return target[prop];
+      }
+
+      return envValue;
+    },
+    ownKeys: () => Reflect.ownKeys(Deno.env.toObject()),
+    getOwnPropertyDescriptor: (_target, name) => {
+      const value = denoEnvGet(String(name));
+      if (value) {
+        return {
+          enumerable: true,
+          configurable: true,
+          value,
+        };
+      }
+    },
+    set(_target, prop, value) {
+      Deno.env.set(String(prop), String(value));
+      return true; // success
+    },
+    has: (_target, prop) => typeof denoEnvGet(String(prop)) === "string",
+  });
+
+/** https://nodejs.org/api/process.html#process_process_pid */
+export const pid = Deno.pid;
+
+/** https://nodejs.org/api/process.html#process_process_platform */
+export const platform = isWindows ? "win32" : Deno.build.os;
+
+/**
+ * https://nodejs.org/api/process.html#process_process_version
+ *
+ * This value is hard coded to latest stable release of Node, as
+ * some packages are checking it for compatibility. Previously
+ * it pointed to Deno version, but that led to incompability
+ * with some packages.
+ */
+export const version = "v18.12.1";
+
+/**
+ * https://nodejs.org/api/process.html#process_process_versions
+ *
+ * This value is hard coded to latest stable release of Node, as
+ * some packages are checking it for compatibility. Previously
+ * it contained only output of `Deno.version`, but that led to incompability
+ * with some packages. Value of `v8` field is still taken from `Deno.version`.
+ */
+export const versions = {
+  node: "18.12.1",
+  uv: "1.43.0",
+  zlib: "1.2.11",
+  brotli: "1.0.9",
+  ares: "1.18.1",
+  modules: "108",
+  nghttp2: "1.47.0",
+  napi: "8",
+  llhttp: "6.0.10",
+  openssl: "3.0.7+quic",
+  cldr: "41.0",
+  icu: "71.1",
+  tz: "2022b",
+  unicode: "14.0",
+  ngtcp2: "0.8.1",
+  nghttp3: "0.7.0",
+  ...Deno.version,
+};

package/src/templates/vendor/deno.land/std@0.175.0/node/_process/stdio.mjs

@@ -0,0 +1,7 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
+
+// Lazily initializes the actual stdio objects.
+// This trick is necessary for avoiding circular dependencies between
+// stream and process modules.
+export const stdio = {};

package/src/templates/vendor/deno.land/std@0.175.0/node/_process/streams.mjs

@@ -0,0 +1,146 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
+
+import { Buffer } from "../buffer.ts";
+import {
+  clearLine,
+  clearScreenDown,
+  cursorTo,
+  moveCursor,
+} from "../internal/readline/callbacks.mjs";
+import { Readable, Writable } from "../stream.ts";
+import { stdio } from "./stdio.mjs";
+
+// https://github.com/nodejs/node/blob/00738314828074243c9a52a228ab4c68b04259ef/lib/internal/bootstrap/switches/is_main_thread.js#L41
+function createWritableStdioStream(writer, name) {
+  const stream = new Writable({
+    write(buf, enc, cb) {
+      if (!writer) {
+        this.destroy(
+          new Error(`Deno.${name} is not available in this environment`),
+        );
+        return;
+      }
+      writer.writeSync(buf instanceof Uint8Array ? buf : Buffer.from(buf, enc));
+      cb();
+    },
+    destroy(err, cb) {
+      cb(err);
+      this._undestroy();
+      if (!this._writableState.emitClose) {
+        nextTick(() => this.emit("close"));
+      }
+    },
+  });
+  stream.fd = writer?.rid ?? -1;
+  stream.destroySoon = stream.destroy;
+  stream._isStdio = true;
+  stream.once("close", () => writer?.close());
+  Object.defineProperties(stream, {
+    columns: {
+      enumerable: true,
+      configurable: true,
+      get: () =>
+        Deno.isatty?.(writer?.rid) ? Deno.consoleSize?.().columns : undefined,
+    },
+    rows: {
+      enumerable: true,
+      configurable: true,
+      get: () =>
+        Deno.isatty?.(writer?.rid) ? Deno.consoleSize?.().rows : undefined,
+    },
+    isTTY: {
+      enumerable: true,
+      configurable: true,
+      get: () => Deno.isatty?.(writer?.rid),
+    },
+    getWindowSize: {
+      enumerable: true,
+      configurable: true,
+      value: () =>
+        Deno.isatty?.(writer?.rid)
+          ? Object.values(Deno.consoleSize?.())
+          : undefined,
+    },
+  });
+
+  if (Deno.isatty?.(writer?.rid)) {
+    // These belong on tty.WriteStream(), but the TTY streams currently have
+    // following problems:
+    // 1. Using them here introduces a circular dependency.
+    // 2. Creating a net.Socket() from a fd is not currently supported.
+    stream.cursorTo = function (x, y, callback) {
+      return cursorTo(this, x, y, callback);
+    };
+
+    stream.moveCursor = function (dx, dy, callback) {
+      return moveCursor(this, dx, dy, callback);
+    };
+
+    stream.clearLine = function (dir, callback) {
+      return clearLine(this, dir, callback);
+    };
+
+    stream.clearScreenDown = function (callback) {
+      return clearScreenDown(this, callback);
+    };
+  }
+
+  return stream;
+}
+
+/** https://nodejs.org/api/process.html#process_process_stderr */
+export const stderr = stdio.stderr = createWritableStdioStream(
+  Deno.stderr,
+  "stderr",
+);
+
+/** https://nodejs.org/api/process.html#process_process_stdout */
+export const stdout = stdio.stdout = createWritableStdioStream(
+  Deno.stdout,
+  "stdout",
+);
+
+/** https://nodejs.org/api/process.html#process_process_stdin */
+export const stdin = stdio.stdin = new Readable({
+  highWaterMark: 0,
+  emitClose: false,
+  read(size) {
+    const p = Buffer.alloc(size || 16 * 1024);
+
+    if (!Deno.stdin) {
+      this.destroy(
+        new Error("Deno.stdin is not available in this environment"),
+      );
+      return;
+    }
+
+    Deno.stdin.read(p).then((length) => {
+      this.push(length === null ? null : p.slice(0, length));
+    }, (error) => {
+      this.destroy(error);
+    });
+  },
+});
+stdin.on("close", () => Deno.stdin?.close());
+stdin.fd = Deno.stdin?.rid ?? -1;
+Object.defineProperty(stdin, "isTTY", {
+  enumerable: true,
+  configurable: true,
+  get() {
+    return Deno.isatty?.(Deno.stdin.rid);
+  },
+});
+stdin._isRawMode = false;
+stdin.setRawMode = (enable) => {
+  Deno.stdin?.setRaw?.(enable);
+  stdin._isRawMode = enable;
+  return stdin;
+};
+Object.defineProperty(stdin, "isRaw", {
+  enumerable: true,
+  configurable: true,
+  get() {
+    return stdin._isRawMode;
+  },
+});