@netlify/plugin-nextjs 4.40.0 → 4.40.2

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

@@ -0,0 +1,123 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and other Node contributors.
+
+// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
+const kSize = 2048;
+const kMask = kSize - 1;
+
+// The FixedQueue is implemented as a singly-linked list of fixed-size
+// circular buffers. It looks something like this:
+//
+//  head                                                       tail
+//    |                                                          |
+//    v                                                          v
+// +-----------+ <-----\       +-----------+ <------\         +-----------+
+// |  [null]   |        \----- |   next    |         \------- |   next    |
+// +-----------+               +-----------+                  +-----------+
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |       bottom --> |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |    ...    |               |    ...    |                  |    ...    |
+// |   item    |               |   item    |                  |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// +-----------+               +-----------+                  +-----------+
+//
+// Or, if there is only one circular buffer, it looks something
+// like either of these:
+//
+//  head   tail                                 head   tail
+//    |     |                                     |     |
+//    v     v                                     v     v
+// +-----------+                               +-----------+
+// |  [null]   |                               |  [null]   |
+// +-----------+                               +-----------+
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
+// +-----------+                               +-----------+
+//
+// Adding a value means moving `top` forward by one, removing means
+// moving `bottom` forward by one. After reaching the end, the queue
+// wraps around.
+//
+// When `top === bottom` the current queue is empty and when
+// `top + 1 === bottom` it's full. This wastes a single space of storage
+// but allows much quicker checks.
+
+class FixedCircularBuffer {
+  bottom: number;
+  top: number;
+  list: undefined | Array<unknown>;
+  next: FixedCircularBuffer | null;
+
+  constructor() {
+    this.bottom = 0;
+    this.top = 0;
+    this.list = new Array(kSize);
+    this.next = null;
+  }
+
+  isEmpty() {
+    return this.top === this.bottom;
+  }
+
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom;
+  }
+
+  push(data: unknown) {
+    this.list![this.top] = data;
+    this.top = (this.top + 1) & kMask;
+  }
+
+  shift() {
+    const nextItem = this.list![this.bottom];
+    if (nextItem === undefined) {
+      return null;
+    }
+    this.list![this.bottom] = undefined;
+    this.bottom = (this.bottom + 1) & kMask;
+    return nextItem;
+  }
+}
+
+export class FixedQueue {
+  head: FixedCircularBuffer;
+  tail: FixedCircularBuffer;
+
+  constructor() {
+    this.head = this.tail = new FixedCircularBuffer();
+  }
+
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+
+  push(data: unknown) {
+    if (this.head.isFull()) {
+      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
+      // and sets it as the new main queue.
+      this.head = this.head.next = new FixedCircularBuffer();
+    }
+    this.head.push(data);
+  }
+
+  shift() {
+    const tail = this.tail;
+    const next = tail.shift();
+    if (tail.isEmpty() && tail.next !== null) {
+      // If there is another queue, it forms the new tail.
+      this.tail = tail.next;
+    }
+    return next;
+  }
+}

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

@@ -0,0 +1,16 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+// deno-lint-ignore no-explicit-any
+type GenericFunction = (...args: any[]) => any;
+
+/** This function removes unnecessary frames from Node.js core errors. */
+export function hideStackFrames<T extends GenericFunction = GenericFunction>(
+  fn: T,
+): T {
+  // We rename the functions that will be hidden to cut off the stacktrace
+  // at the outermost one.
+  const hidden = "__node_internal_" + fn.name;
+  Object.defineProperty(fn, "name", { value: hidden });
+
+  return fn;
+}

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

