@netlify/plugin-nextjs 4.40.0 → 4.40.2

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

@@ -0,0 +1,66 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+/* Copyright 1998 by the Massachusetts Institute of Technology.
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+// REF: https://github.com/nodejs/node/blob/master/deps/cares/include/ares.h#L190
+
+export const ARES_AI_CANONNAME = 1 << 0;
+export const ARES_AI_NUMERICHOST = 1 << 1;
+export const ARES_AI_PASSIVE = 1 << 2;
+export const ARES_AI_NUMERICSERV = 1 << 3;
+export const AI_V4MAPPED = 1 << 4;
+export const AI_ALL = 1 << 5;
+export const AI_ADDRCONFIG = 1 << 6;
+export const ARES_AI_NOSORT = 1 << 7;
+export const ARES_AI_ENVHOSTS = 1 << 8;
+
+// REF: https://github.com/nodejs/node/blob/master/deps/cares/src/lib/ares_strerror.c
+
+export function ares_strerror(code: number) {
+  /* Return a string literal from a table. */
+  const errorText = [
+    "Successful completion",
+    "DNS server returned answer with no data",
+    "DNS server claims query was misformatted",
+    "DNS server returned general failure",
+    "Domain name not found",
+    "DNS server does not implement requested operation",
+    "DNS server refused query",
+    "Misformatted DNS query",
+    "Misformatted domain name",
+    "Unsupported address family",
+    "Misformatted DNS reply",
+    "Could not contact DNS servers",
+    "Timeout while contacting DNS servers",
+    "End of file",
+    "Error reading file",
+    "Out of memory",
+    "Channel is being destroyed",
+    "Misformatted string",
+    "Illegal flags specified",
+    "Given hostname is not numeric",
+    "Illegal hints flags specified",
+    "c-ares library initialization not yet performed",
+    "Error loading iphlpapi.dll",
+    "Could not find GetNetworkParams function",
+    "DNS query cancelled",
+  ];
+
+  if (code >= 0 && code < errorText.length) {
+    return errorText[code];
+  } else {
+    return "unknown";
+  }
+}

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

@@ -0,0 +1,152 @@
+// 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.
+
+// This module ports:
+// - https://github.com/nodejs/node/blob/master/src/async_wrap-inl.h
+// - https://github.com/nodejs/node/blob/master/src/async_wrap.cc
+// - https://github.com/nodejs/node/blob/master/src/async_wrap.h
+
+export function registerDestroyHook(
+  // deno-lint-ignore no-explicit-any
+  _target: any,
+  _asyncId: number,
+  _prop: { destroyed: boolean },
+) {
+  // TODO(kt3k): implement actual procedures
+}
+
+export enum constants {
+  kInit,
+  kBefore,
+  kAfter,
+  kDestroy,
+  kPromiseResolve,
+  kTotals,
+  kCheck,
+  kExecutionAsyncId,
+  kTriggerAsyncId,
+  kAsyncIdCounter,
+  kDefaultTriggerAsyncId,
+  kUsesExecutionAsyncResource,
+  kStackLength,
+}
+
+const asyncHookFields = new Uint32Array(Object.keys(constants).length);
+
+export { asyncHookFields as async_hook_fields };
+
+// Increment the internal id counter and return the value.
+export function newAsyncId() {
+  return ++asyncIdFields[constants.kAsyncIdCounter];
+}
+
+export enum UidFields {
+  kExecutionAsyncId,
+  kTriggerAsyncId,
+  kAsyncIdCounter,
+  kDefaultTriggerAsyncId,
+  kUidFieldsCount,
+}
+
+const asyncIdFields = new Float64Array(Object.keys(UidFields).length);
+
+// `kAsyncIdCounter` should start at `1` because that'll be the id the execution
+// context during bootstrap.
+asyncIdFields[UidFields.kAsyncIdCounter] = 1;
+
+// `kDefaultTriggerAsyncId` should be `-1`, this indicates that there is no
+// specified default value and it should fallback to the executionAsyncId.
+// 0 is not used as the magic value, because that indicates a missing
+// context which is different from a default context.
+asyncIdFields[UidFields.kDefaultTriggerAsyncId] = -1;
+
+export { asyncIdFields };
+
+export enum providerType {
+  NONE,
+  DIRHANDLE,
+  DNSCHANNEL,
+  ELDHISTOGRAM,
+  FILEHANDLE,
+  FILEHANDLECLOSEREQ,
+  FIXEDSIZEBLOBCOPY,
+  FSEVENTWRAP,
+  FSREQCALLBACK,
+  FSREQPROMISE,
+  GETADDRINFOREQWRAP,
+  GETNAMEINFOREQWRAP,
+  HEAPSNAPSHOT,
+  HTTP2SESSION,
+  HTTP2STREAM,
+  HTTP2PING,
+  HTTP2SETTINGS,
+  HTTPINCOMINGMESSAGE,
+  HTTPCLIENTREQUEST,
+  JSSTREAM,
+  JSUDPWRAP,
+  MESSAGEPORT,
+  PIPECONNECTWRAP,
+  PIPESERVERWRAP,
+  PIPEWRAP,
+  PROCESSWRAP,
+  PROMISE,
+  QUERYWRAP,
+  SHUTDOWNWRAP,
+  SIGNALWRAP,
+  STATWATCHER,
+  STREAMPIPE,
+  TCPCONNECTWRAP,
+  TCPSERVERWRAP,
+  TCPWRAP,
+  TTYWRAP,
+  UDPSENDWRAP,
+  UDPWRAP,
+  SIGINTWATCHDOG,
+  WORKER,
+  WORKERHEAPSNAPSHOT,
+  WRITEWRAP,
+  ZLIB,
+}
+
+const kInvalidAsyncId = -1;
+
+export class AsyncWrap {
+  provider: providerType = providerType.NONE;
+  asyncId = kInvalidAsyncId;
+
+  constructor(provider: providerType) {
+    this.provider = provider;
+    this.getAsyncId();
+  }
+
+  getAsyncId(): number {
+    this.asyncId = this.asyncId === kInvalidAsyncId
+      ? newAsyncId()
+      : this.asyncId;
+
+    return this.asyncId;
+  }
+
+  getProviderType() {
+    return this.provider;
+  }
+}

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

