@netlify/plugin-nextjs 4.40.0 → 4.40.2

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

@@ -0,0 +1,229 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+// This module ports:
+// - https://github.com/libuv/libuv/blob/master/src/win/error.c
+
+import * as winErrors from "./_winerror.ts";
+
+export function uvTranslateSysError(sysErrno: number): string {
+  switch (sysErrno) {
+    case winErrors.ERROR_ACCESS_DENIED:
+      return "EACCES";
+    case winErrors.ERROR_NOACCESS:
+      return "EACCES";
+    case winErrors.WSAEACCES:
+      return "EACCES";
+    // case winErrors.ERROR_ELEVATION_REQUIRED:          return "EACCES";
+    case winErrors.ERROR_CANT_ACCESS_FILE:
+      return "EACCES";
+    case winErrors.ERROR_ADDRESS_ALREADY_ASSOCIATED:
+      return "EADDRINUSE";
+    case winErrors.WSAEADDRINUSE:
+      return "EADDRINUSE";
+    case winErrors.WSAEADDRNOTAVAIL:
+      return "EADDRNOTAVAIL";
+    case winErrors.WSAEAFNOSUPPORT:
+      return "EAFNOSUPPORT";
+    case winErrors.WSAEWOULDBLOCK:
+      return "EAGAIN";
+    case winErrors.WSAEALREADY:
+      return "EALREADY";
+    case winErrors.ERROR_INVALID_FLAGS:
+      return "EBADF";
+    case winErrors.ERROR_INVALID_HANDLE:
+      return "EBADF";
+    case winErrors.ERROR_LOCK_VIOLATION:
+      return "EBUSY";
+    case winErrors.ERROR_PIPE_BUSY:
+      return "EBUSY";
+    case winErrors.ERROR_SHARING_VIOLATION:
+      return "EBUSY";
+    case winErrors.ERROR_OPERATION_ABORTED:
+      return "ECANCELED";
+    case winErrors.WSAEINTR:
+      return "ECANCELED";
+    case winErrors.ERROR_NO_UNICODE_TRANSLATION:
+      return "ECHARSET";
+    case winErrors.ERROR_CONNECTION_ABORTED:
+      return "ECONNABORTED";
+    case winErrors.WSAECONNABORTED:
+      return "ECONNABORTED";
+    case winErrors.ERROR_CONNECTION_REFUSED:
+      return "ECONNREFUSED";
+    case winErrors.WSAECONNREFUSED:
+      return "ECONNREFUSED";
+    case winErrors.ERROR_NETNAME_DELETED:
+      return "ECONNRESET";
+    case winErrors.WSAECONNRESET:
+      return "ECONNRESET";
+    case winErrors.ERROR_ALREADY_EXISTS:
+      return "EEXIST";
+    case winErrors.ERROR_FILE_EXISTS:
+      return "EEXIST";
+    case winErrors.ERROR_BUFFER_OVERFLOW:
+      return "EFAULT";
+    case winErrors.WSAEFAULT:
+      return "EFAULT";
+    case winErrors.ERROR_HOST_UNREACHABLE:
+      return "EHOSTUNREACH";
+    case winErrors.WSAEHOSTUNREACH:
+      return "EHOSTUNREACH";
+    case winErrors.ERROR_INSUFFICIENT_BUFFER:
+      return "EINVAL";
+    case winErrors.ERROR_INVALID_DATA:
+      return "EINVAL";
+    case winErrors.ERROR_INVALID_NAME:
+      return "EINVAL";
+    case winErrors.ERROR_INVALID_PARAMETER:
+      return "EINVAL";
+    // case winErrors.ERROR_SYMLINK_NOT_SUPPORTED:       return "EINVAL";
+    case winErrors.WSAEINVAL:
+      return "EINVAL";
+    case winErrors.WSAEPFNOSUPPORT:
+      return "EINVAL";
+    case winErrors.ERROR_BEGINNING_OF_MEDIA:
+      return "EIO";
+    case winErrors.ERROR_BUS_RESET:
+      return "EIO";
+    case winErrors.ERROR_CRC:
+      return "EIO";
+    case winErrors.ERROR_DEVICE_DOOR_OPEN:
+      return "EIO";
+    case winErrors.ERROR_DEVICE_REQUIRES_CLEANING:
+      return "EIO";
+    case winErrors.ERROR_DISK_CORRUPT:
+      return "EIO";
+    case winErrors.ERROR_EOM_OVERFLOW:
+      return "EIO";
+    case winErrors.ERROR_FILEMARK_DETECTED:
+      return "EIO";
+    case winErrors.ERROR_GEN_FAILURE:
+      return "EIO";
+    case winErrors.ERROR_INVALID_BLOCK_LENGTH:
+      return "EIO";
+    case winErrors.ERROR_IO_DEVICE:
+      return "EIO";
+    case winErrors.ERROR_NO_DATA_DETECTED:
+      return "EIO";
+    case winErrors.ERROR_NO_SIGNAL_SENT:
+      return "EIO";
+    case winErrors.ERROR_OPEN_FAILED:
+      return "EIO";
+    case winErrors.ERROR_SETMARK_DETECTED:
+      return "EIO";
+    case winErrors.ERROR_SIGNAL_REFUSED:
+      return "EIO";
+    case winErrors.WSAEISCONN:
+      return "EISCONN";
+    case winErrors.ERROR_CANT_RESOLVE_FILENAME:
+      return "ELOOP";
+    case winErrors.ERROR_TOO_MANY_OPEN_FILES:
+      return "EMFILE";
+    case winErrors.WSAEMFILE:
+      return "EMFILE";
+    case winErrors.WSAEMSGSIZE:
+      return "EMSGSIZE";
+    case winErrors.ERROR_FILENAME_EXCED_RANGE:
+      return "ENAMETOOLONG";
+    case winErrors.ERROR_NETWORK_UNREACHABLE:
+      return "ENETUNREACH";
+    case winErrors.WSAENETUNREACH:
+      return "ENETUNREACH";
+    case winErrors.WSAENOBUFS:
+      return "ENOBUFS";
+    case winErrors.ERROR_BAD_PATHNAME:
+      return "ENOENT";
+    case winErrors.ERROR_DIRECTORY:
+      return "ENOTDIR";
+    case winErrors.ERROR_ENVVAR_NOT_FOUND:
+      return "ENOENT";
+    case winErrors.ERROR_FILE_NOT_FOUND:
+      return "ENOENT";
+    case winErrors.ERROR_INVALID_DRIVE:
+      return "ENOENT";
+    case winErrors.ERROR_INVALID_REPARSE_DATA:
+      return "ENOENT";
+    case winErrors.ERROR_MOD_NOT_FOUND:
+      return "ENOENT";
+    case winErrors.ERROR_PATH_NOT_FOUND:
+      return "ENOENT";
+    case winErrors.WSAHOST_NOT_FOUND:
+      return "ENOENT";
+    case winErrors.WSANO_DATA:
+      return "ENOENT";
+    case winErrors.ERROR_NOT_ENOUGH_MEMORY:
+      return "ENOMEM";
+    case winErrors.ERROR_OUTOFMEMORY:
+      return "ENOMEM";
+    case winErrors.ERROR_CANNOT_MAKE:
+      return "ENOSPC";
+    case winErrors.ERROR_DISK_FULL:
+      return "ENOSPC";
+    case winErrors.ERROR_EA_TABLE_FULL:
+      return "ENOSPC";
+    case winErrors.ERROR_END_OF_MEDIA:
+      return "ENOSPC";
+    case winErrors.ERROR_HANDLE_DISK_FULL:
+      return "ENOSPC";
+    case winErrors.ERROR_NOT_CONNECTED:
+      return "ENOTCONN";
+    case winErrors.WSAENOTCONN:
+      return "ENOTCONN";
+    case winErrors.ERROR_DIR_NOT_EMPTY:
+      return "ENOTEMPTY";
+    case winErrors.WSAENOTSOCK:
+      return "ENOTSOCK";
+    case winErrors.ERROR_NOT_SUPPORTED:
+      return "ENOTSUP";
+    case winErrors.ERROR_BROKEN_PIPE:
+      return "EOF";
+    case winErrors.ERROR_PRIVILEGE_NOT_HELD:
+      return "EPERM";
+    case winErrors.ERROR_BAD_PIPE:
+      return "EPIPE";
+    case winErrors.ERROR_NO_DATA:
+      return "EPIPE";
+    case winErrors.ERROR_PIPE_NOT_CONNECTED:
+      return "EPIPE";
+    case winErrors.WSAESHUTDOWN:
+      return "EPIPE";
+    case winErrors.WSAEPROTONOSUPPORT:
+      return "EPROTONOSUPPORT";
+    case winErrors.ERROR_WRITE_PROTECT:
+      return "EROFS";
+    case winErrors.ERROR_SEM_TIMEOUT:
+      return "ETIMEDOUT";
+    case winErrors.WSAETIMEDOUT:
+      return "ETIMEDOUT";
+    case winErrors.ERROR_NOT_SAME_DEVICE:
+      return "EXDEV";
+    case winErrors.ERROR_INVALID_FUNCTION:
+      return "EISDIR";
+    case winErrors.ERROR_META_EXPANSION_TOO_LONG:
+      return "E2BIG";
+    case winErrors.WSAESOCKTNOSUPPORT:
+      return "ESOCKTNOSUPPORT";
+    default:
+      return "UNKNOWN";
+  }
+}

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