@@ -0,0 +1,95 @@
+// 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 { uvException } from "./errors.ts";
+import { writeBuffer } from "../internal_binding/node_file.ts";
+
+// IPv4 Segment
+const v4Seg = "(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])";
+const v4Str = `(${v4Seg}[.]){3}${v4Seg}`;
+const IPv4Reg = new RegExp(`^${v4Str}$`);
+
+// IPv6 Segment
+const v6Seg = "(?:[0-9a-fA-F]{1,4})";
+const IPv6Reg = new RegExp(
+  "^(" +
+    `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +
+    `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +
+    `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +
+    `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +
+    `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +
+    `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +
+    `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +
+    `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +
+    ")(%[0-9a-zA-Z-.:]{1,})?$",
+);
+
+export function isIPv4(ip: string) {
+  return RegExp.prototype.test.call(IPv4Reg, ip);
+}
+
+export function isIPv6(ip: string) {
+  return RegExp.prototype.test.call(IPv6Reg, ip);
+}
+
+export function isIP(ip: string) {
+  if (isIPv4(ip)) {
+    return 4;
+  }
+  if (isIPv6(ip)) {
+    return 6;
+  }
+
+  return 0;
+}
+
+export function makeSyncWrite(fd: number) {
+  return function (
+    // deno-lint-ignore no-explicit-any
+    this: any,
+    // deno-lint-ignore no-explicit-any
+    chunk: any,
+    enc: string,
+    cb: (err?: Error) => void,
+  ) {
+    if (enc !== "buffer") {
+      chunk = Buffer.from(chunk, enc);
+    }
+
+    this._handle.bytesWritten += chunk.length;
+
+    const ctx: { errno?: number } = {};
+    writeBuffer(fd, chunk, 0, chunk.length, null, ctx);
+
+    if (ctx.errno !== undefined) {
+      const ex = uvException(ctx);
+      ex.errno = ctx.errno;
+
+      return cb(ex);
+    }
+
+    cb();
+  };
+}
+
+export const normalizedArgsSymbol = Symbol("normalizedArgs");

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

@@ -0,0 +1,72 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+export function normalizeEncoding(enc) {
+  if (enc == null || enc === "utf8" || enc === "utf-8") return "utf8";
+  return slowCases(enc);
+}
+
+export function slowCases(enc) {
+  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;
+    case 9:
+      if (
+        enc === "base64url" || enc === "BASE64URL" ||
+        `${enc}`.toLowerCase() === "base64url"
+      ) {
+        return "base64url";
+      }
+      break;
+    default:
+      if (enc === "") return "utf8";
+  }
+}

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

@@ -0,0 +1,45 @@
+// 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 { getOptions } from "../internal_binding/node_options.ts";
+
+let optionsMap: Map<string, { value: string }>;
+
+function getOptionsFromBinding() {
+  if (!optionsMap) {
+    ({ options: optionsMap } = getOptions());
+  }
+
+  return optionsMap;
+}
+
+export function getOptionValue(optionName: string) {
+  const options = getOptionsFromBinding();
+
+  if (optionName.startsWith("--no-")) {
+    const option = options.get("--" + optionName.slice(5));
+
+    return option && !option.value;
+  }
+
+  return options.get(optionName)?.value;
+}

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

@@ -0,0 +1,30 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+export const ArrayIsArray = Array.isArray;
+export const ArrayPrototypeFilter = (that, ...args) => that.filter(...args);
+export const ArrayPrototypeForEach = (that, ...args) => that.forEach(...args);
+export const ArrayPrototypeIncludes = (that, ...args) => that.includes(...args);
+export const ArrayPrototypeJoin = (that, ...args) => that.join(...args);
+export const ArrayPrototypePush = (that, ...args) => that.push(...args);
+export const ArrayPrototypeSlice = (that, ...args) => that.slice(...args);
+export const ArrayPrototypeSome = (that, ...args) => that.some(...args);
+export const ArrayPrototypeSort = (that, ...args) => that.sort(...args);
+export const ArrayPrototypeUnshift = (that, ...args) => that.unshift(...args);
+export const ObjectAssign = Object.assign;
+export const ObjectCreate = Object.create;
+export const ObjectPrototypeHasOwnProperty = Object.hasOwn;
+export const RegExpPrototypeTest = (that, ...args) => that.test(...args);
+export const RegExpPrototypeExec = RegExp.prototype.exec;
+export const StringFromCharCode = String.fromCharCode;
+export const StringPrototypeCharCodeAt = (that, ...args) =>
+  that.charCodeAt(...args);
+export const StringPrototypeEndsWith = (that, ...args) =>
+  that.endsWith(...args);
+export const StringPrototypeIncludes = (that, ...args) =>
+  that.includes(...args);
+export const StringPrototypeReplace = (that, ...args) => that.replace(...args);
+export const StringPrototypeSlice = (that, ...args) => that.slice(...args);
+export const StringPrototypeSplit = (that, ...args) => that.split(...args);
+export const StringPrototypeStartsWith = (that, ...args) =>
+  that.startsWith(...args);
+export const StringPrototypeToUpperCase = (that) => that.toUpperCase();

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

