@netlify/plugin-nextjs 4.40.0 → 4.40.2

package/src/templates/vendor/deno.land/std@0.175.0/node/internal/util/types.ts

@@ -0,0 +1,113 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+//
+// Adapted from Node.js. Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+import * as bindingTypes from "../../internal_binding/types.ts";
+export { isCryptoKey, isKeyObject } from "../crypto/_keys.ts";
+
+// https://tc39.es/ecma262/#sec-get-%typedarray%.prototype-@@tostringtag
+const _getTypedArrayToStringTag = Object.getOwnPropertyDescriptor(
+  Object.getPrototypeOf(Uint8Array).prototype,
+  Symbol.toStringTag,
+)!.get!;
+
+export function isArrayBufferView(value: unknown): boolean {
+  return ArrayBuffer.isView(value);
+}
+
+export function isBigInt64Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "BigInt64Array";
+}
+
+export function isBigUint64Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "BigUint64Array";
+}
+
+export function isFloat32Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Float32Array";
+}
+
+export function isFloat64Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Float64Array";
+}
+
+export function isInt8Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Int8Array";
+}
+
+export function isInt16Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Int16Array";
+}
+
+export function isInt32Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Int32Array";
+}
+
+export function isTypedArray(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) !== undefined;
+}
+
+export function isUint8Array(value: unknown): value is Uint8Array {
+  return _getTypedArrayToStringTag.call(value) === "Uint8Array";
+}
+
+export function isUint8ClampedArray(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Uint8ClampedArray";
+}
+
+export function isUint16Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Uint16Array";
+}
+
+export function isUint32Array(value: unknown): boolean {
+  return _getTypedArrayToStringTag.call(value) === "Uint32Array";
+}
+
+export const {
+  // isExternal,
+  isDate,
+  isArgumentsObject,
+  isBigIntObject,
+  isBooleanObject,
+  isNumberObject,
+  isStringObject,
+  isSymbolObject,
+  isNativeError,
+  isRegExp,
+  isAsyncFunction,
+  isGeneratorFunction,
+  isGeneratorObject,
+  isPromise,
+  isMap,
+  isSet,
+  isMapIterator,
+  isSetIterator,
+  isWeakMap,
+  isWeakSet,
+  isArrayBuffer,
+  isDataView,
+  isSharedArrayBuffer,
+  isProxy,
+  isModuleNamespaceObject,
+  isAnyArrayBuffer,
+  isBoxedPrimitive,
+} = bindingTypes;

package/src/templates/vendor/deno.land/std@0.175.0/node/internal/util.mjs

@@ -0,0 +1,143 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { validateFunction } from "./validators.mjs";
+import { normalizeEncoding, slowCases } from "./normalize_encoding.mjs";
+export { normalizeEncoding, slowCases };
+import { ObjectCreate, StringPrototypeToUpperCase } from "./primordials.mjs";
+import { ERR_UNKNOWN_SIGNAL } from "./errors.ts";
+import { os } from "../internal_binding/constants.ts";
+
+const { signals } = os;
+
+export const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+export const kEnumerableProperty = Object.create(null);
+kEnumerableProperty.enumerable = true;
+
+export const kEmptyObject = Object.freeze(Object.create(null));
+
+export function once(callback) {
+  let called = false;
+  return function (...args) {
+    if (called) return;
+    called = true;
+    Reflect.apply(callback, this, args);
+  };
+}
+
+export function createDeferredPromise() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  return { promise, resolve, reject };
+}
+
+// In addition to being accessible through util.promisify.custom,
+// this symbol is registered globally and can be accessed in any environment as
+// Symbol.for('nodejs.util.promisify.custom').
+const kCustomPromisifiedSymbol = Symbol.for("nodejs.util.promisify.custom");
+// This is an internal Node symbol used by functions returning multiple
+// arguments, e.g. ['bytesRead', 'buffer'] for fs.read().
+const kCustomPromisifyArgsSymbol = Symbol.for(
+  "nodejs.util.promisify.customArgs",
+);
+
+export const customPromisifyArgs = kCustomPromisifyArgsSymbol;
+
+export function promisify(
+  original,
+) {
+  validateFunction(original, "original");
+  if (original[kCustomPromisifiedSymbol]) {
+    const fn = original[kCustomPromisifiedSymbol];
+
+    validateFunction(fn, "util.promisify.custom");
+
+    return Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn,
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    });
+  }
+
+  // Names to create an object from in case the callback receives multiple
+  // arguments, e.g. ['bytesRead', 'buffer'] for fs.read.
+  const argumentNames = original[kCustomPromisifyArgsSymbol];
+  function fn(...args) {
+    return new Promise((resolve, reject) => {
+      args.push((err, ...values) => {
+        if (err) {
+          return reject(err);
+        }
+        if (argumentNames !== undefined && values.length > 1) {
+          const obj = {};
+          for (let i = 0; i < argumentNames.length; i++) {
+            obj[argumentNames[i]] = values[i];
+          }
+          resolve(obj);
+        } else {
+          resolve(values[0]);
+        }
+      });
+      Reflect.apply(original, this, args);
+    });
+  }
+
+  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+
+  Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+    value: fn,
+    enumerable: false,
+    writable: false,
+    configurable: true,
+  });
+  return Object.defineProperties(
+    fn,
+    Object.getOwnPropertyDescriptors(original),
+  );
+}
+
+let signalsToNamesMapping;
+function getSignalsToNamesMapping() {
+  if (signalsToNamesMapping !== undefined) {
+    return signalsToNamesMapping;
+  }
+
+  signalsToNamesMapping = ObjectCreate(null);
+  for (const key in signals) {
+    signalsToNamesMapping[signals[key]] = key;
+  }
+
+  return signalsToNamesMapping;
+}
+
+export function convertToValidSignal(signal) {
+  if (typeof signal === "number" && getSignalsToNamesMapping()[signal]) {
+    return signal;
+  }
+
+  if (typeof signal === "string") {
+    const signalName = signals[StringPrototypeToUpperCase(signal)];
+    if (signalName) return signalName;
+  }
+
+  throw new ERR_UNKNOWN_SIGNAL(signal);
+}
+
+promisify.custom = kCustomPromisifiedSymbol;
+
+export default {
+  convertToValidSignal,
+  createDeferredPromise,
+  customInspectSymbol,
+  customPromisifyArgs,
+  kEmptyObject,
+  kEnumerableProperty,
+  normalizeEncoding,
+  once,
+  promisify,
+  slowCases,
+};

