@netlify/plugin-nextjs 4.40.1 → 4.40.2

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

@@ -0,0 +1,37 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// compose, destroy and isDisturbed are experimental APIs without
+// typings. They can be exposed once they are released as stable in Node
+
+// @deno-types="./_stream.d.ts"
+import {
+  _isUint8Array,
+  _uint8ArrayToBuffer,
+  addAbortSignal,
+  // compose,
+  // destroy,
+  Duplex,
+  finished,
+  // isDisturbed,
+  PassThrough,
+  pipeline,
+  Readable,
+  Stream,
+  Transform,
+  Writable,
+} from "./_stream.mjs";
+
+export {
+  _isUint8Array,
+  _uint8ArrayToBuffer,
+  addAbortSignal,
+  Duplex,
+  finished,
+  PassThrough,
+  pipeline,
+  Readable,
+  Stream,
+  Transform,
+  Writable,
+};
+
+export default Stream;

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

@@ -0,0 +1,337 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// 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 { Buffer } from "./buffer.ts";
+import { normalizeEncoding as castEncoding, notImplemented } from "./_utils.ts";
+
+enum NotImplemented {
+  "ascii",
+  "latin1",
+  "utf16le",
+}
+
+function normalizeEncoding(enc?: string): string {
+  const encoding = castEncoding(enc ?? null);
+  if (encoding && encoding in NotImplemented) notImplemented(encoding);
+  if (!encoding && typeof enc === "string" && enc.toLowerCase() !== "raw") {
+    throw new Error(`Unknown encoding: ${enc}`);
+  }
+  return String(encoding);
+}
+
+/**
+ * Check is `ArrayBuffer` and not `TypedArray`. Typescript allowed `TypedArray` to be passed as `ArrayBuffer` and does not do a deep check
+ */
+
+function isBufferType(buf: Buffer) {
+  return buf instanceof ArrayBuffer && buf.BYTES_PER_ELEMENT;
+}
+
+/*
+ * Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+ * continuation byte. If an invalid byte is detected, -2 is returned.
+ */
+function utf8CheckByte(byte: number): number {
+  if (byte <= 0x7f) return 0;
+  else if (byte >> 5 === 0x06) return 2;
+  else if (byte >> 4 === 0x0e) return 3;
+  else if (byte >> 3 === 0x1e) return 4;
+  return byte >> 6 === 0x02 ? -1 : -2;
+}
+
+/*
+ * Checks at most 3 bytes at the end of a Buffer in order to detect an
+ * incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+ * needed to complete the UTF-8 character (if applicable) are returned.
+ */
+function utf8CheckIncomplete(
+  self: StringDecoderBase,
+  buf: Buffer,
+  i: number,
+): number {
+  let j = buf.length - 1;
+  if (j < i) return 0;
+  let nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 1;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) self.lastNeed = nb - 2;
+    return nb;
+  }
+  if (--j < i || nb === -2) return 0;
+  nb = utf8CheckByte(buf[j]);
+  if (nb >= 0) {
+    if (nb > 0) {
+      if (nb === 2) nb = 0;
+      else self.lastNeed = nb - 3;
+    }
+    return nb;
+  }
+  return 0;
+}
+
+/*
+ * Validates as many continuation bytes for a multi-byte UTF-8 character as
+ * needed or are available. If we see a non-continuation byte where we expect
+ * one, we "replace" the validated continuation bytes we've seen so far with
+ * a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+ * behavior. The continuation byte check is included three times in the case
+ * where all of the continuation bytes for a character exist in the same buffer.
+ * It is also done this way as a slight performance increase instead of using a
+ * loop.
+ */
+function utf8CheckExtraBytes(
+  self: StringDecoderBase,
+  buf: Buffer,
+): string | undefined {
+  if ((buf[0] & 0xc0) !== 0x80) {
+    self.lastNeed = 0;
+    return "\ufffd";
+  }
+  if (self.lastNeed > 1 && buf.length > 1) {
+    if ((buf[1] & 0xc0) !== 0x80) {
+      self.lastNeed = 1;
+      return "\ufffd";
+    }
+    if (self.lastNeed > 2 && buf.length > 2) {
+      if ((buf[2] & 0xc0) !== 0x80) {
+        self.lastNeed = 2;
+        return "\ufffd";
+      }
+    }
+  }
+}
+
+/*
+ * Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+ */
+function utf8FillLastComplete(
+  this: StringDecoderBase,
+  buf: Buffer,
+): string | undefined {
+  const p = this.lastTotal - this.lastNeed;
+  const r = utf8CheckExtraBytes(this, buf);
+  if (r !== undefined) return r;
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, p, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, p, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+
+/*
+ * Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+ */
+function utf8FillLastIncomplete(
+  this: StringDecoderBase,
+  buf: Buffer,
+): string | undefined {
+  if (this.lastNeed <= buf.length) {
+    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  }
+  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+  this.lastNeed -= buf.length;
+}
+
+/*
+ * Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+ * partial character, the character's bytes are buffered until the required
+ * number of bytes are available.
+ */
+function utf8Text(this: StringDecoderBase, buf: Buffer, i: number): string {
+  const total = utf8CheckIncomplete(this, buf, i);
+  if (!this.lastNeed) return buf.toString("utf8", i);
+  this.lastTotal = total;
+  const end = buf.length - (total - this.lastNeed);
+  buf.copy(this.lastChar, 0, end);
+  return buf.toString("utf8", i, end);
+}
+
+/*
+ * For UTF-8, a replacement character is added when ending on a partial
+ * character.
+ */
+function utf8End(this: Utf8Decoder, buf?: Buffer): string {
+  const r = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed) return r + "\ufffd";
+  return r;
+}
+
+function utf8Write(
+  this: Utf8Decoder | Base64Decoder,
+  buf: Buffer | string,
+): string {
+  if (typeof buf === "string") {
+    return buf;
+  }
+  if (buf.length === 0) return "";
+  let r;
+  let i;
+  // Because `TypedArray` is recognized as `ArrayBuffer` but in the reality, there are some fundamental difference. We would need to cast it properly
+  const normalizedBuffer: Buffer = isBufferType(buf) ? buf : Buffer.from(buf);
+  if (this.lastNeed) {
+    r = this.fillLast(normalizedBuffer);
+    if (r === undefined) return "";
+    i = this.lastNeed;
+    this.lastNeed = 0;
+  } else {
+    i = 0;
+  }
+  if (i < buf.length) {
+    return r
+      ? r + this.text(normalizedBuffer, i)
+      : this.text(normalizedBuffer, i);
+  }
+  return r || "";
+}
+
+function base64Text(this: StringDecoderBase, buf: Buffer, i: number): string {
+  const n = (buf.length - i) % 3;
+  if (n === 0) return buf.toString("base64", i);
+  this.lastNeed = 3 - n;
+  this.lastTotal = 3;
+  if (n === 1) {
+    this.lastChar[0] = buf[buf.length - 1];
+  } else {
+    this.lastChar[0] = buf[buf.length - 2];
+    this.lastChar[1] = buf[buf.length - 1];
+  }
+  return buf.toString("base64", i, buf.length - n);
+}
+
+function base64End(this: Base64Decoder, buf?: Buffer): string {
+  const r = buf && buf.length ? this.write(buf) : "";
+  if (this.lastNeed) {
+    return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+  }
+  return r;
+}
+
+function simpleWrite(
+  this: StringDecoderBase,
+  buf: Buffer | string,
+): string {
+  if (typeof buf === "string") {
+    return buf;
+  }
+  return buf.toString(this.encoding);
+}
+
+function simpleEnd(this: GenericDecoder, buf?: Buffer): string {
+  return buf && buf.length ? this.write(buf) : "";
+}
+
+class StringDecoderBase {
+  public lastChar: Buffer;
+  public lastNeed = 0;
+  public lastTotal = 0;
+  constructor(public encoding: string, nb: number) {
+    this.lastChar = Buffer.allocUnsafe(nb);
+  }
+}
+
+class Base64Decoder extends StringDecoderBase {
+  public end = base64End;
+  public fillLast = utf8FillLastIncomplete;
+  public text = base64Text;
+  public write = utf8Write;
+
+  constructor(encoding?: string) {
+    super(normalizeEncoding(encoding), 3);
+  }
+}
+
+class GenericDecoder extends StringDecoderBase {
+  public end = simpleEnd;
+  public fillLast = undefined;
+  public text = utf8Text;
+  public write = simpleWrite;
+
+  constructor(encoding?: string) {
+    super(normalizeEncoding(encoding), 4);
+  }
+}
+
+class Utf8Decoder extends StringDecoderBase {
+  public end = utf8End;
+  public fillLast = utf8FillLastComplete;
+  public text = utf8Text;
+  public write = utf8Write;
+
+  constructor(encoding?: string) {
+    super(normalizeEncoding(encoding), 4);
+  }
+}
+
+/*
+ * StringDecoder provides an interface for efficiently splitting a series of
+ * buffers into a series of JS strings without breaking apart multi-byte
+ * characters.
+ */
+export class StringDecoder {
+  public encoding: string;
+  public end: (buf?: Buffer) => string;
+  public fillLast: ((buf: Buffer) => string | undefined) | undefined;
+  public lastChar: Buffer;
+  public lastNeed: number;
+  public lastTotal: number;
+  public text: (buf: Buffer, n: number) => string;
+  public write: (buf: Buffer) => string;
+
+  constructor(encoding?: string) {
+    const normalizedEncoding = normalizeEncoding(encoding);
+    let decoder: Utf8Decoder | Base64Decoder | GenericDecoder;
+    switch (normalizedEncoding) {
+      case "utf8":
+        decoder = new Utf8Decoder(encoding);
+        break;
+      case "base64":
+        decoder = new Base64Decoder(encoding);
+        break;
+      default:
+        decoder = new GenericDecoder(encoding);
+    }
+    this.encoding = decoder.encoding;
+    this.end = decoder.end;
+    this.fillLast = decoder.fillLast;
+    this.lastChar = decoder.lastChar;
+    this.lastNeed = decoder.lastNeed;
+    this.lastTotal = decoder.lastTotal;
+    this.text = decoder.text;
+    this.write = decoder.write;
+  }
+}
+// Allow calling StringDecoder() without new
+const PStringDecoder = new Proxy(StringDecoder, {
+  apply(_target, thisArg, args) {
+    // @ts-ignore tedious to replicate types ...
+    return Object.assign(thisArg, new StringDecoder(...args));
+  },
+});
+
+export default { StringDecoder: PStringDecoder };

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

