@netlify/plugin-nextjs 4.40.0 → 4.40.2

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

@@ -0,0 +1,129 @@
+// 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.
+
+// These are simplified versions of the "real" errors in Node.
+
+import { nextTick } from "../_next_tick.ts";
+
+class NodeFalsyValueRejectionError extends Error {
+  public reason: unknown;
+  public code = "ERR_FALSY_VALUE_REJECTION";
+  constructor(reason: unknown) {
+    super("Promise was rejected with falsy value");
+    this.reason = reason;
+  }
+}
+class NodeInvalidArgTypeError extends TypeError {
+  public code = "ERR_INVALID_ARG_TYPE";
+  constructor(argumentName: string) {
+    super(`The ${argumentName} argument must be of type function.`);
+  }
+}
+
+type Callback<ResultT> =
+  | ((err: Error) => void)
+  | ((err: null, result: ResultT) => void);
+
+function callbackify<ResultT>(
+  fn: () => PromiseLike<ResultT>,
+): (callback: Callback<ResultT>) => void;
+function callbackify<ArgT, ResultT>(
+  fn: (arg: ArgT) => PromiseLike<ResultT>,
+): (arg: ArgT, callback: Callback<ResultT>) => void;
+function callbackify<Arg1T, Arg2T, ResultT>(
+  fn: (arg1: Arg1T, arg2: Arg2T) => PromiseLike<ResultT>,
+): (arg1: Arg1T, arg2: Arg2T, callback: Callback<ResultT>) => void;
+function callbackify<Arg1T, Arg2T, Arg3T, ResultT>(
+  fn: (arg1: Arg1T, arg2: Arg2T, arg3: Arg3T) => PromiseLike<ResultT>,
+): (arg1: Arg1T, arg2: Arg2T, arg3: Arg3T, callback: Callback<ResultT>) => void;
+function callbackify<Arg1T, Arg2T, Arg3T, Arg4T, ResultT>(
+  fn: (
+    arg1: Arg1T,
+    arg2: Arg2T,
+    arg3: Arg3T,
+    arg4: Arg4T,
+  ) => PromiseLike<ResultT>,
+): (
+  arg1: Arg1T,
+  arg2: Arg2T,
+  arg3: Arg3T,
+  arg4: Arg4T,
+  callback: Callback<ResultT>,
+) => void;
+function callbackify<Arg1T, Arg2T, Arg3T, Arg4T, Arg5T, ResultT>(
+  fn: (
+    arg1: Arg1T,
+    arg2: Arg2T,
+    arg3: Arg3T,
+    arg4: Arg4T,
+    arg5: Arg5T,
+  ) => PromiseLike<ResultT>,
+): (
+  arg1: Arg1T,
+  arg2: Arg2T,
+  arg3: Arg3T,
+  arg4: Arg4T,
+  arg5: Arg5T,
+  callback: Callback<ResultT>,
+) => void;
+
+function callbackify<ResultT>(
+  original: (...args: unknown[]) => PromiseLike<ResultT>,
+): (...args: unknown[]) => void {
+  if (typeof original !== "function") {
+    throw new NodeInvalidArgTypeError('"original"');
+  }
+
+  const callbackified = function (this: unknown, ...args: unknown[]) {
+    const maybeCb = args.pop();
+    if (typeof maybeCb !== "function") {
+      throw new NodeInvalidArgTypeError("last");
+    }
+    const cb = (...args: unknown[]) => {
+      maybeCb.apply(this, args);
+    };
+    original.apply(this, args).then(
+      (ret: unknown) => {
+        nextTick(cb.bind(this, null, ret));
+      },
+      (rej: unknown) => {
+        rej = rej || new NodeFalsyValueRejectionError(rej);
+        nextTick(cb.bind(this, rej));
+      },
+    );
+  };
+
+  const descriptors = Object.getOwnPropertyDescriptors(original);
+  // It is possible to manipulate a functions `length` or `name` property. This
+  // guards against the manipulation.
+  if (typeof descriptors.length.value === "number") {
+    descriptors.length.value++;
+  }
+  if (typeof descriptors.name.value === "string") {
+    descriptors.name.value += "Callbackified";
+  }
+  Object.defineProperties(callbackified, descriptors);
+  return callbackified;
+}
+
+export { callbackify };

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