package/src/templates/vendor/deno.land/std@0.175.0/node/internal/validators.mjs

@@ -0,0 +1,317 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+
+import { codes } from "./error_codes.ts";
+import { hideStackFrames } from "./hide_stack_frames.ts";
+import { isArrayBufferView } from "./util/types.ts";
+import { normalizeEncoding } from "./normalize_encoding.mjs";
+
+/**
+ * @param {number} value
+ * @returns {boolean}
+ */
+function isInt32(value) {
+  return value === (value | 0);
+}
+
+/**
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+function isUint32(value) {
+  return value === (value >>> 0);
+}
+
+const octalReg = /^[0-7]+$/;
+const modeDesc = "must be a 32-bit unsigned integer or an octal string";
+
+/**
+ * Parse and validate values that will be converted into mode_t (the S_*
+ * constants). Only valid numbers and octal strings are allowed. They could be
+ * converted to 32-bit unsigned integers or non-negative signed integers in the
+ * C++ land, but any value higher than 0o777 will result in platform-specific
+ * behaviors.
+ *
+ * @param {*} value Values to be validated
+ * @param {string} name Name of the argument
+ * @param {number} [def] If specified, will be returned for invalid values
+ * @returns {number}
+ */
+function parseFileMode(value, name, def) {
+  value ??= def;
+  if (typeof value === "string") {
+    if (!octalReg.test(value)) {
+      throw new codes.ERR_INVALID_ARG_VALUE(name, value, modeDesc);
+    }
+    value = Number.parseInt(value, 8);
+  }
+
+  validateInt32(value, name, 0, 2 ** 32 - 1);
+  return value;
+}
+
+const validateBuffer = hideStackFrames((buffer, name = "buffer") => {
+  if (!isArrayBufferView(buffer)) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      name,
+      ["Buffer", "TypedArray", "DataView"],
+      buffer,
+    );
+  }
+});
+
+const validateInteger = hideStackFrames(
+  (
+    value,
+    name,
+    min = Number.MIN_SAFE_INTEGER,
+    max = Number.MAX_SAFE_INTEGER,
+  ) => {
+    if (typeof value !== "number") {
+      throw new codes.ERR_INVALID_ARG_TYPE(name, "number", value);
+    }
+    if (!Number.isInteger(value)) {
+      throw new codes.ERR_OUT_OF_RANGE(name, "an integer", value);
+    }
+    if (value < min || value > max) {
+      throw new codes.ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+    }
+  },
+);
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ * @param {{
+ *   allowArray?: boolean,
+ *   allowFunction?: boolean,
+ *   nullable?: boolean
+ * }} [options]
+ */
+const validateObject = hideStackFrames((value, name, options) => {
+  const useDefaultOptions = options == null;
+  const allowArray = useDefaultOptions ? false : options.allowArray;
+  const allowFunction = useDefaultOptions ? false : options.allowFunction;
+  const nullable = useDefaultOptions ? false : options.nullable;
+  if (
+    (!nullable && value === null) ||
+    (!allowArray && Array.isArray(value)) ||
+    (typeof value !== "object" && (
+      !allowFunction || typeof value !== "function"
+    ))
+  ) {
+    throw new codes.ERR_INVALID_ARG_TYPE(name, "Object", value);
+  }
+});
+
+const validateInt32 = hideStackFrames(
+  (value, name, min = -2147483648, max = 2147483647) => {
+    // The defaults for min and max correspond to the limits of 32-bit integers.
+    if (!isInt32(value)) {
+      if (typeof value !== "number") {
+        throw new codes.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+
+      if (!Number.isInteger(value)) {
+        throw new codes.ERR_OUT_OF_RANGE(name, "an integer", value);
+      }
+
+      throw new codes.ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+    }
+
+    if (value < min || value > max) {
+      throw new codes.ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
+    }
+  },
+);
+
+const validateUint32 = hideStackFrames(
+  (value, name, positive) => {
+    if (!isUint32(value)) {
+      if (typeof value !== "number") {
+        throw new codes.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+      if (!Number.isInteger(value)) {
+        throw new codes.ERR_OUT_OF_RANGE(name, "an integer", value);
+      }
+      const min = positive ? 1 : 0;
+      // 2 ** 32 === 4294967296
+      throw new codes.ERR_OUT_OF_RANGE(
+        name,
+        `>= ${min} && < 4294967296`,
+        value,
+      );
+    }
+    if (positive && value === 0) {
+      throw new codes.ERR_OUT_OF_RANGE(name, ">= 1 && < 4294967296", value);
+    }
+  },
+);
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ */
+function validateString(value, name) {
+  if (typeof value !== "string") {
+    throw new codes.ERR_INVALID_ARG_TYPE(name, "string", value);
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ */
+function validateNumber(value, name) {
+  if (typeof value !== "number") {
+    throw new codes.ERR_INVALID_ARG_TYPE(name, "number", value);
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ */
+function validateBoolean(value, name) {
+  if (typeof value !== "boolean") {
+    throw new codes.ERR_INVALID_ARG_TYPE(name, "boolean", value);
+  }
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ * @param {unknown[]} oneOf
+ */
+const validateOneOf = hideStackFrames(
+  (value, name, oneOf) => {
+    if (!Array.prototype.includes.call(oneOf, value)) {
+      const allowed = Array.prototype.join.call(
+        Array.prototype.map.call(
+          oneOf,
+          (v) => (typeof v === "string" ? `'${v}'` : String(v)),
+        ),
+        ", ",
+      );
+      const reason = "must be one of: " + allowed;
+
+      throw new codes.ERR_INVALID_ARG_VALUE(name, value, reason);
+    }
+  },
+);
+
+export function validateEncoding(data, encoding) {
+  const normalizedEncoding = normalizeEncoding(encoding);
+  const length = data.length;
+
+  if (normalizedEncoding === "hex" && length % 2 !== 0) {
+    throw new codes.ERR_INVALID_ARG_VALUE(
+      "encoding",
+      encoding,
+      `is invalid for data of length ${length}`,
+    );
+  }
+}
+
+// Check that the port number is not NaN when coerced to a number,
+// is an integer and that it falls within the legal range of port numbers.
+/**
+ * @param {string} name
+ * @returns {number}
+ */
+function validatePort(port, name = "Port", allowZero = true) {
+  if (
+    (typeof port !== "number" && typeof port !== "string") ||
+    (typeof port === "string" &&
+      String.prototype.trim.call(port).length === 0) ||
+    +port !== (+port >>> 0) ||
+    port > 0xFFFF ||
+    (port === 0 && !allowZero)
+  ) {
+    throw new codes.ERR_SOCKET_BAD_PORT(name, port, allowZero);
+  }
+
+  return port;
+}
+
+/**
+ * @param {unknown} signal
+ * @param {string} name
+ */
+const validateAbortSignal = hideStackFrames(
+  (signal, name) => {
+    if (
+      signal !== undefined &&
+      (signal === null ||
+        typeof signal !== "object" ||
+        !("aborted" in signal))
+    ) {
+      throw new codes.ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
+    }
+  },
+);
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ */
+const validateFunction = hideStackFrames(
+  (value, name) => {
+    if (typeof value !== "function") {
+      throw new codes.ERR_INVALID_ARG_TYPE(name, "Function", value);
+    }
+  },
+);
+
+/**
+ * @param {unknown} value
+ * @param {string} name
+ */
+const validateArray = hideStackFrames(
+  (value, name, minLength = 0) => {
+    if (!Array.isArray(value)) {
+      throw new codes.ERR_INVALID_ARG_TYPE(name, "Array", value);
+    }
+    if (value.length < minLength) {
+      const reason = `must be longer than ${minLength}`;
+      throw new codes.ERR_INVALID_ARG_VALUE(name, value, reason);
+    }
+  },
+);
+
+export default {
+  isInt32,
+  isUint32,
+  parseFileMode,
+  validateAbortSignal,
+  validateArray,
+  validateBoolean,
+  validateBuffer,
+  validateFunction,
+  validateInt32,
+  validateInteger,
+  validateNumber,
+  validateObject,
+  validateOneOf,
+  validatePort,
+  validateString,
+  validateUint32,
+};
+export {
+  isInt32,
+  isUint32,
+  parseFileMode,
+  validateAbortSignal,
+  validateArray,
+  validateBoolean,
+  validateBuffer,
+  validateFunction,
+  validateInt32,
+  validateInteger,
+  validateNumber,
+  validateObject,
+  validateOneOf,
+  validatePort,
+  validateString,
+  validateUint32,
+};