@@ -0,0 +1,4 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as types from "../internal/util/types.ts";
+export * from "../internal/util/types.ts";
+export default { ...types };

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

@@ -0,0 +1,289 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { promisify } from "./internal/util.mjs";
+import { callbackify } from "./_util/_util_callbackify.ts";
+import { debuglog } from "./internal/util/debuglog.ts";
+import {
+  format,
+  formatWithOptions,
+  inspect,
+  stripVTControlCharacters,
+} from "./internal/util/inspect.mjs";
+import { codes } from "./internal/error_codes.ts";
+import types from "./util/types.ts";
+import { Buffer } from "./buffer.ts";
+import { isDeepStrictEqual } from "./internal/util/comparisons.ts";
+import process from "./process.ts";
+import { validateString } from "./internal/validators.mjs";
+
+export {
+  callbackify,
+  debuglog,
+  format,
+  formatWithOptions,
+  inspect,
+  promisify,
+  stripVTControlCharacters,
+  types,
+};
+
+/** @deprecated - use `Array.isArray()` instead. */
+export function isArray(value: unknown): boolean {
+  return Array.isArray(value);
+}
+
+/** @deprecated - use `typeof value === "boolean" || value instanceof Boolean` instead. */
+export function isBoolean(value: unknown): boolean {
+  return typeof value === "boolean" || value instanceof Boolean;
+}
+
+/** @deprecated - use `value === null` instead. */
+export function isNull(value: unknown): boolean {
+  return value === null;
+}
+
+/** @deprecated - use `value === null || value === undefined` instead. */
+export function isNullOrUndefined(value: unknown): boolean {
+  return value === null || value === undefined;
+}
+
+/** @deprecated - use `typeof value === "number" || value instanceof Number` instead. */
+export function isNumber(value: unknown): boolean {
+  return typeof value === "number" || value instanceof Number;
+}
+
+/** @deprecated - use `typeof value === "string" || value instanceof String` instead. */
+export function isString(value: unknown): boolean {
+  return typeof value === "string" || value instanceof String;
+}
+
+/** @deprecated - use `typeof value === "symbol"` instead. */
+export function isSymbol(value: unknown): boolean {
+  return typeof value === "symbol";
+}
+
+/** @deprecated - use `value === undefined` instead. */
+export function isUndefined(value: unknown): boolean {
+  return value === undefined;
+}
+
+/** @deprecated - use `value !== null && typeof value === "object"` instead. */
+export function isObject(value: unknown): boolean {
+  return value !== null && typeof value === "object";
+}
+
+/** @deprecated - use `e instanceof Error` instead. */
+export function isError(e: unknown): boolean {
+  return e instanceof Error;
+}
+
+/** @deprecated - use `typeof value === "function"` instead. */
+export function isFunction(value: unknown): boolean {
+  return typeof value === "function";
+}
+
+/** @deprecated Use util.types.RegExp() instead. */
+export function isRegExp(value: unknown): boolean {
+  return types.isRegExp(value);
+}
+
+/** @deprecated Use util.types.isDate() instead. */
+export function isDate(value: unknown): boolean {
+  return types.isDate(value);
+}
+
+/** @deprecated - use `value === null || (typeof value !== "object" && typeof value !== "function")` instead. */
+export function isPrimitive(value: unknown): boolean {
+  return (
+    value === null || (typeof value !== "object" && typeof value !== "function")
+  );
+}
+
+/** @deprecated  Use Buffer.isBuffer() instead. */
+export function isBuffer(value: unknown): boolean {
+  return Buffer.isBuffer(value);
+}
+
+/** @deprecated Use Object.assign() instead. */
+export function _extend(
+  target: Record<string, unknown>,
+  source: unknown,
+): Record<string, unknown> {
+  // Don't do anything if source isn't an object
+  if (source === null || typeof source !== "object") return target;
+
+  const keys = Object.keys(source!);
+  let i = keys.length;
+  while (i--) {
+    target[keys[i]] = (source as Record<string, unknown>)[keys[i]];
+  }
+  return target;
+}
+
+/**
+ * https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor
+ * @param ctor Constructor function which needs to inherit the prototype.
+ * @param superCtor Constructor function to inherit prototype from.
+ */
+export function inherits<T, U>(
+  ctor: new (...args: unknown[]) => T,
+  superCtor: new (...args: unknown[]) => U,
+) {
+  if (ctor === undefined || ctor === null) {
+    throw new codes.ERR_INVALID_ARG_TYPE("ctor", "Function", ctor);
+  }
+
+  if (superCtor === undefined || superCtor === null) {
+    throw new codes.ERR_INVALID_ARG_TYPE("superCtor", "Function", superCtor);
+  }
+
+  if (superCtor.prototype === undefined) {
+    throw new codes.ERR_INVALID_ARG_TYPE(
+      "superCtor.prototype",
+      "Object",
+      superCtor.prototype,
+    );
+  }
+  Object.defineProperty(ctor, "super_", {
+    value: superCtor,
+    writable: true,
+    configurable: true,
+  });
+  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+
+import { _TextDecoder, _TextEncoder, getSystemErrorName } from "./_utils.ts";
+
+/** The global TextDecoder */
+export type TextDecoder = import("./_utils.ts")._TextDecoder;
+export const TextDecoder = _TextDecoder;
+
+/** The global TextEncoder */
+export type TextEncoder = import("./_utils.ts")._TextEncoder;
+export const TextEncoder = _TextEncoder;
+
+function pad(n: number) {
+  return n.toString().padStart(2, "0");
+}
+
+const months = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+/**
+ * @returns 26 Feb 16:19:34
+ */
+function timestamp(): string {
+  const d = new Date();
+  const t = [
+    pad(d.getHours()),
+    pad(d.getMinutes()),
+    pad(d.getSeconds()),
+  ].join(":");
+  return `${(d.getDate())} ${months[(d).getMonth()]} ${t}`;
+}
+
+/**
+ * Log is just a thin wrapper to console.log that prepends a timestamp
+ * @deprecated
+ */
+// deno-lint-ignore no-explicit-any
+export function log(...args: any[]) {
+  console.log("%s - %s", timestamp(), format(...args));
+}
+
+// Keep a list of deprecation codes that have been warned on so we only warn on
+// each one once.
+const codesWarned = new Set();
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+// deno-lint-ignore no-explicit-any
+export function deprecate(fn: any, msg: string, code?: any) {
+  if (process.noDeprecation === true) {
+    return fn;
+  }
+
+  if (code !== undefined) {
+    validateString(code, "code");
+  }
+
+  let warned = false;
+  // deno-lint-ignore no-explicit-any
+  function deprecated(this: any, ...args: any[]) {
+    if (!warned) {
+      warned = true;
+      if (code !== undefined) {
+        if (!codesWarned.has(code)) {
+          process.emitWarning(msg, "DeprecationWarning", code, deprecated);
+          codesWarned.add(code);
+        }
+      } else {
+        // deno-lint-ignore no-explicit-any
+        process.emitWarning(msg, "DeprecationWarning", deprecated as any);
+      }
+    }
+    if (new.target) {
+      return Reflect.construct(fn, args, new.target);
+    }
+    return Reflect.apply(fn, this, args);
+  }
+
+  // The wrapper will keep the same prototype as fn to maintain prototype chain
+  Object.setPrototypeOf(deprecated, fn);
+  if (fn.prototype) {
+    // Setting this (rather than using Object.setPrototype, as above) ensures
+    // that calling the unwrapped constructor gives an instanceof the wrapped
+    // constructor.
+    deprecated.prototype = fn.prototype;
+  }
+
+  return deprecated;
+}
+
+export { getSystemErrorName, isDeepStrictEqual };
+
+export default {
+  format,
+  formatWithOptions,
+  inspect,
+  isArray,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isSymbol,
+  isUndefined,
+  isObject,
+  isError,
+  isFunction,
+  isRegExp,
+  isDate,
+  isPrimitive,
+  isBuffer,
+  _extend,
+  getSystemErrorName,
+  deprecate,
+  callbackify,
+  promisify,
+  inherits,
+  types,
+  stripVTControlCharacters,
+  TextDecoder,
+  TextEncoder,
+  log,
+  debuglog,
+  isDeepStrictEqual,
+};