@@ -0,0 +1,206 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import { errorMap } from "./internal_binding/uv.ts";
+import { codes } from "./internal/error_codes.ts";
+
+export type BinaryEncodings = "binary";
+
+export type TextEncodings =
+  | "ascii"
+  | "utf8"
+  | "utf-8"
+  | "utf16le"
+  | "ucs2"
+  | "ucs-2"
+  | "base64"
+  | "latin1"
+  | "hex";
+
+export type Encodings = BinaryEncodings | TextEncodings;
+
+export function notImplemented(msg: string): never {
+  const message = msg ? `Not implemented: ${msg}` : "Not implemented";
+  throw new Error(message);
+}
+
+export function warnNotImplemented(msg?: string) {
+  const message = msg
+    ? `Warning: Not implemented: ${msg}`
+    : "Warning: Not implemented";
+  console.warn(message);
+}
+
+export type _TextDecoder = typeof TextDecoder.prototype;
+export const _TextDecoder = TextDecoder;
+
+export type _TextEncoder = typeof TextEncoder.prototype;
+export const _TextEncoder = TextEncoder;
+
+// API helpers
+
+export type MaybeNull<T> = T | null;
+export type MaybeDefined<T> = T | undefined;
+export type MaybeEmpty<T> = T | null | undefined;
+
+export function intoCallbackAPI<T>(
+  // deno-lint-ignore no-explicit-any
+  func: (...args: any[]) => Promise<T>,
+  cb: MaybeEmpty<(err: MaybeNull<Error>, value?: MaybeEmpty<T>) => void>,
+  // deno-lint-ignore no-explicit-any
+  ...args: any[]
+) {
+  func(...args).then(
+    (value) => cb && cb(null, value),
+    (err) => cb && cb(err),
+  );
+}
+
+export function intoCallbackAPIWithIntercept<T1, T2>(
+  // deno-lint-ignore no-explicit-any
+  func: (...args: any[]) => Promise<T1>,
+  interceptor: (v: T1) => T2,
+  cb: MaybeEmpty<(err: MaybeNull<Error>, value?: MaybeEmpty<T2>) => void>,
+  // deno-lint-ignore no-explicit-any
+  ...args: any[]
+) {
+  func(...args).then(
+    (value) => cb && cb(null, interceptor(value)),
+    (err) => cb && cb(err),
+  );
+}
+
+export function spliceOne(list: string[], index: number) {
+  for (; index + 1 < list.length; index++) list[index] = list[index + 1];
+  list.pop();
+}
+
+// Taken from: https://github.com/nodejs/node/blob/ba684805b6c0eded76e5cd89ee00328ac7a59365/lib/internal/util.js#L125
+// Return undefined if there is no match.
+// Move the "slow cases" to a separate function to make sure this function gets
+// inlined properly. That prioritizes the common case.
+export function normalizeEncoding(
+  enc: string | null,
+): TextEncodings | undefined {
+  if (enc == null || enc === "utf8" || enc === "utf-8") return "utf8";
+  return slowCases(enc);
+}
+
+// https://github.com/nodejs/node/blob/ba684805b6c0eded76e5cd89ee00328ac7a59365/lib/internal/util.js#L130
+function slowCases(enc: string): TextEncodings | undefined {
+  switch (enc.length) {
+    case 4:
+      if (enc === "UTF8") return "utf8";
+      if (enc === "ucs2" || enc === "UCS2") return "utf16le";
+      enc = `${enc}`.toLowerCase();
+      if (enc === "utf8") return "utf8";
+      if (enc === "ucs2") return "utf16le";
+      break;
+    case 3:
+      if (enc === "hex" || enc === "HEX" || `${enc}`.toLowerCase() === "hex") {
+        return "hex";
+      }
+      break;
+    case 5:
+      if (enc === "ascii") return "ascii";
+      if (enc === "ucs-2") return "utf16le";
+      if (enc === "UTF-8") return "utf8";
+      if (enc === "ASCII") return "ascii";
+      if (enc === "UCS-2") return "utf16le";
+      enc = `${enc}`.toLowerCase();
+      if (enc === "utf-8") return "utf8";
+      if (enc === "ascii") return "ascii";
+      if (enc === "ucs-2") return "utf16le";
+      break;
+    case 6:
+      if (enc === "base64") return "base64";
+      if (enc === "latin1" || enc === "binary") return "latin1";
+      if (enc === "BASE64") return "base64";
+      if (enc === "LATIN1" || enc === "BINARY") return "latin1";
+      enc = `${enc}`.toLowerCase();
+      if (enc === "base64") return "base64";
+      if (enc === "latin1" || enc === "binary") return "latin1";
+      break;
+    case 7:
+      if (
+        enc === "utf16le" ||
+        enc === "UTF16LE" ||
+        `${enc}`.toLowerCase() === "utf16le"
+      ) {
+        return "utf16le";
+      }
+      break;
+    case 8:
+      if (
+        enc === "utf-16le" ||
+        enc === "UTF-16LE" ||
+        `${enc}`.toLowerCase() === "utf-16le"
+      ) {
+        return "utf16le";
+      }
+      break;
+    default:
+      if (enc === "") return "utf8";
+  }
+}
+
+export function validateIntegerRange(
+  value: number,
+  name: string,
+  min = -2147483648,
+  max = 2147483647,
+) {
+  // The defaults for min and max correspond to the limits of 32-bit integers.
+  if (!Number.isInteger(value)) {
+    throw new Error(`${name} must be 'an integer' but was ${value}`);
+  }
+
+  if (value < min || value > max) {
+    throw new Error(
+      `${name} must be >= ${min} && <= ${max}. Value was ${value}`,
+    );
+  }
+}
+
+type OptionalSpread<T> = T extends undefined ? []
+  : [T];
+
+export function once<T = undefined>(
+  callback: (...args: OptionalSpread<T>) => void,
+) {
+  let called = false;
+  return function (this: unknown, ...args: OptionalSpread<T>) {
+    if (called) return;
+    called = true;
+    callback.apply(this, args);
+  };
+}
+
+export function makeMethodsEnumerable(klass: { new (): unknown }) {
+  const proto = klass.prototype;
+  for (const key of Object.getOwnPropertyNames(proto)) {
+    const value = proto[key];
+    if (typeof value === "function") {
+      const desc = Reflect.getOwnPropertyDescriptor(proto, key);
+      if (desc) {
+        desc.enumerable = true;
+        Object.defineProperty(proto, key, desc);
+      }
+    }
+  }
+}
+
+const NumberIsSafeInteger = Number.isSafeInteger;
+
+/**
+ * Returns a system error name from an error code number.
+ * @param code error code number
+ */
+export function getSystemErrorName(code: number): string | undefined {
+  if (typeof code !== "number") {
+    throw new codes.ERR_INVALID_ARG_TYPE("err", "number", code);
+  }
+  if (code >= 0 || !NumberIsSafeInteger(code)) {
+    throw new codes.ERR_OUT_OF_RANGE("err", "a negative integer", code);
+  }
+  return errorMap.get(code)?.[0];
+}