@@ -0,0 +1,272 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
+
+const kInternal = Symbol("internal properties");
+
+const replaceUnderscoresRegex = /_/g;
+const leadingDashesRegex = /^--?/;
+const trailingValuesRegex = /=.*$/;
+
+// This builds the initial process.allowedNodeEnvironmentFlags
+// from data in the config binding.
+export function buildAllowedFlags() {
+  const allowedNodeEnvironmentFlags = [
+    "--track-heap-objects",
+    "--no-track-heap-objects",
+    "--node-snapshot",
+    "--no-node-snapshot",
+    "--require",
+    "--max-old-space-size",
+    "--trace-exit",
+    "--no-trace-exit",
+    "--disallow-code-generation-from-strings",
+    "--experimental-json-modules",
+    "--no-experimental-json-modules",
+    "--interpreted-frames-native-stack",
+    "--inspect-brk",
+    "--no-inspect-brk",
+    "--trace-tls",
+    "--no-trace-tls",
+    "--stack-trace-limit",
+    "--experimental-repl-await",
+    "--no-experimental-repl-await",
+    "--preserve-symlinks",
+    "--no-preserve-symlinks",
+    "--report-uncaught-exception",
+    "--no-report-uncaught-exception",
+    "--experimental-modules",
+    "--no-experimental-modules",
+    "--report-signal",
+    "--jitless",
+    "--inspect-port",
+    "--heapsnapshot-near-heap-limit",
+    "--tls-keylog",
+    "--force-context-aware",
+    "--no-force-context-aware",
+    "--napi-modules",
+    "--abort-on-uncaught-exception",
+    "--diagnostic-dir",
+    "--verify-base-objects",
+    "--no-verify-base-objects",
+    "--unhandled-rejections",
+    "--perf-basic-prof",
+    "--trace-atomics-wait",
+    "--no-trace-atomics-wait",
+    "--deprecation",
+    "--no-deprecation",
+    "--perf-basic-prof-only-functions",
+    "--perf-prof",
+    "--max-http-header-size",
+    "--report-on-signal",
+    "--no-report-on-signal",
+    "--throw-deprecation",
+    "--no-throw-deprecation",
+    "--warnings",
+    "--no-warnings",
+    "--force-fips",
+    "--no-force-fips",
+    "--pending-deprecation",
+    "--no-pending-deprecation",
+    "--input-type",
+    "--tls-max-v1.3",
+    "--no-tls-max-v1.3",
+    "--tls-min-v1.2",
+    "--no-tls-min-v1.2",
+    "--inspect",
+    "--no-inspect",
+    "--heapsnapshot-signal",
+    "--trace-warnings",
+    "--no-trace-warnings",
+    "--trace-event-categories",
+    "--experimental-worker",
+    "--tls-max-v1.2",
+    "--no-tls-max-v1.2",
+    "--perf-prof-unwinding-info",
+    "--preserve-symlinks-main",
+    "--no-preserve-symlinks-main",
+    "--policy-integrity",
+    "--experimental-wasm-modules",
+    "--no-experimental-wasm-modules",
+    "--node-memory-debug",
+    "--inspect-publish-uid",
+    "--tls-min-v1.3",
+    "--no-tls-min-v1.3",
+    "--experimental-specifier-resolution",
+    "--secure-heap",
+    "--tls-min-v1.0",
+    "--no-tls-min-v1.0",
+    "--redirect-warnings",
+    "--experimental-report",
+    "--trace-event-file-pattern",
+    "--trace-uncaught",
+    "--no-trace-uncaught",
+    "--experimental-loader",
+    "--http-parser",
+    "--dns-result-order",
+    "--trace-sigint",
+    "--no-trace-sigint",
+    "--secure-heap-min",
+    "--enable-fips",
+    "--no-enable-fips",
+    "--enable-source-maps",
+    "--no-enable-source-maps",
+    "--insecure-http-parser",
+    "--no-insecure-http-parser",
+    "--use-openssl-ca",
+    "--no-use-openssl-ca",
+    "--tls-cipher-list",
+    "--experimental-top-level-await",
+    "--no-experimental-top-level-await",
+    "--openssl-config",
+    "--icu-data-dir",
+    "--v8-pool-size",
+    "--report-on-fatalerror",
+    "--no-report-on-fatalerror",
+    "--title",
+    "--tls-min-v1.1",
+    "--no-tls-min-v1.1",
+    "--report-filename",
+    "--trace-deprecation",
+    "--no-trace-deprecation",
+    "--report-compact",
+    "--no-report-compact",
+    "--experimental-policy",
+    "--experimental-import-meta-resolve",
+    "--no-experimental-import-meta-resolve",
+    "--zero-fill-buffers",
+    "--no-zero-fill-buffers",
+    "--report-dir",
+    "--use-bundled-ca",
+    "--no-use-bundled-ca",
+    "--experimental-vm-modules",
+    "--no-experimental-vm-modules",
+    "--force-async-hooks-checks",
+    "--no-force-async-hooks-checks",
+    "--frozen-intrinsics",
+    "--no-frozen-intrinsics",
+    "--huge-max-old-generation-size",
+    "--disable-proto",
+    "--debug-arraybuffer-allocations",
+    "--no-debug-arraybuffer-allocations",
+    "--conditions",
+    "--experimental-wasi-unstable-preview1",
+    "--no-experimental-wasi-unstable-preview1",
+    "--trace-sync-io",
+    "--no-trace-sync-io",
+    "--use-largepages",
+    "--experimental-abortcontroller",
+    "--debug-port",
+    "--es-module-specifier-resolution",
+    "--prof-process",
+    "-C",
+    "--loader",
+    "--report-directory",
+    "-r",
+    "--trace-events-enabled",
+  ];
+
+  /*
+  function isAccepted(to) {
+    if (!to.startsWith("-") || to === "--") return true;
+    const recursiveExpansion = aliases.get(to);
+    if (recursiveExpansion) {
+      if (recursiveExpansion[0] === to) {
+        recursiveExpansion.splice(0, 1);
+      }
+      return recursiveExpansion.every(isAccepted);
+    }
+    return options.get(to).envVarSettings === kAllowedInEnvironment;
+  }
+  for (const { 0: from, 1: expansion } of aliases) {
+    if (expansion.every(isAccepted)) {
+      let canonical = from;
+      if (canonical.endsWith("=")) {
+        canonical = canonical.slice(0, canonical.length - 1);
+      }
+      if (canonical.endsWith(" <arg>")) {
+        canonical = canonical.slice(0, canonical.length - 4);
+      }
+      allowedNodeEnvironmentFlags.push(canonical);
+    }
+  }
+  */
+
+  const trimLeadingDashes = (flag) => flag.replace(leadingDashesRegex, "");
+
+  // Save these for comparison against flags provided to
+  // process.allowedNodeEnvironmentFlags.has() which lack leading dashes.
+  const nodeFlags = allowedNodeEnvironmentFlags.map(trimLeadingDashes);
+
+  class NodeEnvironmentFlagsSet extends Set {
+    constructor(array) {
+      super();
+      this[kInternal] = { array };
+    }
+
+    add() {
+      // No-op, `Set` API compatible
+      return this;
+    }
+
+    delete() {
+      // No-op, `Set` API compatible
+      return false;
+    }
+
+    clear() {
+      // No-op, `Set` API compatible
+    }
+
+    has(key) {
+      // This will return `true` based on various possible
+      // permutations of a flag, including present/missing leading
+      // dash(es) and/or underscores-for-dashes.
+      // Strips any values after `=`, inclusive.
+      // TODO(addaleax): It might be more flexible to run the option parser
+      // on a dummy option set and see whether it rejects the argument or
+      // not.
+      if (typeof key === "string") {
+        key = key.replace(replaceUnderscoresRegex, "-");
+        if (leadingDashesRegex.test(key)) {
+          key = key.replace(trailingValuesRegex, "");
+          return this[kInternal].array.includes(key);
+        }
+        return nodeFlags.includes(key);
+      }
+      return false;
+    }
+
+    entries() {
+      this[kInternal].set ??= new Set(this[kInternal].array);
+      return this[kInternal].set.entries();
+    }
+
+    forEach(callback, thisArg = undefined) {
+      this[kInternal].array.forEach((v) =>
+        Reflect.apply(callback, thisArg, [v, v, this])
+      );
+    }
+
+    get size() {
+      return this[kInternal].array.length;
+    }
+
+    values() {
+      this[kInternal].set ??= new Set(this[kInternal].array);
+      return this[kInternal].set.values();
+    }
+  }
+  NodeEnvironmentFlagsSet.prototype.keys =
+    NodeEnvironmentFlagsSet
+      .prototype[Symbol.iterator] =
+      NodeEnvironmentFlagsSet.prototype.values;
+
+  Object.freeze(NodeEnvironmentFlagsSet.prototype.constructor);
+  Object.freeze(NodeEnvironmentFlagsSet.prototype);
+
+  return Object.freeze(
+    new NodeEnvironmentFlagsSet(
+      allowedNodeEnvironmentFlags,
+    ),
+  );
+}