@@ -0,0 +1,16 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/**
+ * @param n Number to act on.
+ * @return The number rounded up to the nearest power of 2.
+ */
+export function ceilPowOf2(n: number) {
+  const roundPowOf2 = 1 << (31 - Math.clz32(n));
+
+  return roundPowOf2 < n ? roundPowOf2 * 2 : roundPowOf2;
+}
+
+/** Initial backoff delay of 5ms following a temporary accept failure. */
+export const INITIAL_ACCEPT_BACKOFF_DELAY = 5;
+
+/** Max backoff delay of 1s following a temporary accept failure. */
+export const MAX_ACCEPT_BACKOFF_DELAY = 1000;

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

@@ -0,0 +1,18 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This file contains C++ node globals accesed in internal binding calls
+
+/**
+ * Adapted from
+ * https://github.com/nodejs/node/blob/3b72788afb7365e10ae1e97c71d1f60ee29f09f2/src/node.h#L728-L738
+ */
+export enum Encodings {
+  ASCII, // 0
+  UTF8, // 1
+  BASE64, // 2
+  UCS2, // 3
+  BINARY, // 4
+  HEX, // 5
+  BUFFER, // 6
+  BASE64URL, // 7
+  LATIN1 = 4, // 4 = BINARY
+}

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

@@ -0,0 +1,12 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { Buffer } from "../buffer.ts";
+import { timingSafeEqual as stdTimingSafeEqual } from "../../crypto/timing_safe_equal.ts";
+
+export const timingSafeEqual = (
+  a: Buffer | DataView | ArrayBuffer,
+  b: Buffer | DataView | ArrayBuffer,
+): boolean => {
+  if (a instanceof Buffer) a = new DataView(a.buffer);
+  if (a instanceof Buffer) b = new DataView(a.buffer);
+  return stdTimingSafeEqual(a, b);
+};

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