@@ -0,0 +1,130 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import { Encodings } from "./_node.ts";
+import { indexOfNeedle } from "../../bytes/index_of_needle.ts";
+
+export function numberToBytes(n: number): Uint8Array {
+  if (n === 0) return new Uint8Array([0]);
+
+  const bytes = [];
+  bytes.unshift(n & 255);
+  while (n >= 256) {
+    n = n >>> 8;
+    bytes.unshift(n & 255);
+  }
+  return new Uint8Array(bytes);
+}
+
+// TODO(Soremwar)
+// Check if offset or buffer can be transform in order to just use std's lastIndexOf directly
+// This implementation differs from std's lastIndexOf in the fact that
+// it also includes items outside of the offset as long as part of the
+// set is contained inside of the offset
+// Probably way slower too
+function findLastIndex(
+  targetBuffer: Uint8Array,
+  buffer: Uint8Array,
+  offset: number,
+) {
+  offset = offset > targetBuffer.length ? targetBuffer.length : offset;
+
+  const searchableBuffer = targetBuffer.slice(0, offset + buffer.length);
+  const searchableBufferLastIndex = searchableBuffer.length - 1;
+  const bufferLastIndex = buffer.length - 1;
+
+  // Important to keep track of the last match index in order to backtrack after an incomplete match
+  // Not doing this will cause the search to skip all possible matches that happened in the
+  // last match range
+  let lastMatchIndex = -1;
+  let matches = 0;
+  let index = -1;
+  for (let x = 0; x <= searchableBufferLastIndex; x++) {
+    if (
+      searchableBuffer[searchableBufferLastIndex - x] ===
+        buffer[bufferLastIndex - matches]
+    ) {
+      if (lastMatchIndex === -1) {
+        lastMatchIndex = x;
+      }
+      matches++;
+    } else {
+      matches = 0;
+      if (lastMatchIndex !== -1) {
+        // Restart the search right after the last index was ignored
+        x = lastMatchIndex + 1;
+        lastMatchIndex = -1;
+      }
+      continue;
+    }
+
+    if (matches === buffer.length) {
+      index = x;
+      break;
+    }
+  }
+
+  if (index === -1) return index;
+
+  return searchableBufferLastIndex - index;
+}
+
+// TODO
+// Take encoding into account when evaluating index
+function indexOfBuffer(
+  targetBuffer: Uint8Array,
+  buffer: Uint8Array,
+  byteOffset: number,
+  encoding: Encodings,
+  forwardDirection: boolean,
+) {
+  if (!Encodings[encoding] === undefined) {
+    throw new Error(`Unknown encoding code ${encoding}`);
+  }
+
+  if (!forwardDirection) {
+    // If negative the offset is calculated from the end of the buffer
+
+    if (byteOffset < 0) {
+      byteOffset = targetBuffer.length + byteOffset;
+    }
+
+    if (buffer.length === 0) {
+      return byteOffset <= targetBuffer.length
+        ? byteOffset
+        : targetBuffer.length;
+    }
+
+    return findLastIndex(targetBuffer, buffer, byteOffset);
+  }
+
+  if (buffer.length === 0) {
+    return byteOffset <= targetBuffer.length ? byteOffset : targetBuffer.length;
+  }
+
+  return indexOfNeedle(targetBuffer, buffer, byteOffset);
+}
+
+// TODO(Soremwar)
+// Node's implementation is a very obscure algorithm that I haven't been able to crack just yet
+function indexOfNumber(
+  targetBuffer: Uint8Array,
+  number: number,
+  byteOffset: number,
+  forwardDirection: boolean,
+) {
+  const bytes = numberToBytes(number);
+
+  if (bytes.length > 1) {
+    throw new Error("Multi byte number search is not supported");
+  }
+
+  return indexOfBuffer(
+    targetBuffer,
+    numberToBytes(number),
+    byteOffset,
+    Encodings.UTF8,
+    forwardDirection,
+  );
+}
+
+export default { indexOfBuffer, indexOfNumber };
+export { indexOfBuffer, indexOfNumber };