@@ -0,0 +1,86 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as base64 from "../../encoding/base64.ts";
+import * as base64url from "../../encoding/base64url.ts";
+
+export function asciiToBytes(str: string) {
+  const byteArray = [];
+  for (let i = 0; i < str.length; ++i) {
+    byteArray.push(str.charCodeAt(i) & 255);
+  }
+  return new Uint8Array(byteArray);
+}
+
+export function base64ToBytes(str: string) {
+  str = base64clean(str);
+  str = str.replaceAll("-", "+").replaceAll("_", "/");
+  return base64.decode(str);
+}
+
+const INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+function base64clean(str: string) {
+  // Node takes equal signs as end of the Base64 encoding
+  str = str.split("=")[0];
+  // Node strips out invalid characters like \n and \t from the string, std/base64 does not
+  str = str.trim().replace(INVALID_BASE64_RE, "");
+  // Node converts strings with length < 2 to ''
+  if (str.length < 2) return "";
+  // Node allows for non-padded base64 strings (missing trailing ===), std/base64 does not
+  while (str.length % 4 !== 0) {
+    str = str + "=";
+  }
+  return str;
+}
+
+export function base64UrlToBytes(str: string) {
+  str = base64clean(str);
+  str = str.replaceAll("+", "-").replaceAll("/", "_");
+  return base64url.decode(str);
+}
+
+export function hexToBytes(str: string) {
+  const byteArray = new Uint8Array(Math.floor((str || "").length / 2));
+  let i;
+  for (i = 0; i < byteArray.length; i++) {
+    const a = Number.parseInt(str[i * 2], 16);
+    const b = Number.parseInt(str[i * 2 + 1], 16);
+    if (Number.isNaN(a) && Number.isNaN(b)) {
+      break;
+    }
+    byteArray[i] = (a << 4) | b;
+  }
+  return new Uint8Array(
+    i === byteArray.length ? byteArray : byteArray.slice(0, i),
+  );
+}
+
+export function utf16leToBytes(str: string, units: number) {
+  let c, hi, lo;
+  const byteArray = [];
+  for (let i = 0; i < str.length; ++i) {
+    if ((units -= 2) < 0) {
+      break;
+    }
+    c = str.charCodeAt(i);
+    hi = c >> 8;
+    lo = c % 256;
+    byteArray.push(lo);
+    byteArray.push(hi);
+  }
+  return new Uint8Array(byteArray);
+}
+
+export function bytesToAscii(bytes: Uint8Array) {
+  let ret = "";
+  for (let i = 0; i < bytes.length; ++i) {
+    ret += String.fromCharCode(bytes[i] & 127);
+  }
+  return ret;
+}
+
+export function bytesToUtf16le(bytes: Uint8Array) {
+  let res = "";
+  for (let i = 0; i < bytes.length - 1; i += 2) {
+    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+  }
+  return res;
+}