diff --git a/.autorestic.yml.old b/.autorestic.yml.old
new file mode 100644
index 0000000000..ae86b33cdc
--- /dev/null
+++ b/.autorestic.yml.old
@@ -0,0 +1,21 @@
+
+version: 2
+locations:
+  home:
+    from: /
+    to: local
+    options:
+      backup:
+        exclude:
+          - /dev
+          - /proc
+          - /sys
+          - /tmp
+          - /run
+          - /mnt
+          - /media
+          - /lost+found
+backends:
+  local:
+    type: local
+    path: /tmp/autorestic-test
diff --git a/.bash_aliases b/.bash_aliases
new file mode 100644
index 0000000000..e562182892
--- /dev/null
+++ b/.bash_aliases
@@ -0,0 +1,6 @@
+alias yarn="corepack yarn"
+alias yarnpkg="corepack yarnpkg"
+alias pnpm="corepack pnpm"
+alias pnpx="corepack pnpx"
+alias npm="corepack npm"
+alias npx="corepack npx"
\ No newline at end of file
diff --git a/.codesandbox/node/assert.js b/.codesandbox/node/assert.js
new file mode 100644
index 0000000000..2ddc44d9b8
--- /dev/null
+++ b/.codesandbox/node/assert.js
@@ -0,0 +1,824 @@
+'use strict';
+
+const {
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  Error,
+  NumberIsNaN,
+  ObjectAssign,
+  ObjectIs,
+  ObjectKeys,
+  ObjectPrototypeIsPrototypeOf,
+  ReflectApply,
+  RegExpPrototypeExec,
+  String,
+  StringPrototypeIndexOf,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+} = primordials;
+
+const {
+  codes: {
+    ERR_AMBIGUOUS_ARGUMENT,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_RETURN_VALUE,
+    ERR_MISSING_ARGS,
+  },
+} = require('internal/errors');
+const AssertionError = require('internal/assert/assertion_error');
+const { inspect } = require('internal/util/inspect');
+const {
+  isPromise,
+  isRegExp,
+} = require('internal/util/types');
+const { isError, deprecate } = require('internal/util');
+const { innerOk } = require('internal/assert/utils');
+
+const CallTracker = require('internal/assert/calltracker');
+const {
+  validateFunction,
+} = require('internal/validators');
+
+let isDeepEqual;
+let isDeepStrictEqual;
+let isPartialStrictEqual;
+
+function lazyLoadComparison() {
+  const comparison = require('internal/util/comparisons');
+  isDeepEqual = comparison.isDeepEqual;
+  isDeepStrictEqual = comparison.isDeepStrictEqual;
+  isPartialStrictEqual = comparison.isPartialStrictEqual;
+}
+
+let warned = false;
+
+// The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+const assert = module.exports = ok;
+
+const NO_EXCEPTION_SENTINEL = {};
+
+// All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided. All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function innerFail(obj) {
+  if (obj.message instanceof Error) throw obj.message;
+
+  throw new AssertionError(obj);
+}
+
+/**
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @param {string} [operator]
+ * @param {Function} [stackStartFn]
+ */
+function fail(actual, expected, message, operator, stackStartFn) {
+  const argsLen = arguments.length;
+
+  let internalMessage = false;
+  if (actual == null && argsLen <= 1) {
+    internalMessage = true;
+    message = 'Failed';
+  } else if (argsLen === 1) {
+    message = actual;
+    actual = undefined;
+  } else {
+    if (warned === false) {
+      warned = true;
+      process.emitWarning(
+        'assert.fail() with more than one argument is deprecated. ' +
+          'Please use assert.strictEqual() instead or only pass a message.',
+        'DeprecationWarning',
+        'DEP0094',
+      );
+    }
+    if (argsLen === 2)
+      operator = '!=';
+  }
+
+  if (message instanceof Error) throw message;
+
+  const errArgs = {
+    actual,
+    expected,
+    operator: operator === undefined ? 'fail' : operator,
+    stackStartFn: stackStartFn || fail,
+    message,
+  };
+  const err = new AssertionError(errArgs);
+  if (internalMessage) {
+    err.generatedMessage = true;
+  }
+  throw err;
+}
+
+assert.fail = fail;
+
+// The AssertionError is defined in internal/error.
+assert.AssertionError = AssertionError;
+
+/**
+ * Pure assertion tests whether a value is truthy, as determined
+ * by !!value.
+ * @param {...any} args
+ * @returns {void}
+ */
+function ok(...args) {
+  innerOk(ok, args.length, ...args);
+}
+assert.ok = ok;
+
+/**
+ * The equality assertion tests shallow, coercive equality with ==.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+/* eslint-disable no-restricted-properties */
+assert.equal = function equal(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  // eslint-disable-next-line eqeqeq
+  if (actual != expected && (!NumberIsNaN(actual) || !NumberIsNaN(expected))) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '==',
+      stackStartFn: equal,
+    });
+  }
+};
+
+/**
+ * The non-equality assertion tests for whether two objects are not
+ * equal with !=.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.notEqual = function notEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  // eslint-disable-next-line eqeqeq
+  if (actual == expected || (NumberIsNaN(actual) && NumberIsNaN(expected))) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: '!=',
+      stackStartFn: notEqual,
+    });
+  }
+};
+
+/**
+ * The deep equivalence assertion tests a deep equality relation.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.deepEqual = function deepEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (isDeepEqual === undefined) lazyLoadComparison();
+  if (!isDeepEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'deepEqual',
+      stackStartFn: deepEqual,
+    });
+  }
+};
+
+/**
+ * The deep non-equivalence assertion tests for any deep inequality.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (isDeepEqual === undefined) lazyLoadComparison();
+  if (isDeepEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'notDeepEqual',
+      stackStartFn: notDeepEqual,
+    });
+  }
+};
+/* eslint-enable */
+
+/**
+ * The deep strict equivalence assertion tests a deep strict equality
+ * relation.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (isDeepEqual === undefined) lazyLoadComparison();
+  if (!isDeepStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'deepStrictEqual',
+      stackStartFn: deepStrictEqual,
+    });
+  }
+};
+
+/**
+ * The deep strict non-equivalence assertion tests for any deep strict
+ * inequality.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.notDeepStrictEqual = notDeepStrictEqual;
+function notDeepStrictEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (isDeepEqual === undefined) lazyLoadComparison();
+  if (isDeepStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'notDeepStrictEqual',
+      stackStartFn: notDeepStrictEqual,
+    });
+  }
+}
+
+/**
+ * The strict equivalence assertion tests a strict equality relation.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.strictEqual = function strictEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (!ObjectIs(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'strictEqual',
+      stackStartFn: strictEqual,
+    });
+  }
+};
+
+/**
+ * The strict non-equivalence assertion tests for any strict inequality.
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (ObjectIs(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'notStrictEqual',
+      stackStartFn: notStrictEqual,
+    });
+  }
+};
+
+/**
+ * The strict equivalence assertion test between two objects
+ * @param {any} actual
+ * @param {any} expected
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.partialDeepStrictEqual = function partialDeepStrictEqual(
+  actual,
+  expected,
+  message,
+) {
+  if (arguments.length < 2) {
+    throw new ERR_MISSING_ARGS('actual', 'expected');
+  }
+  if (isDeepEqual === undefined) lazyLoadComparison();
+  if (!isPartialStrictEqual(actual, expected)) {
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: 'partialDeepStrictEqual',
+      stackStartFn: partialDeepStrictEqual,
+    });
+  }
+};
+
+class Comparison {
+  constructor(obj, keys, actual) {
+    for (const key of keys) {
+      if (key in obj) {
+        if (actual !== undefined &&
+            typeof actual[key] === 'string' &&
+            isRegExp(obj[key]) &&
+            RegExpPrototypeExec(obj[key], actual[key]) !== null) {
+          this[key] = actual[key];
+        } else {
+          this[key] = obj[key];
+        }
+      }
+    }
+  }
+}
+
+function compareExceptionKey(actual, expected, key, message, keys, fn) {
+  if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+    if (!message) {
+      // Create placeholder objects to create a nice output.
+      const a = new Comparison(actual, keys);
+      const b = new Comparison(expected, keys, actual);
+
+      const err = new AssertionError({
+        actual: a,
+        expected: b,
+        operator: 'deepStrictEqual',
+        stackStartFn: fn,
+      });
+      err.actual = actual;
+      err.expected = expected;
+      err.operator = fn.name;
+      throw err;
+    }
+    innerFail({
+      actual,
+      expected,
+      message,
+      operator: fn.name,
+      stackStartFn: fn,
+    });
+  }
+}
+
+function expectedException(actual, expected, message, fn) {
+  let generatedMessage = false;
+  let throwError = false;
+
+  if (typeof expected !== 'function') {
+    // Handle regular expressions.
+    if (isRegExp(expected)) {
+      const str = String(actual);
+      if (RegExpPrototypeExec(expected, str) !== null)
+        return;
+
+      if (!message) {
+        generatedMessage = true;
+        message = 'The input did not match the regular expression ' +
+                  `${inspect(expected)}. Input:\n\n${inspect(str)}\n`;
+      }
+      throwError = true;
+      // Handle primitives properly.
+    } else if (typeof actual !== 'object' || actual === null) {
+      const err = new AssertionError({
+        actual,
+        expected,
+        message,
+        operator: 'deepStrictEqual',
+        stackStartFn: fn,
+      });
+      err.operator = fn.name;
+      throw err;
+    } else {
+      // Handle validation objects.
+      const keys = ObjectKeys(expected);
+      // Special handle errors to make sure the name and the message are
+      // compared as well.
+      if (expected instanceof Error) {
+        ArrayPrototypePush(keys, 'name', 'message');
+      } else if (keys.length === 0) {
+        throw new ERR_INVALID_ARG_VALUE('error',
+                                        expected, 'may not be an empty object');
+      }
+      if (isDeepEqual === undefined) lazyLoadComparison();
+      for (const key of keys) {
+        if (typeof actual[key] === 'string' &&
+            isRegExp(expected[key]) &&
+            RegExpPrototypeExec(expected[key], actual[key]) !== null) {
+          continue;
+        }
+        compareExceptionKey(actual, expected, key, message, keys, fn);
+      }
+      return;
+    }
+  // Guard instanceof against arrow functions as they don't have a prototype.
+  // Check for matching Error classes.
+  } else if (expected.prototype !== undefined && actual instanceof expected) {
+    return;
+  } else if (ObjectPrototypeIsPrototypeOf(Error, expected)) {
+    if (!message) {
+      generatedMessage = true;
+      message = 'The error is expected to be an instance of ' +
+        `"${expected.name}". Received `;
+      if (isError(actual)) {
+        const name = (actual.constructor?.name) ||
+                     actual.name;
+        if (expected.name === name) {
+          message += 'an error with identical name but a different prototype.';
+        } else {
+          message += `"${name}"`;
+        }
+        if (actual.message) {
+          message += `\n\nError message:\n\n${actual.message}`;
+        }
+      } else {
+        message += `"${inspect(actual, { depth: -1 })}"`;
+      }
+    }
+    throwError = true;
+  } else {
+    // Check validation functions return value.
+    const res = ReflectApply(expected, {}, [actual]);
+    if (res !== true) {
+      if (!message) {
+        generatedMessage = true;
+        const name = expected.name ? `"${expected.name}" ` : '';
+        message = `The ${name}validation function is expected to return` +
+          ` "true". Received ${inspect(res)}`;
+
+        if (isError(actual)) {
+          message += `\n\nCaught error:\n\n${actual}`;
+        }
+      }
+      throwError = true;
+    }
+  }
+
+  if (throwError) {
+    const err = new AssertionError({
+      actual,
+      expected,
+      message,
+      operator: fn.name,
+      stackStartFn: fn,
+    });
+    err.generatedMessage = generatedMessage;
+    throw err;
+  }
+}
+
+function getActual(fn) {
+  validateFunction(fn, 'fn');
+  try {
+    fn();
+  } catch (e) {
+    return e;
+  }
+  return NO_EXCEPTION_SENTINEL;
+}
+
+function checkIsPromise(obj) {
+  // Accept native ES6 promises and promises that are implemented in a similar
+  // way. Do not accept thenables that use a function as `obj` and that have no
+  // `catch` handler.
+  return isPromise(obj) ||
+    (obj !== null && typeof obj === 'object' &&
+    typeof obj.then === 'function' &&
+    typeof obj.catch === 'function');
+}
+
+async function waitForActual(promiseFn) {
+  let resultPromise;
+  if (typeof promiseFn === 'function') {
+    // Return a rejected promise if `promiseFn` throws synchronously.
+    resultPromise = promiseFn();
+    // Fail in case no promise is returned.
+    if (!checkIsPromise(resultPromise)) {
+      throw new ERR_INVALID_RETURN_VALUE('instance of Promise',
+                                         'promiseFn', resultPromise);
+    }
+  } else if (checkIsPromise(promiseFn)) {
+    resultPromise = promiseFn;
+  } else {
+    throw new ERR_INVALID_ARG_TYPE(
+      'promiseFn', ['Function', 'Promise'], promiseFn);
+  }
+
+  try {
+    await resultPromise;
+  } catch (e) {
+    return e;
+  }
+  return NO_EXCEPTION_SENTINEL;
+}
+
+function expectsError(stackStartFn, actual, error, message) {
+  if (typeof error === 'string') {
+    if (arguments.length === 4) {
+      throw new ERR_INVALID_ARG_TYPE('error',
+                                     ['Object', 'Error', 'Function', 'RegExp'],
+                                     error);
+    }
+    if (typeof actual === 'object' && actual !== null) {
+      if (actual.message === error) {
+        throw new ERR_AMBIGUOUS_ARGUMENT(
+          'error/message',
+          `The error message "${actual.message}" is identical to the message.`,
+        );
+      }
+    } else if (actual === error) {
+      throw new ERR_AMBIGUOUS_ARGUMENT(
+        'error/message',
+        `The error "${actual}" is identical to the message.`,
+      );
+    }
+    message = error;
+    error = undefined;
+  } else if (error != null &&
+             typeof error !== 'object' &&
+             typeof error !== 'function') {
+    throw new ERR_INVALID_ARG_TYPE('error',
+                                   ['Object', 'Error', 'Function', 'RegExp'],
+                                   error);
+  }
+
+  if (actual === NO_EXCEPTION_SENTINEL) {
+    let details = '';
+    if (error?.name) {
+      details += ` (${error.name})`;
+    }
+    details += message ? `: ${message}` : '.';
+    const fnType = stackStartFn === assert.rejects ? 'rejection' : 'exception';
+    innerFail({
+      actual: undefined,
+      expected: error,
+      operator: stackStartFn.name,
+      message: `Missing expected ${fnType}${details}`,
+      stackStartFn,
+    });
+  }
+
+  if (!error)
+    return;
+
+  expectedException(actual, error, message, stackStartFn);
+}
+
+function hasMatchingError(actual, expected) {
+  if (typeof expected !== 'function') {
+    if (isRegExp(expected)) {
+      const str = String(actual);
+      return RegExpPrototypeExec(expected, str) !== null;
+    }
+    throw new ERR_INVALID_ARG_TYPE(
+      'expected', ['Function', 'RegExp'], expected,
+    );
+  }
+  // Guard instanceof against arrow functions as they don't have a prototype.
+  if (expected.prototype !== undefined && actual instanceof expected) {
+    return true;
+  }
+  if (ObjectPrototypeIsPrototypeOf(Error, expected)) {
+    return false;
+  }
+  return ReflectApply(expected, {}, [actual]) === true;
+}
+
+function expectsNoError(stackStartFn, actual, error, message) {
+  if (actual === NO_EXCEPTION_SENTINEL)
+    return;
+
+  if (typeof error === 'string') {
+    message = error;
+    error = undefined;
+  }
+
+  if (!error || hasMatchingError(actual, error)) {
+    const details = message ? `: ${message}` : '.';
+    const fnType = stackStartFn === assert.doesNotReject ?
+      'rejection' : 'exception';
+    innerFail({
+      actual,
+      expected: error,
+      operator: stackStartFn.name,
+      message: `Got unwanted ${fnType}${details}\n` +
+               `Actual message: "${actual?.message}"`,
+      stackStartFn,
+    });
+  }
+  throw actual;
+}
+
+/**
+ * Expects the function `promiseFn` to throw an error.
+ * @param {() => any} promiseFn
+ * @param {...any} [args]
+ * @returns {void}
+ */
+assert.throws = function throws(promiseFn, ...args) {
+  expectsError(throws, getActual(promiseFn), ...args);
+};
+
+/**
+ * Expects `promiseFn` function or its value to reject.
+ * @param {() => Promise<any>} promiseFn
+ * @param {...any} [args]
+ * @returns {Promise<void>}
+ */
+assert.rejects = async function rejects(promiseFn, ...args) {
+  expectsError(rejects, await waitForActual(promiseFn), ...args);
+};
+
+/**
+ * Asserts that the function `fn` does not throw an error.
+ * @param {() => any} fn
+ * @param {...any} [args]
+ * @returns {void}
+ */
+assert.doesNotThrow = function doesNotThrow(fn, ...args) {
+  expectsNoError(doesNotThrow, getActual(fn), ...args);
+};
+
+/**
+ * Expects `fn` or its value to not reject.
+ * @param {() => Promise<any>} fn
+ * @param {...any} [args]
+ * @returns {Promise<void>}
+ */
+assert.doesNotReject = async function doesNotReject(fn, ...args) {
+  expectsNoError(doesNotReject, await waitForActual(fn), ...args);
+};
+
+/**
+ * Throws `AssertionError` if the value is not `null` or `undefined`.
+ * @param {any} err
+ * @returns {void}
+ */
+assert.ifError = function ifError(err) {
+  if (err !== null && err !== undefined) {
+    let message = 'ifError got unwanted exception: ';
+    if (typeof err === 'object' && typeof err.message === 'string') {
+      if (err.message.length === 0 && err.constructor) {
+        message += err.constructor.name;
+      } else {
+        message += err.message;
+      }
+    } else {
+      message += inspect(err);
+    }
+
+    const newErr = new AssertionError({
+      actual: err,
+      expected: null,
+      operator: 'ifError',
+      message,
+      stackStartFn: ifError,
+    });
+
+    // Make sure we actually have a stack trace!
+    const origStack = err.stack;
+
+    if (typeof origStack === 'string') {
+      // This will remove any duplicated frames from the error frames taken
+      // from within `ifError` and add the original error frames to the newly
+      // created ones.
+      const origStackStart = StringPrototypeIndexOf(origStack, '\n    at');
+      if (origStackStart !== -1) {
+        const originalFrames = StringPrototypeSplit(
+          StringPrototypeSlice(origStack, origStackStart + 1),
+          '\n',
+        );
+        // Filter all frames existing in err.stack.
+        let newFrames = StringPrototypeSplit(newErr.stack, '\n');
+        for (const errFrame of originalFrames) {
+          // Find the first occurrence of the frame.
+          const pos = ArrayPrototypeIndexOf(newFrames, errFrame);
+          if (pos !== -1) {
+            // Only keep new frames.
+            newFrames = ArrayPrototypeSlice(newFrames, 0, pos);
+            break;
+          }
+        }
+        const stackStart = ArrayPrototypeJoin(newFrames, '\n');
+        const stackEnd = ArrayPrototypeJoin(originalFrames, '\n');
+        newErr.stack = `${stackStart}\n${stackEnd}`;
+      }
+    }
+
+    throw newErr;
+  }
+};
+
+function internalMatch(string, regexp, message, fn) {
+  if (!isRegExp(regexp)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'regexp', 'RegExp', regexp,
+    );
+  }
+  const match = fn === assert.match;
+  if (typeof string !== 'string' ||
+      RegExpPrototypeExec(regexp, string) !== null !== match) {
+    if (message instanceof Error) {
+      throw message;
+    }
+
+    const generatedMessage = !message;
+
+    // 'The input was expected to not match the regular expression ' +
+    message ||= (typeof string !== 'string' ?
+      'The "string" argument must be of type string. Received type ' +
+        `${typeof string} (${inspect(string)})` :
+      (match ?
+        'The input did not match the regular expression ' :
+        'The input was expected to not match the regular expression ') +
+          `${inspect(regexp)}. Input:\n\n${inspect(string)}\n`);
+    const err = new AssertionError({
+      actual: string,
+      expected: regexp,
+      message,
+      operator: fn.name,
+      stackStartFn: fn,
+    });
+    err.generatedMessage = generatedMessage;
+    throw err;
+  }
+}
+
+/**
+ * Expects the `string` input to match the regular expression.
+ * @param {string} string
+ * @param {RegExp} regexp
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.match = function match(string, regexp, message) {
+  internalMatch(string, regexp, message, match);
+};
+
+/**
+ * Expects the `string` input not to match the regular expression.
+ * @param {string} string
+ * @param {RegExp} regexp
+ * @param {string | Error} [message]
+ * @returns {void}
+ */
+assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
+  internalMatch(string, regexp, message, doesNotMatch);
+};
+
+assert.CallTracker = deprecate(CallTracker, 'assert.CallTracker is deprecated.', 'DEP0173');
+
+/**
+ * Expose a strict only variant of assert.
+ * @param {...any} args
+ * @returns {void}
+ */
+function strict(...args) {
+  innerOk(strict, args.length, ...args);
+}
+
+assert.strict = ObjectAssign(strict, assert, {
+  equal: assert.strictEqual,
+  deepEqual: assert.deepStrictEqual,
+  notEqual: assert.notStrictEqual,
+  notDeepEqual: assert.notDeepStrictEqual,
+});
+
+assert.strict.strict = assert.strict;
\ No newline at end of file
diff --git a/.codesandbox/node/async_hooks.js b/.codesandbox/node/async_hooks.js
new file mode 100644
index 0000000000..8c57bc67fe
--- /dev/null
+++ b/.codesandbox/node/async_hooks.js
@@ -0,0 +1,296 @@
+'use strict';
+
+const {
+  ArrayPrototypeIncludes,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  FunctionPrototypeBind,
+  NumberIsSafeInteger,
+  ObjectDefineProperties,
+  ObjectFreeze,
+  ReflectApply,
+  Symbol,
+} = primordials;
+
+const {
+  ERR_ASYNC_CALLBACK,
+  ERR_ASYNC_TYPE,
+  ERR_INVALID_ASYNC_ID,
+} = require('internal/errors').codes;
+const {
+  deprecate,
+  kEmptyObject,
+} = require('internal/util');
+const {
+  validateFunction,
+  validateString,
+} = require('internal/validators');
+const internal_async_hooks = require('internal/async_hooks');
+
+const AsyncContextFrame = require('internal/async_context_frame');
+
+// Get functions
+// For userland AsyncResources, make sure to emit a destroy event when the
+// resource gets gced.
+const { registerDestroyHook, kNoPromiseHook } = internal_async_hooks;
+const {
+  asyncWrap,
+  executionAsyncId,
+  triggerAsyncId,
+  // Private API
+  hasAsyncIdStack,
+  getHookArrays,
+  enableHooks,
+  disableHooks,
+  updatePromiseHookMode,
+  executionAsyncResource,
+  // Internal Embedder API
+  newAsyncId,
+  getDefaultTriggerAsyncId,
+  emitInit,
+  emitBefore,
+  emitAfter,
+  emitDestroy,
+  enabledHooksExist,
+  initHooksExist,
+  destroyHooksExist,
+} = internal_async_hooks;
+
+// Get symbols
+const {
+  async_id_symbol, trigger_async_id_symbol,
+  init_symbol, before_symbol, after_symbol, destroy_symbol,
+  promise_resolve_symbol,
+} = internal_async_hooks.symbols;
+
+// Get constants
+const {
+  kInit, kBefore, kAfter, kDestroy, kTotals, kPromiseResolve,
+} = internal_async_hooks.constants;
+
+// Listener API //
+
+class AsyncHook {
+  constructor({ init, before, after, destroy, promiseResolve }) {
+    if (init !== undefined && typeof init !== 'function')
+      throw new ERR_ASYNC_CALLBACK('hook.init');
+    if (before !== undefined && typeof before !== 'function')
+      throw new ERR_ASYNC_CALLBACK('hook.before');
+    if (after !== undefined && typeof after !== 'function')
+      throw new ERR_ASYNC_CALLBACK('hook.after');
+    if (destroy !== undefined && typeof destroy !== 'function')
+      throw new ERR_ASYNC_CALLBACK('hook.destroy');
+    if (promiseResolve !== undefined && typeof promiseResolve !== 'function')
+      throw new ERR_ASYNC_CALLBACK('hook.promiseResolve');
+
+    this[init_symbol] = init;
+    this[before_symbol] = before;
+    this[after_symbol] = after;
+    this[destroy_symbol] = destroy;
+    this[promise_resolve_symbol] = promiseResolve;
+    this[kNoPromiseHook] = false;
+  }
+
+  enable() {
+    // The set of callbacks for a hook should be the same regardless of whether
+    // enable()/disable() are run during their execution. The following
+    // references are reassigned to the tmp arrays if a hook is currently being
+    // processed.
+    const { 0: hooks_array, 1: hook_fields } = getHookArrays();
+
+    // Each hook is only allowed to be added once.
+    if (ArrayPrototypeIncludes(hooks_array, this))
+      return this;
+
+    const prev_kTotals = hook_fields[kTotals];
+
+    // createHook() has already enforced that the callbacks are all functions,
+    // so here simply increment the count of whether each callbacks exists or
+    // not.
+    hook_fields[kTotals] = hook_fields[kInit] += +!!this[init_symbol];
+    hook_fields[kTotals] += hook_fields[kBefore] += +!!this[before_symbol];
+    hook_fields[kTotals] += hook_fields[kAfter] += +!!this[after_symbol];
+    hook_fields[kTotals] += hook_fields[kDestroy] += +!!this[destroy_symbol];
+    hook_fields[kTotals] +=
+        hook_fields[kPromiseResolve] += +!!this[promise_resolve_symbol];
+    ArrayPrototypePush(hooks_array, this);
+
+    if (prev_kTotals === 0 && hook_fields[kTotals] > 0) {
+      enableHooks();
+    }
+
+    if (!this[kNoPromiseHook]) {
+      updatePromiseHookMode();
+    }
+
+    return this;
+  }
+
+  disable() {
+    const { 0: hooks_array, 1: hook_fields } = getHookArrays();
+
+    const index = ArrayPrototypeIndexOf(hooks_array, this);
+    if (index === -1)
+      return this;
+
+    const prev_kTotals = hook_fields[kTotals];
+
+    hook_fields[kTotals] = hook_fields[kInit] -= +!!this[init_symbol];
+    hook_fields[kTotals] += hook_fields[kBefore] -= +!!this[before_symbol];
+    hook_fields[kTotals] += hook_fields[kAfter] -= +!!this[after_symbol];
+    hook_fields[kTotals] += hook_fields[kDestroy] -= +!!this[destroy_symbol];
+    hook_fields[kTotals] +=
+        hook_fields[kPromiseResolve] -= +!!this[promise_resolve_symbol];
+    ArrayPrototypeSplice(hooks_array, index, 1);
+
+    if (prev_kTotals > 0 && hook_fields[kTotals] === 0) {
+      disableHooks();
+    }
+
+    return this;
+  }
+}
+
+
+function createHook(fns) {
+  return new AsyncHook(fns);
+}
+
+
+// Embedder API //
+
+const destroyedSymbol = Symbol('destroyed');
+const contextFrameSymbol = Symbol('context_frame');
+
+class AsyncResource {
+  constructor(type, opts = kEmptyObject) {
+    validateString(type, 'type');
+
+    let triggerAsyncId = opts;
+    let requireManualDestroy = false;
+    if (typeof opts !== 'number') {
+      triggerAsyncId = opts.triggerAsyncId === undefined ?
+        getDefaultTriggerAsyncId() : opts.triggerAsyncId;
+      requireManualDestroy = !!opts.requireManualDestroy;
+    }
+
+    // Unlike emitInitScript, AsyncResource doesn't supports null as the
+    // triggerAsyncId.
+    if (!NumberIsSafeInteger(triggerAsyncId) || triggerAsyncId < -1) {
+      throw new ERR_INVALID_ASYNC_ID('triggerAsyncId', triggerAsyncId);
+    }
+
+    this[contextFrameSymbol] = AsyncContextFrame.current();
+
+    const asyncId = newAsyncId();
+    this[async_id_symbol] = asyncId;
+    this[trigger_async_id_symbol] = triggerAsyncId;
+
+    if (initHooksExist()) {
+      if (enabledHooksExist() && type.length === 0) {
+        throw new ERR_ASYNC_TYPE(type);
+      }
+
+      emitInit(asyncId, type, triggerAsyncId, this);
+    }
+
+    if (!requireManualDestroy && destroyHooksExist()) {
+      // This prop name (destroyed) has to be synchronized with C++
+      const destroyed = { destroyed: false };
+      this[destroyedSymbol] = destroyed;
+      registerDestroyHook(this, asyncId, destroyed);
+    }
+  }
+
+  runInAsyncScope(fn, thisArg, ...args) {
+    const asyncId = this[async_id_symbol];
+    emitBefore(asyncId, this[trigger_async_id_symbol], this);
+
+    const contextFrame = this[contextFrameSymbol];
+    const prior = AsyncContextFrame.exchange(contextFrame);
+    try {
+      return ReflectApply(fn, thisArg, args);
+    } finally {
+      AsyncContextFrame.set(prior);
+      if (hasAsyncIdStack())
+        emitAfter(asyncId);
+    }
+  }
+
+  emitDestroy() {
+    if (this[destroyedSymbol] !== undefined) {
+      this[destroyedSymbol].destroyed = true;
+    }
+    emitDestroy(this[async_id_symbol]);
+    return this;
+  }
+
+  asyncId() {
+    return this[async_id_symbol];
+  }
+
+  triggerAsyncId() {
+    return this[trigger_async_id_symbol];
+  }
+
+  bind(fn, thisArg) {
+    validateFunction(fn, 'fn');
+    let bound;
+    if (thisArg === undefined) {
+      const resource = this;
+      bound = function(...args) {
+        ArrayPrototypeUnshift(args, fn, this);
+        return ReflectApply(resource.runInAsyncScope, resource, args);
+      };
+    } else {
+      bound = FunctionPrototypeBind(this.runInAsyncScope, this, fn, thisArg);
+    }
+    let self = this;
+    ObjectDefineProperties(bound, {
+      'length': {
+        __proto__: null,
+        configurable: true,
+        enumerable: false,
+        value: fn.length,
+        writable: false,
+      },
+      'asyncResource': {
+        __proto__: null,
+        configurable: true,
+        enumerable: true,
+        get: deprecate(function() {
+          return self;
+        }, 'The asyncResource property on bound functions is deprecated', 'DEP0172'),
+        set: deprecate(function(val) {
+          self = val;
+        }, 'The asyncResource property on bound functions is deprecated', 'DEP0172'),
+      },
+    });
+    return bound;
+  }
+
+  static bind(fn, type, thisArg) {
+    type ||= fn.name;
+    return (new AsyncResource(type || 'bound-anonymous-fn')).bind(fn, thisArg);
+  }
+}
+
+// Placing all exports down here because the exported classes won't export
+// otherwise.
+module.exports = {
+  // Public API
+  get AsyncLocalStorage() {
+    return AsyncContextFrame.enabled ?
+      require('internal/async_local_storage/async_context_frame') :
+      require('internal/async_local_storage/async_hooks');
+  },
+  createHook,
+  executionAsyncId,
+  triggerAsyncId,
+  executionAsyncResource,
+  asyncWrapProviders: ObjectFreeze({ __proto__: null, ...asyncWrap.Providers }),
+  // Embedder API
+  AsyncResource,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/buffer.js b/.codesandbox/node/buffer.js
new file mode 100644
index 0000000000..06bfebc7e1
--- /dev/null
+++ b/.codesandbox/node/buffer.js
@@ -0,0 +1,1365 @@
+'use strict';
+
+const {
+  Array,
+  ArrayBufferIsView,
+  ArrayIsArray,
+  ArrayPrototypeForEach,
+  MathFloor,
+  MathMin,
+  MathTrunc,
+  NumberIsInteger,
+  NumberIsNaN,
+  NumberMAX_SAFE_INTEGER,
+  NumberMIN_SAFE_INTEGER,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectPrototypeHasOwnProperty,
+  ObjectSetPrototypeOf,
+  RegExpPrototypeSymbolReplace,
+  StringPrototypeCharCodeAt,
+  StringPrototypeSlice,
+  StringPrototypeToLowerCase,
+  StringPrototypeTrim,
+  SymbolSpecies,
+  SymbolToPrimitive,
+  TypedArrayPrototypeFill,
+  TypedArrayPrototypeGetBuffer,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeGetByteOffset,
+  TypedArrayPrototypeGetLength,
+  TypedArrayPrototypeSet,
+  TypedArrayPrototypeSlice,
+  Uint8Array,
+  Uint8ArrayPrototype,
+} = primordials;
+
+const {
+  byteLengthUtf8,
+  compare: _compare,
+  compareOffset,
+  copy: _copy,
+  fill: bindingFill,
+  isAscii: bindingIsAscii,
+  isUtf8: bindingIsUtf8,
+  indexOfBuffer,
+  indexOfNumber,
+  indexOfString,
+  swap16: _swap16,
+  swap32: _swap32,
+  swap64: _swap64,
+  kMaxLength,
+  kStringMaxLength,
+  atob: _atob,
+  btoa: _btoa,
+} = internalBinding('buffer');
+const {
+  constants: {
+    ALL_PROPERTIES,
+    ONLY_ENUMERABLE,
+  },
+  getOwnNonIndexProperties,
+  isInsideNodeModules,
+} = internalBinding('util');
+const {
+  customInspectSymbol,
+  lazyDOMException,
+  normalizeEncoding,
+  kIsEncodingSymbol,
+  defineLazyProperties,
+  encodingsMap,
+  deprecate,
+} = require('internal/util');
+const {
+  isAnyArrayBuffer,
+  isArrayBufferView,
+  isUint8Array,
+  isTypedArray,
+} = require('internal/util/types');
+const {
+  inspect: utilInspect,
+} = require('internal/util/inspect');
+
+const {
+  codes: {
+    ERR_BUFFER_OUT_OF_BOUNDS,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_BUFFER_SIZE,
+    ERR_MISSING_ARGS,
+    ERR_OUT_OF_RANGE,
+    ERR_UNKNOWN_ENCODING,
+  },
+  genericNodeError,
+} = require('internal/errors');
+const {
+  validateArray,
+  validateBuffer,
+  validateInteger,
+  validateNumber,
+  validateString,
+} = require('internal/validators');
+// Provide validateInteger() but with kMaxLength as the default maximum value.
+const validateOffset = (value, name, min = 0, max = kMaxLength) =>
+  validateInteger(value, name, min, max);
+
+const {
+  FastBuffer,
+  markAsUntransferable,
+  addBufferPrototypeMethods,
+  createUnsafeBuffer,
+} = require('internal/buffer');
+
+FastBuffer.prototype.constructor = Buffer;
+Buffer.prototype = FastBuffer.prototype;
+addBufferPrototypeMethods(Buffer.prototype);
+
+const constants = ObjectDefineProperties({}, {
+  MAX_LENGTH: {
+    __proto__: null,
+    value: kMaxLength,
+    writable: false,
+    enumerable: true,
+  },
+  MAX_STRING_LENGTH: {
+    __proto__: null,
+    value: kStringMaxLength,
+    writable: false,
+    enumerable: true,
+  },
+});
+
+Buffer.poolSize = 8 * 1024;
+let poolSize, poolOffset, allocPool, allocBuffer;
+
+function createPool() {
+  poolSize = Buffer.poolSize;
+  allocBuffer = createUnsafeBuffer(poolSize);
+  allocPool = allocBuffer.buffer;
+  markAsUntransferable(allocPool);
+  poolOffset = 0;
+}
+createPool();
+
+function alignPool() {
+  // Ensure aligned slices
+  if (poolOffset & 0x7) {
+    poolOffset |= 0x7;
+    poolOffset++;
+  }
+}
+
+let bufferWarningAlreadyEmitted = false;
+let nodeModulesCheckCounter = 0;
+const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
+                      'issues. Please use the Buffer.alloc(), ' +
+                      'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+
+function showFlaggedDeprecation() {
+  if (bufferWarningAlreadyEmitted ||
+      ++nodeModulesCheckCounter > 10000 ||
+      (!require('internal/options').getOptionValue('--pending-deprecation') &&
+       isInsideNodeModules(100, true))) {
+    // We don't emit a warning, because we either:
+    // - Already did so, or
+    // - Already checked too many times whether a call is coming
+    //   from node_modules and want to stop slowing down things, or
+    // - We aren't running with `--pending-deprecation` enabled,
+    //   and the code is inside `node_modules`.
+    // - We found node_modules in up to the topmost 100 frames, or
+    //   there are more than 100 frames and we don't want to search anymore.
+    return;
+  }
+
+  process.emitWarning(bufferWarning, 'DeprecationWarning', 'DEP0005');
+  bufferWarningAlreadyEmitted = true;
+}
+
+function toInteger(n, defaultVal) {
+  n = +n;
+  if (!NumberIsNaN(n) &&
+      n >= NumberMIN_SAFE_INTEGER &&
+      n <= NumberMAX_SAFE_INTEGER) {
+    return ((n % 1) === 0 ? n : MathFloor(n));
+  }
+  return defaultVal;
+}
+
+function copyImpl(source, target, targetStart, sourceStart, sourceEnd) {
+  if (!ArrayBufferIsView(source))
+    throw new ERR_INVALID_ARG_TYPE('source', ['Buffer', 'Uint8Array'], source);
+  if (!ArrayBufferIsView(target))
+    throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+
+  if (targetStart === undefined) {
+    targetStart = 0;
+  } else {
+    targetStart = NumberIsInteger(targetStart) ? targetStart : toInteger(targetStart, 0);
+    if (targetStart < 0)
+      throw new ERR_OUT_OF_RANGE('targetStart', '>= 0', targetStart);
+  }
+
+  if (sourceStart === undefined) {
+    sourceStart = 0;
+  } else {
+    sourceStart = NumberIsInteger(sourceStart) ? sourceStart : toInteger(sourceStart, 0);
+    if (sourceStart < 0 || sourceStart > source.byteLength)
+      throw new ERR_OUT_OF_RANGE('sourceStart', `>= 0 && <= ${source.byteLength}`, sourceStart);
+  }
+
+  if (sourceEnd === undefined) {
+    sourceEnd = source.byteLength;
+  } else {
+    sourceEnd = NumberIsInteger(sourceEnd) ? sourceEnd : toInteger(sourceEnd, 0);
+    if (sourceEnd < 0)
+      throw new ERR_OUT_OF_RANGE('sourceEnd', '>= 0', sourceEnd);
+  }
+
+  if (targetStart >= target.byteLength || sourceStart >= sourceEnd)
+    return 0;
+
+  return _copyActual(source, target, targetStart, sourceStart, sourceEnd);
+}
+
+function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {
+  if (sourceEnd - sourceStart > target.byteLength - targetStart)
+    sourceEnd = sourceStart + target.byteLength - targetStart;
+
+  let nb = sourceEnd - sourceStart;
+  const sourceLen = source.byteLength - sourceStart;
+  if (nb > sourceLen)
+    nb = sourceLen;
+
+  if (nb <= 0)
+    return 0;
+
+  _copy(source, target, targetStart, sourceStart, nb);
+
+  return nb;
+}
+
+/**
+ * The Buffer() constructor is deprecated in documentation and should not be
+ * used moving forward. Rather, developers should use one of the three new
+ * factory APIs: Buffer.from(), Buffer.allocUnsafe() or Buffer.alloc() based on
+ * their specific needs. There is no runtime deprecation because of the extent
+ * to which the Buffer constructor is used in the ecosystem currently -- a
+ * runtime deprecation would introduce too much breakage at this time. It's not
+ * likely that the Buffer constructors would ever actually be removed.
+ * Deprecation Code: DEP0005
+ * @returns {Buffer}
+ */
+function Buffer(arg, encodingOrOffset, length) {
+  showFlaggedDeprecation();
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new ERR_INVALID_ARG_TYPE('string', 'string', arg);
+    }
+    return Buffer.alloc(arg);
+  }
+  return Buffer.from(arg, encodingOrOffset, length);
+}
+
+ObjectDefineProperty(Buffer, SymbolSpecies, {
+  __proto__: null,
+  enumerable: false,
+  configurable: true,
+  get() { return FastBuffer; },
+});
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ * @param {any} value
+ * @param {BufferEncoding|number} encodingOrOffset
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.from = function from(value, encodingOrOffset, length) {
+  if (typeof value === 'string')
+    return fromString(value, encodingOrOffset);
+
+  if (typeof value === 'object' && value !== null) {
+    if (isAnyArrayBuffer(value))
+      return fromArrayBuffer(value, encodingOrOffset, length);
+
+    const valueOf = value.valueOf && value.valueOf();
+    if (valueOf != null &&
+        valueOf !== value &&
+        (typeof valueOf === 'string' || typeof valueOf === 'object')) {
+      return from(valueOf, encodingOrOffset, length);
+    }
+
+    const b = fromObject(value);
+    if (b)
+      return b;
+
+    if (typeof value[SymbolToPrimitive] === 'function') {
+      const primitive = value[SymbolToPrimitive]('string');
+      if (typeof primitive === 'string') {
+        return fromString(primitive, encodingOrOffset);
+      }
+    }
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    'first argument',
+    ['string', 'Buffer', 'ArrayBuffer', 'Array', 'Array-like Object'],
+    value,
+  );
+};
+
+/**
+ * Creates the Buffer as a copy of the underlying ArrayBuffer of the view
+ * rather than the contents of the view.
+ * @param {TypedArray} view
+ * @param {number} [offset]
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
+  if (!isTypedArray(view)) {
+    throw new ERR_INVALID_ARG_TYPE('view', [ 'TypedArray' ], view);
+  }
+
+  const viewLength = TypedArrayPrototypeGetLength(view);
+  if (viewLength === 0) {
+    return Buffer.alloc(0);
+  }
+
+  if (offset !== undefined || length !== undefined) {
+    if (offset !== undefined) {
+      validateInteger(offset, 'offset', 0);
+      if (offset >= viewLength) return Buffer.alloc(0);
+    } else {
+      offset = 0;
+    }
+    let end;
+    if (length !== undefined) {
+      validateInteger(length, 'length', 0);
+      end = offset + length;
+    } else {
+      end = viewLength;
+    }
+
+    view = TypedArrayPrototypeSlice(view, offset, end);
+  }
+
+  return fromArrayLike(new Uint8Array(
+    TypedArrayPrototypeGetBuffer(view),
+    TypedArrayPrototypeGetByteOffset(view),
+    TypedArrayPrototypeGetByteLength(view)));
+};
+
+// Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
+// Buffer() constructor. Must use arrow function syntax to avoid automatically
+// adding a `prototype` property and making the function a constructor.
+//
+// Refs: https://tc39.github.io/ecma262/#sec-%typedarray%.of
+// Refs: https://esdiscuss.org/topic/isconstructor#content-11
+const of = (...items) => {
+  const newObj = createUnsafeBuffer(items.length);
+  for (let k = 0; k < items.length; k++)
+    newObj[k] = items[k];
+  return newObj;
+};
+Buffer.of = of;
+
+ObjectSetPrototypeOf(Buffer, Uint8Array);
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ * @returns {FastBuffer}
+ */
+Buffer.alloc = function alloc(size, fill, encoding) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  if (fill !== undefined && fill !== 0 && size > 0) {
+    const buf = createUnsafeBuffer(size);
+    return _fill(buf, fill, 0, buf.length, encoding);
+  }
+  return new FastBuffer(size);
+};
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer
+ * instance. If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @returns {FastBuffer}
+ */
+Buffer.allocUnsafe = function allocUnsafe(size) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  return allocate(size);
+};
+
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled
+ * Buffer instance that is not allocated off the pre-initialized pool.
+ * If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @param {number} size
+ * @returns {FastBuffer|undefined}
+ */
+Buffer.allocUnsafeSlow = function allocUnsafeSlow(size) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  return createUnsafeBuffer(size);
+};
+
+// If --zero-fill-buffers command line argument is set, a zero-filled
+// buffer is returned.
+function SlowBuffer(size) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  return createUnsafeBuffer(size);
+}
+
+ObjectSetPrototypeOf(SlowBuffer.prototype, Uint8ArrayPrototype);
+ObjectSetPrototypeOf(SlowBuffer, Uint8Array);
+
+function allocate(size) {
+  if (size <= 0) {
+    return new FastBuffer();
+  }
+  if (size < (Buffer.poolSize >>> 1)) {
+    if (size > (poolSize - poolOffset))
+      createPool();
+    const b = new FastBuffer(allocPool, poolOffset, size);
+    poolOffset += size;
+    alignPool();
+    return b;
+  }
+  return createUnsafeBuffer(size);
+}
+
+function fromStringFast(string, ops) {
+  const maxLength = Buffer.poolSize >>> 1;
+
+  let length = string.length; // Min length
+
+  if (length >= maxLength)
+    return createFromString(string, ops);
+
+  length *= 4; // Max length (4 bytes per character)
+
+  if (length >= maxLength)
+    length = ops.byteLength(string); // Actual length
+
+  if (length >= maxLength)
+    return createFromString(string, ops, length);
+
+  if (length > (poolSize - poolOffset))
+    createPool();
+
+  const actual = ops.write(allocBuffer, string, poolOffset, length);
+  const b = new FastBuffer(allocPool, poolOffset, actual);
+
+  poolOffset += actual;
+  alignPool();
+  return b;
+}
+
+function createFromString(string, ops, length = ops.byteLength(string)) {
+  const buf = Buffer.allocUnsafeSlow(length);
+  const actual = ops.write(buf, string, 0, length);
+  return actual < length ? new FastBuffer(buf.buffer, 0, actual) : buf;
+}
+
+function fromString(string, encoding) {
+  let ops;
+  if (!encoding || encoding === 'utf8' || typeof encoding !== 'string') {
+    ops = encodingOps.utf8;
+  } else {
+    ops = getEncodingOps(encoding);
+    if (ops === undefined)
+      throw new ERR_UNKNOWN_ENCODING(encoding);
+  }
+
+  return string.length === 0 ? new FastBuffer() : fromStringFast(string, ops);
+}
+
+function fromArrayBuffer(obj, byteOffset, length) {
+  // Convert byteOffset to integer
+  if (byteOffset === undefined) {
+    byteOffset = 0;
+  } else {
+    byteOffset = +byteOffset;
+    if (NumberIsNaN(byteOffset))
+      byteOffset = 0;
+  }
+
+  const maxLength = obj.byteLength - byteOffset;
+
+  if (maxLength < 0)
+    throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
+
+  if (length !== undefined) {
+    // Convert length to non-negative integer.
+    length = +length;
+    if (length > 0) {
+      if (length > maxLength)
+        throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
+    } else {
+      length = 0;
+    }
+  }
+
+  return new FastBuffer(obj, byteOffset, length);
+}
+
+function fromArrayLike(obj) {
+  if (obj.length <= 0)
+    return new FastBuffer();
+  if (obj.length < (Buffer.poolSize >>> 1)) {
+    if (obj.length > (poolSize - poolOffset))
+      createPool();
+    const b = new FastBuffer(allocPool, poolOffset, obj.length);
+    TypedArrayPrototypeSet(b, obj, 0);
+    poolOffset += obj.length;
+    alignPool();
+    return b;
+  }
+  return new FastBuffer(obj);
+}
+
+function fromObject(obj) {
+  if (obj.length !== undefined || isAnyArrayBuffer(obj.buffer)) {
+    if (typeof obj.length !== 'number') {
+      return new FastBuffer();
+    }
+    return fromArrayLike(obj);
+  }
+
+  if (obj.type === 'Buffer' && ArrayIsArray(obj.data)) {
+    return fromArrayLike(obj.data);
+  }
+}
+
+// Static methods
+
+Buffer.isBuffer = function isBuffer(b) {
+  return b instanceof Buffer;
+};
+
+Buffer.compare = function compare(buf1, buf2) {
+  if (!isUint8Array(buf1)) {
+    throw new ERR_INVALID_ARG_TYPE('buf1', ['Buffer', 'Uint8Array'], buf1);
+  }
+
+  if (!isUint8Array(buf2)) {
+    throw new ERR_INVALID_ARG_TYPE('buf2', ['Buffer', 'Uint8Array'], buf2);
+  }
+
+  if (buf1 === buf2) {
+    return 0;
+  }
+
+  return _compare(buf1, buf2);
+};
+
+Buffer.isEncoding = function isEncoding(encoding) {
+  return typeof encoding === 'string' && encoding.length !== 0 &&
+         normalizeEncoding(encoding) !== undefined;
+};
+Buffer[kIsEncodingSymbol] = Buffer.isEncoding;
+
+Buffer.concat = function concat(list, length) {
+  validateArray(list, 'list');
+
+  if (list.length === 0)
+    return new FastBuffer();
+
+  if (length === undefined) {
+    length = 0;
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].length) {
+        length += list[i].length;
+      }
+    }
+  } else {
+    validateOffset(length, 'length');
+  }
+
+  const buffer = Buffer.allocUnsafe(length);
+  let pos = 0;
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    if (!isUint8Array(buf)) {
+      // TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.
+      // Instead, find the proper error code for this.
+      throw new ERR_INVALID_ARG_TYPE(
+        `list[${i}]`, ['Buffer', 'Uint8Array'], list[i]);
+    }
+    pos += _copyActual(buf, buffer, pos, 0, buf.length);
+  }
+
+  // Note: `length` is always equal to `buffer.length` at this point
+  if (pos < length) {
+    // Zero-fill the remaining bytes if the specified `length` was more than
+    // the actual total length, i.e. if we have some remaining allocated bytes
+    // there were not initialized.
+    TypedArrayPrototypeFill(buffer, 0, pos, length);
+  }
+
+  return buffer;
+};
+
+function base64ByteLength(str, bytes) {
+  // Handle padding
+  if (StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+    bytes--;
+  if (bytes > 1 && StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+    bytes--;
+
+  // Base64 ratio: 3/4
+  return (bytes * 3) >>> 2;
+}
+
+const encodingOps = {
+  utf8: {
+    encoding: 'utf8',
+    encodingVal: encodingsMap.utf8,
+    byteLength: byteLengthUtf8,
+    write: (buf, string, offset, len) => buf.utf8Write(string, offset, len),
+    slice: (buf, start, end) => buf.utf8Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.utf8, dir),
+  },
+  ucs2: {
+    encoding: 'ucs2',
+    encodingVal: encodingsMap.utf16le,
+    byteLength: (string) => string.length * 2,
+    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+    slice: (buf, start, end) => buf.ucs2Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+  },
+  utf16le: {
+    encoding: 'utf16le',
+    encodingVal: encodingsMap.utf16le,
+    byteLength: (string) => string.length * 2,
+    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+    slice: (buf, start, end) => buf.ucs2Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+  },
+  latin1: {
+    encoding: 'latin1',
+    encodingVal: encodingsMap.latin1,
+    byteLength: (string) => string.length,
+    write: (buf, string, offset, len) => buf.latin1Write(string, offset, len),
+    slice: (buf, start, end) => buf.latin1Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir),
+  },
+  ascii: {
+    encoding: 'ascii',
+    encodingVal: encodingsMap.ascii,
+    byteLength: (string) => string.length,
+    write: (buf, string, offset, len) => buf.asciiWrite(string, offset, len),
+    slice: (buf, start, end) => buf.asciiSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.ascii),
+                    byteOffset,
+                    encodingsMap.ascii,
+                    dir),
+  },
+  base64: {
+    encoding: 'base64',
+    encodingVal: encodingsMap.base64,
+    byteLength: (string) => base64ByteLength(string, string.length),
+    write: (buf, string, offset, len) => buf.base64Write(string, offset, len),
+    slice: (buf, start, end) => buf.base64Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.base64),
+                    byteOffset,
+                    encodingsMap.base64,
+                    dir),
+  },
+  base64url: {
+    encoding: 'base64url',
+    encodingVal: encodingsMap.base64url,
+    byteLength: (string) => base64ByteLength(string, string.length),
+    write: (buf, string, offset, len) =>
+      buf.base64urlWrite(string, offset, len),
+    slice: (buf, start, end) => buf.base64urlSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.base64url),
+                    byteOffset,
+                    encodingsMap.base64url,
+                    dir),
+  },
+  hex: {
+    encoding: 'hex',
+    encodingVal: encodingsMap.hex,
+    byteLength: (string) => string.length >>> 1,
+    write: (buf, string, offset, len) => buf.hexWrite(string, offset, len),
+    slice: (buf, start, end) => buf.hexSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.hex),
+                    byteOffset,
+                    encodingsMap.hex,
+                    dir),
+  },
+};
+function getEncodingOps(encoding) {
+  encoding += '';
+  switch (encoding.length) {
+    case 4:
+      if (encoding === 'utf8') return encodingOps.utf8;
+      if (encoding === 'ucs2') return encodingOps.ucs2;
+      encoding = StringPrototypeToLowerCase(encoding);
+      if (encoding === 'utf8') return encodingOps.utf8;
+      if (encoding === 'ucs2') return encodingOps.ucs2;
+      break;
+    case 5:
+      if (encoding === 'utf-8') return encodingOps.utf8;
+      if (encoding === 'ascii') return encodingOps.ascii;
+      if (encoding === 'ucs-2') return encodingOps.ucs2;
+      encoding = StringPrototypeToLowerCase(encoding);
+      if (encoding === 'utf-8') return encodingOps.utf8;
+      if (encoding === 'ascii') return encodingOps.ascii;
+      if (encoding === 'ucs-2') return encodingOps.ucs2;
+      break;
+    case 7:
+      if (encoding === 'utf16le' ||
+          StringPrototypeToLowerCase(encoding) === 'utf16le')
+        return encodingOps.utf16le;
+      break;
+    case 8:
+      if (encoding === 'utf-16le' ||
+          StringPrototypeToLowerCase(encoding) === 'utf-16le')
+        return encodingOps.utf16le;
+      break;
+    case 6:
+      if (encoding === 'latin1' || encoding === 'binary')
+        return encodingOps.latin1;
+      if (encoding === 'base64') return encodingOps.base64;
+      encoding = StringPrototypeToLowerCase(encoding);
+      if (encoding === 'latin1' || encoding === 'binary')
+        return encodingOps.latin1;
+      if (encoding === 'base64') return encodingOps.base64;
+      break;
+    case 3:
+      if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
+        return encodingOps.hex;
+      break;
+    case 9:
+      if (encoding === 'base64url' ||
+          StringPrototypeToLowerCase(encoding) === 'base64url')
+        return encodingOps.base64url;
+      break;
+  }
+}
+
+function byteLength(string, encoding) {
+  if (typeof string !== 'string') {
+    if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {
+      return string.byteLength;
+    }
+
+    throw new ERR_INVALID_ARG_TYPE(
+      'string', ['string', 'Buffer', 'ArrayBuffer'], string,
+    );
+  }
+
+  const len = string.length;
+  if (len === 0)
+    return 0;
+
+  if (!encoding || encoding === 'utf8') {
+    return byteLengthUtf8(string);
+  }
+
+  if (encoding === 'ascii') {
+    return len;
+  }
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined) {
+    // TODO (ronag): Makes more sense to throw here.
+    // throw new ERR_UNKNOWN_ENCODING(encoding);
+    return byteLengthUtf8(string);
+  }
+
+  return ops.byteLength(string);
+}
+
+Buffer.byteLength = byteLength;
+
+// For backwards compatibility.
+ObjectDefineProperty(Buffer.prototype, 'parent', {
+  __proto__: null,
+  enumerable: true,
+  get() {
+    if (!(this instanceof Buffer))
+      return undefined;
+    return this.buffer;
+  },
+});
+ObjectDefineProperty(Buffer.prototype, 'offset', {
+  __proto__: null,
+  enumerable: true,
+  get() {
+    if (!(this instanceof Buffer))
+      return undefined;
+    return this.byteOffset;
+  },
+});
+
+Buffer.prototype.copy =
+  function copy(target, targetStart, sourceStart, sourceEnd) {
+    return copyImpl(this, target, targetStart, sourceStart, sourceEnd);
+  };
+
+// No need to verify that "buf.length <= MAX_UINT32" since it's a read-only
+// property of a typed array.
+// This behaves neither like String nor Uint8Array in that we set start/end
+// to their upper/lower bounds if the value passed is out of range.
+Buffer.prototype.toString = function toString(encoding, start, end) {
+  if (arguments.length === 0) {
+    return this.utf8Slice(0, this.length);
+  }
+
+  const len = this.length;
+
+  if (start <= 0)
+    start = 0;
+  else if (start >= len)
+    return '';
+  else
+    start = MathTrunc(start) || 0;
+
+  if (end === undefined || end > len)
+    end = len;
+  else
+    end = MathTrunc(end) || 0;
+
+  if (end <= start)
+    return '';
+
+  if (encoding === undefined)
+    return this.utf8Slice(start, end);
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined)
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+
+  return ops.slice(this, start, end);
+};
+
+Buffer.prototype.equals = function equals(otherBuffer) {
+  if (!isUint8Array(otherBuffer)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'otherBuffer', ['Buffer', 'Uint8Array'], otherBuffer);
+  }
+
+  if (this === otherBuffer)
+    return true;
+  const len = TypedArrayPrototypeGetByteLength(this);
+  if (len !== TypedArrayPrototypeGetByteLength(otherBuffer))
+    return false;
+
+  return len === 0 || _compare(this, otherBuffer) === 0;
+};
+
+let INSPECT_MAX_BYTES = 50;
+// Override how buffers are presented by util.inspect().
+Buffer.prototype[customInspectSymbol] = function inspect(recurseTimes, ctx) {
+  const max = INSPECT_MAX_BYTES;
+  const actualMax = MathMin(max, this.length);
+  const remaining = this.length - max;
+  let str = StringPrototypeTrim(RegExpPrototypeSymbolReplace(
+    /(.{2})/g, this.hexSlice(0, actualMax), '$1 '));
+  if (remaining > 0)
+    str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+  // Inspect special properties as well, if possible.
+  if (ctx) {
+    let extras = false;
+    const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+    const obj = { __proto__: null };
+    ArrayPrototypeForEach(getOwnNonIndexProperties(this, filter),
+                          (key) => {
+                            extras = true;
+                            obj[key] = this[key];
+                          });
+    if (extras) {
+      if (this.length !== 0)
+        str += ', ';
+      // '[Object: null prototype] {'.length === 26
+      // This is guarded with a test.
+      str += StringPrototypeSlice(utilInspect(obj, {
+        ...ctx,
+        breakLength: Infinity,
+        compact: true,
+      }), 27, -2);
+    }
+  }
+  let constructorName = 'Buffer';
+  try {
+    const { constructor } = this;
+    if (typeof constructor === 'function' && ObjectPrototypeHasOwnProperty(constructor, 'name')) {
+      constructorName = constructor.name;
+    }
+  } catch { /* Ignore error and use default name */ }
+  return `<${constructorName} ${str}>`;
+};
+Buffer.prototype.inspect = Buffer.prototype[customInspectSymbol];
+
+Buffer.prototype.compare = function compare(target,
+                                            targetStart,
+                                            targetEnd,
+                                            sourceStart,
+                                            sourceEnd) {
+  if (!isUint8Array(target)) {
+    throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+  }
+  if (arguments.length === 1)
+    return _compare(this, target);
+
+  if (targetStart === undefined)
+    targetStart = 0;
+  else
+    validateOffset(targetStart, 'targetStart');
+
+  if (targetEnd === undefined)
+    targetEnd = target.length;
+  else
+    validateOffset(targetEnd, 'targetEnd', 0, target.length);
+
+  if (sourceStart === undefined)
+    sourceStart = 0;
+  else
+    validateOffset(sourceStart, 'sourceStart');
+
+  if (sourceEnd === undefined)
+    sourceEnd = this.length;
+  else
+    validateOffset(sourceEnd, 'sourceEnd', 0, this.length);
+
+  if (sourceStart >= sourceEnd)
+    return (targetStart >= targetEnd ? 0 : -1);
+  if (targetStart >= targetEnd)
+    return 1;
+
+  return compareOffset(this, target, targetStart, sourceStart, targetEnd,
+                       sourceEnd);
+};
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant if val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+  validateBuffer(buffer);
+
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset;
+    byteOffset = undefined;
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff;
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000;
+  }
+  // Coerce to Number. Values like null and [] become 0.
+  byteOffset = +byteOffset;
+  // If the offset is undefined, "foo", {}, coerces to NaN, search whole buffer.
+  if (NumberIsNaN(byteOffset)) {
+    byteOffset = dir ? 0 : (buffer.length || buffer.byteLength);
+  }
+  dir = !!dir;  // Cast to bool.
+
+  if (typeof val === 'number')
+    return indexOfNumber(buffer, val >>> 0, byteOffset, dir);
+
+  let ops;
+  if (encoding === undefined)
+    ops = encodingOps.utf8;
+  else
+    ops = getEncodingOps(encoding);
+
+  if (typeof val === 'string') {
+    if (ops === undefined)
+      throw new ERR_UNKNOWN_ENCODING(encoding);
+    return ops.indexOf(buffer, val, byteOffset, dir);
+  }
+
+  if (isUint8Array(val)) {
+    const encodingVal =
+      (ops === undefined ? encodingsMap.utf8 : ops.encodingVal);
+    return indexOfBuffer(buffer, val, byteOffset, encodingVal, dir);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    'value', ['number', 'string', 'Buffer', 'Uint8Array'], val,
+  );
+}
+
+Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+};
+
+Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+};
+
+Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1;
+};
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill(value, offset, end, encoding) {
+  return _fill(this, value, offset, end, encoding);
+};
+
+function _fill(buf, value, offset, end, encoding) {
+  if (typeof value === 'string') {
+    if (offset === undefined || typeof offset === 'string') {
+      encoding = offset;
+      offset = 0;
+      end = buf.length;
+    } else if (typeof end === 'string') {
+      encoding = end;
+      end = buf.length;
+    }
+
+    const normalizedEncoding = normalizeEncoding(encoding);
+    if (normalizedEncoding === undefined) {
+      validateString(encoding, 'encoding');
+      throw new ERR_UNKNOWN_ENCODING(encoding);
+    }
+
+    if (value.length === 0) {
+      // If value === '' default to zero.
+      value = 0;
+    } else if (value.length === 1) {
+      // Fast path: If `value` fits into a single byte, use that numeric value.
+      if (normalizedEncoding === 'utf8') {
+        const code = StringPrototypeCharCodeAt(value, 0);
+        if (code < 128) {
+          value = code;
+        }
+      } else if (normalizedEncoding === 'latin1') {
+        value = StringPrototypeCharCodeAt(value, 0);
+      }
+    }
+  } else {
+    encoding = undefined;
+  }
+
+  if (offset === undefined) {
+    offset = 0;
+    end = buf.length;
+  } else {
+    validateOffset(offset, 'offset');
+    // Invalid ranges are not set to a default, so can range check early.
+    if (end === undefined) {
+      end = buf.length;
+    } else {
+      validateOffset(end, 'end', 0, buf.length);
+    }
+    if (offset >= end)
+      return buf;
+  }
+
+
+  if (typeof value === 'number') {
+    // OOB check
+    const byteLen = TypedArrayPrototypeGetByteLength(buf);
+    const fillLength = end - offset;
+    if (offset > end || fillLength + offset > byteLen)
+      throw new ERR_BUFFER_OUT_OF_BOUNDS();
+
+    TypedArrayPrototypeFill(buf, value, offset, end);
+  } else {
+    const res = bindingFill(buf, value, offset, end, encoding);
+    if (res < 0) {
+      if (res === -1)
+        throw new ERR_INVALID_ARG_VALUE('value', value);
+      throw new ERR_BUFFER_OUT_OF_BOUNDS();
+    }
+  }
+
+  return buf;
+}
+
+Buffer.prototype.write = function write(string, offset, length, encoding) {
+  // Buffer#write(string);
+  if (offset === undefined) {
+    return this.utf8Write(string, 0, this.length);
+  }
+  // Buffer#write(string, encoding)
+  if (length === undefined && typeof offset === 'string') {
+    encoding = offset;
+    length = this.length;
+    offset = 0;
+
+  // Buffer#write(string, offset[, length][, encoding])
+  } else {
+    validateOffset(offset, 'offset', 0, this.length);
+
+    const remaining = this.length - offset;
+
+    if (length === undefined) {
+      length = remaining;
+    } else if (typeof length === 'string') {
+      encoding = length;
+      length = remaining;
+    } else {
+      validateOffset(length, 'length', 0, this.length);
+      if (length > remaining)
+        length = remaining;
+    }
+  }
+
+  if (!encoding || encoding === 'utf8')
+    return this.utf8Write(string, offset, length);
+  if (encoding === 'ascii')
+    return this.asciiWrite(string, offset, length);
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined)
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+  return ops.write(this, string, offset, length);
+};
+
+Buffer.prototype.toJSON = function toJSON() {
+  if (this.length > 0) {
+    const data = new Array(this.length);
+    for (let i = 0; i < this.length; ++i)
+      data[i] = this[i];
+    return { type: 'Buffer', data };
+  }
+  return { type: 'Buffer', data: [] };
+};
+
+function adjustOffset(offset, length) {
+  // Use Math.trunc() to convert offset to an integer value that can be larger
+  // than an Int32. Hence, don't use offset | 0 or similar techniques.
+  offset = MathTrunc(offset);
+  if (offset === 0) {
+    return 0;
+  }
+  if (offset < 0) {
+    offset += length;
+    return offset > 0 ? offset : 0;
+  }
+  if (offset < length) {
+    return offset;
+  }
+  return NumberIsNaN(offset) ? 0 : length;
+}
+
+Buffer.prototype.subarray = function subarray(start, end) {
+  const srcLength = this.length;
+  start = adjustOffset(start, srcLength);
+  end = end !== undefined ? adjustOffset(end, srcLength) : srcLength;
+  const newLength = end > start ? end - start : 0;
+  return new FastBuffer(this.buffer, this.byteOffset + start, newLength);
+};
+
+Buffer.prototype.slice = function slice(start, end) {
+  return this.subarray(start, end);
+};
+
+function swap(b, n, m) {
+  const i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+}
+
+Buffer.prototype.swap16 = function swap16() {
+  // For Buffer.length < 128, it's generally faster to
+  // do the swap in javascript. For larger buffers,
+  // dropping down to the native code is faster.
+  const len = this.length;
+  if (len % 2 !== 0)
+    throw new ERR_INVALID_BUFFER_SIZE('16-bits');
+  if (len < 128) {
+    for (let i = 0; i < len; i += 2)
+      swap(this, i, i + 1);
+    return this;
+  }
+  return _swap16(this);
+};
+
+Buffer.prototype.swap32 = function swap32() {
+  // For Buffer.length < 192, it's generally faster to
+  // do the swap in javascript. For larger buffers,
+  // dropping down to the native code is faster.
+  const len = this.length;
+  if (len % 4 !== 0)
+    throw new ERR_INVALID_BUFFER_SIZE('32-bits');
+  if (len < 192) {
+    for (let i = 0; i < len; i += 4) {
+      swap(this, i, i + 3);
+      swap(this, i + 1, i + 2);
+    }
+    return this;
+  }
+  return _swap32(this);
+};
+
+Buffer.prototype.swap64 = function swap64() {
+  // For Buffer.length < 192, it's generally faster to
+  // do the swap in javascript. For larger buffers,
+  // dropping down to the native code is faster.
+  const len = this.length;
+  if (len % 8 !== 0)
+    throw new ERR_INVALID_BUFFER_SIZE('64-bits');
+  if (len < 192) {
+    for (let i = 0; i < len; i += 8) {
+      swap(this, i, i + 7);
+      swap(this, i + 1, i + 6);
+      swap(this, i + 2, i + 5);
+      swap(this, i + 3, i + 4);
+    }
+    return this;
+  }
+  return _swap64(this);
+};
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+
+let transcode;
+if (internalBinding('config').hasIntl) {
+  const {
+    icuErrName,
+    transcode: _transcode,
+  } = internalBinding('icu');
+
+  // Transcodes the Buffer from one encoding to another, returning a new
+  // Buffer instance.
+  transcode = function transcode(source, fromEncoding, toEncoding) {
+    if (!isUint8Array(source)) {
+      throw new ERR_INVALID_ARG_TYPE('source',
+                                     ['Buffer', 'Uint8Array'], source);
+    }
+    if (source.length === 0) return Buffer.alloc(0);
+
+    fromEncoding = normalizeEncoding(fromEncoding) || fromEncoding;
+    toEncoding = normalizeEncoding(toEncoding) || toEncoding;
+    const result = _transcode(source, fromEncoding, toEncoding);
+    if (typeof result !== 'number')
+      return result;
+
+    const code = icuErrName(result);
+    const err = genericNodeError(
+      `Unable to transcode Buffer [${code}]`,
+      { code: code, errno: result },
+    );
+    throw err;
+  };
+}
+
+function btoa(input) {
+  // The implementation here has not been performance optimized in any way and
+  // should not be.
+  // Refs: https://github.com/nodejs/node/pull/38433#issuecomment-828426932
+  if (arguments.length === 0) {
+    throw new ERR_MISSING_ARGS('input');
+  }
+  const result = _btoa(`${input}`);
+  if (result === -1) {
+    throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+  }
+  return result;
+}
+
+function atob(input) {
+  if (arguments.length === 0) {
+    throw new ERR_MISSING_ARGS('input');
+  }
+
+  const result = _atob(`${input}`);
+
+  switch (result) {
+    case -2: // Invalid character
+      throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+    case -1: // Single character remained
+      throw lazyDOMException(
+        'The string to be decoded is not correctly encoded.',
+        'InvalidCharacterError');
+    case -3: // Possible overflow
+      // TODO(@anonrig): Throw correct error in here.
+      throw lazyDOMException('The input causes overflow.', 'InvalidCharacterError');
+    default:
+      return result;
+  }
+}
+
+function isUtf8(input) {
+  if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+    return bindingIsUtf8(input);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+function isAscii(input) {
+  if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+    return bindingIsAscii(input);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+module.exports = {
+  Buffer,
+  SlowBuffer: deprecate(
+    SlowBuffer,
+    'SlowBuffer() is deprecated. Please use Buffer.allocUnsafeSlow()',
+    'DEP0030'),
+  transcode,
+  isUtf8,
+  isAscii,
+
+  // Legacy
+  kMaxLength,
+  kStringMaxLength,
+  btoa,
+  atob,
+};
+
+ObjectDefineProperties(module.exports, {
+  constants: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: constants,
+  },
+  INSPECT_MAX_BYTES: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() { return INSPECT_MAX_BYTES; },
+    set(val) {
+      validateNumber(val, 'INSPECT_MAX_BYTES', 0);
+      INSPECT_MAX_BYTES = val;
+    },
+  },
+});
+
+defineLazyProperties(
+  module.exports,
+  'internal/blob',
+  ['Blob', 'resolveObjectURL'],
+);
+defineLazyProperties(
+  module.exports,
+  'internal/file',
+  ['File'],
+);
\ No newline at end of file
diff --git a/.codesandbox/node/child_process.js b/.codesandbox/node/child_process.js
new file mode 100644
index 0000000000..f531ed5117
--- /dev/null
+++ b/.codesandbox/node/child_process.js
@@ -0,0 +1,1021 @@
+"use strict";
+
+const {
+  ArrayIsArray,
+  ArrayPrototypeFilter,
+  ArrayPrototypeIncludes,
+  ArrayPrototypeJoin,
+  ArrayPrototypeLastIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypePushApply,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSort,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  ObjectAssign,
+  ObjectDefineProperty,
+  ObjectPrototypeHasOwnProperty,
+  PromiseWithResolvers,
+  RegExpPrototypeExec,
+  SafeSet,
+  StringPrototypeIncludes,
+  StringPrototypeSlice,
+  StringPrototypeToUpperCase,
+  SymbolDispose,
+} = primordials;
+
+const {
+  assignFunctionName,
+  convertToValidSignal,
+  getSystemErrorName,
+  kEmptyObject,
+  promisify,
+} = require("internal/util");
+const { isArrayBufferView } = require("internal/util/types");
+let debug = require("internal/util/debuglog").debuglog(
+  "child_process",
+  (fn) => {
+    debug = fn;
+  }
+);
+const { Buffer } = require("buffer");
+const { Pipe, constants: PipeConstants } = internalBinding("pipe_wrap");
+
+const {
+  AbortError,
+  codes: {
+    ERR_CHILD_PROCESS_IPC_REQUIRED,
+    ERR_CHILD_PROCESS_STDIO_MAXBUFFER,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+  },
+  genericNodeError,
+} = require("internal/errors");
+const { clearTimeout, setTimeout } = require("timers");
+const { getValidatedPath } = require("internal/fs/utils");
+const {
+  validateAbortSignal,
+  validateArray,
+  validateBoolean,
+  validateFunction,
+  validateInteger,
+  validateInt32,
+  validateNumber,
+  validateObject,
+  validateString,
+} = require("internal/validators");
+const child_process = require("internal/child_process");
+const { getValidStdio, setupChannel, ChildProcess, stdioStringToArray } =
+  child_process;
+
+const MAX_BUFFER = 1024 * 1024;
+
+const permission = require("internal/process/permission");
+
+const isZOS = process.platform === "os390";
+let addAbortListener;
+
+/**
+ * Spawns a new Node.js process + fork.
+ * @param {string|URL} modulePath
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string | URL;
+ *   detached?: boolean;
+ *   env?: Record<string, string>;
+ *   execPath?: string;
+ *   execArgv?: string[];
+ *   gid?: number;
+ *   serialization?: string;
+ *   signal?: AbortSignal;
+ *   killSignal?: string | number;
+ *   silent?: boolean;
+ *   stdio?: Array | string;
+ *   uid?: number;
+ *   windowsVerbatimArguments?: boolean;
+ *   timeout?: number;
+ *   }} [options]
+ * @returns {ChildProcess}
+ */
+function fork(modulePath, args = [], options) {
+  modulePath = getValidatedPath(modulePath, "modulePath");
+
+  // Get options and args arguments.
+  let execArgv;
+
+  if (args == null) {
+    args = [];
+  } else if (typeof args === "object" && !ArrayIsArray(args)) {
+    options = args;
+    args = [];
+  } else {
+    validateArray(args, "args");
+  }
+
+  if (options != null) {
+    validateObject(options, "options");
+  }
+  options = { __proto__: null, ...options, shell: false };
+  options.execPath ||= process.execPath;
+  validateArgumentNullCheck(options.execPath, "options.execPath");
+
+  // Prepare arguments for fork:
+  execArgv = options.execArgv || process.execArgv;
+  validateArgumentsNullCheck(execArgv, "options.execArgv");
+
+  if (execArgv === process.execArgv && process._eval != null) {
+    const index = ArrayPrototypeLastIndexOf(execArgv, process._eval);
+    if (index > 0) {
+      // Remove the -e switch to avoid fork bombing ourselves.
+      execArgv = ArrayPrototypeSlice(execArgv);
+      ArrayPrototypeSplice(execArgv, index - 1, 2);
+    }
+  }
+
+  args = [...execArgv, modulePath, ...args];
+
+  if (typeof options.stdio === "string") {
+    options.stdio = stdioStringToArray(options.stdio, "ipc");
+  } else if (!ArrayIsArray(options.stdio)) {
+    // Use a separate fd=3 for the IPC channel. Inherit stdin, stdout,
+    // and stderr from the parent if silent isn't set.
+    options.stdio = stdioStringToArray(
+      options.silent ? "pipe" : "inherit",
+      "ipc"
+    );
+  } else if (!ArrayPrototypeIncludes(options.stdio, "ipc")) {
+    throw new ERR_CHILD_PROCESS_IPC_REQUIRED("options.stdio");
+  }
+
+  return spawn(options.execPath, args, options);
+}
+
+function _forkChild(fd, serializationMode) {
+  // set process.send()
+  const p = new Pipe(PipeConstants.IPC);
+  p.open(fd);
+  p.unref();
+  const control = setupChannel(process, p, serializationMode);
+  process.on("newListener", function onNewListener(name) {
+    if (name === "message" || name === "disconnect") control.refCounted();
+  });
+  process.on("removeListener", function onRemoveListener(name) {
+    if (name === "message" || name === "disconnect") control.unrefCounted();
+  });
+}
+
+function normalizeExecArgs(command, options, callback) {
+  validateString(command, "command");
+  validateArgumentNullCheck(command, "command");
+
+  if (typeof options === "function") {
+    callback = options;
+    options = undefined;
+  }
+
+  // Make a shallow copy so we don't clobber the user's options object.
+  options = { __proto__: null, ...options };
+  options.shell = typeof options.shell === "string" ? options.shell : true;
+
+  return {
+    file: command,
+    options: options,
+    callback: callback,
+  };
+}
+
+/**
+ * Spawns a shell executing the given command.
+ * @param {string} command
+ * @param {{
+ *   cmd?: string;
+ *   env?: Record<string, string>;
+ *   encoding?: string;
+ *   shell?: string;
+ *   signal?: AbortSignal;
+ *   timeout?: number;
+ *   maxBuffer?: number;
+ *   killSignal?: string | number;
+ *   uid?: number;
+ *   gid?: number;
+ *   windowsHide?: boolean;
+ *   }} [options]
+ * @param {(
+ *   error?: Error,
+ *   stdout?: string | Buffer,
+ *   stderr?: string | Buffer
+ *   ) => any} [callback]
+ * @returns {ChildProcess}
+ */
+function exec(command, options, callback) {
+  const opts = normalizeExecArgs(command, options, callback);
+  return module.exports.execFile(opts.file, opts.options, opts.callback);
+}
+
+const customPromiseExecFunction = (orig) => {
+  return assignFunctionName(orig.name, function (...args) {
+    const { promise, resolve, reject } = PromiseWithResolvers();
+
+    promise.child = orig(...args, (err, stdout, stderr) => {
+      if (err !== null) {
+        err.stdout = stdout;
+        err.stderr = stderr;
+        reject(err);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+
+    return promise;
+  });
+};
+
+ObjectDefineProperty(exec, promisify.custom, {
+  __proto__: null,
+  enumerable: false,
+  value: customPromiseExecFunction(exec),
+});
+
+function normalizeExecFileArgs(file, args, options, callback) {
+  if (ArrayIsArray(args)) {
+    args = ArrayPrototypeSlice(args);
+  } else if (args != null && typeof args === "object") {
+    callback = options;
+    options = args;
+    args = null;
+  } else if (typeof args === "function") {
+    callback = args;
+    options = null;
+    args = null;
+  }
+
+  args ??= [];
+
+  if (typeof options === "function") {
+    callback = options;
+  } else if (options != null) {
+    validateObject(options, "options");
+  }
+
+  options ??= kEmptyObject;
+
+  if (callback != null) {
+    validateFunction(callback, "callback");
+  }
+
+  // Validate argv0, if present.
+  if (options.argv0 != null) {
+    validateString(options.argv0, "options.argv0");
+    validateArgumentNullCheck(options.argv0, "options.argv0");
+  }
+
+  return { file, args, options, callback };
+}
+
+/**
+ * Spawns the specified file as a shell.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string | URL;
+ *   env?: Record<string, string>;
+ *   encoding?: string;
+ *   timeout?: number;
+ *   maxBuffer?: number;
+ *   killSignal?: string | number;
+ *   uid?: number;
+ *   gid?: number;
+ *   windowsHide?: boolean;
+ *   windowsVerbatimArguments?: boolean;
+ *   shell?: boolean | string;
+ *   signal?: AbortSignal;
+ *   }} [options]
+ * @param {(
+ *   error?: Error,
+ *   stdout?: string | Buffer,
+ *   stderr?: string | Buffer
+ *   ) => any} [callback]
+ * @returns {ChildProcess}
+ */
+function execFile(file, args, options, callback) {
+  ({ file, args, options, callback } = normalizeExecFileArgs(
+    file,
+    args,
+    options,
+    callback
+  ));
+
+  options = {
+    __proto__: null,
+    encoding: "utf8",
+    timeout: 0,
+    maxBuffer: MAX_BUFFER,
+    killSignal: "SIGTERM",
+    cwd: null,
+    env: null,
+    shell: false,
+    ...options,
+  };
+
+  // Validate the timeout, if present.
+  validateTimeout(options.timeout);
+
+  // Validate maxBuffer, if present.
+  validateMaxBuffer(options.maxBuffer);
+
+  options.killSignal = sanitizeKillSignal(options.killSignal);
+
+  const child = spawn(file, args, {
+    cwd: options.cwd,
+    env: options.env,
+    gid: options.gid,
+    shell: options.shell,
+    signal: options.signal,
+    uid: options.uid,
+    windowsHide: !!options.windowsHide,
+    windowsVerbatimArguments: !!options.windowsVerbatimArguments,
+  });
+
+  let encoding;
+  const _stdout = [];
+  const _stderr = [];
+  if (options.encoding !== "buffer" && Buffer.isEncoding(options.encoding)) {
+    encoding = options.encoding;
+  } else {
+    encoding = null;
+  }
+  let stdoutLen = 0;
+  let stderrLen = 0;
+  let killed = false;
+  let exited = false;
+  let timeoutId;
+
+  let ex = null;
+
+  let cmd = file;
+
+  function exithandler(code, signal) {
+    if (exited) return;
+    exited = true;
+
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+
+    if (!callback) return;
+
+    // merge chunks
+    let stdout;
+    let stderr;
+    if (encoding || child.stdout?.readableEncoding) {
+      stdout = ArrayPrototypeJoin(_stdout, "");
+    } else {
+      stdout = Buffer.concat(_stdout);
+    }
+    if (encoding || child.stderr?.readableEncoding) {
+      stderr = ArrayPrototypeJoin(_stderr, "");
+    } else {
+      stderr = Buffer.concat(_stderr);
+    }
+
+    if (!ex && code === 0 && signal === null) {
+      callback(null, stdout, stderr);
+      return;
+    }
+
+    if (args?.length) cmd += ` ${ArrayPrototypeJoin(args, " ")}`;
+
+    ex ||= genericNodeError(`Command failed: ${cmd}\n${stderr}`, {
+      code: code < 0 ? getSystemErrorName(code) : code,
+      killed: child.killed || killed,
+      signal: signal,
+    });
+
+    ex.cmd = cmd;
+    callback(ex, stdout, stderr);
+  }
+
+  function errorhandler(e) {
+    ex = e;
+
+    if (child.stdout) child.stdout.destroy();
+
+    if (child.stderr) child.stderr.destroy();
+
+    exithandler();
+  }
+
+  function kill() {
+    if (child.stdout) child.stdout.destroy();
+
+    if (child.stderr) child.stderr.destroy();
+
+    killed = true;
+    try {
+      child.kill(options.killSignal);
+    } catch (e) {
+      ex = e;
+      exithandler();
+    }
+  }
+
+  if (options.timeout > 0) {
+    timeoutId = setTimeout(function delayedKill() {
+      kill();
+      timeoutId = null;
+    }, options.timeout);
+  }
+
+  if (child.stdout) {
+    if (encoding) child.stdout.setEncoding(encoding);
+
+    child.stdout.on("data", function onChildStdout(chunk) {
+      // Do not need to count the length
+      if (options.maxBuffer === Infinity) {
+        ArrayPrototypePush(_stdout, chunk);
+        return;
+      }
+      const encoding = child.stdout.readableEncoding;
+      const length = encoding
+        ? Buffer.byteLength(chunk, encoding)
+        : chunk.length;
+      const slice = encoding
+        ? StringPrototypeSlice
+        : (buf, ...args) => buf.slice(...args);
+      stdoutLen += length;
+
+      if (stdoutLen > options.maxBuffer) {
+        const truncatedLen = options.maxBuffer - (stdoutLen - length);
+        ArrayPrototypePush(_stdout, slice(chunk, 0, truncatedLen));
+
+        ex = new ERR_CHILD_PROCESS_STDIO_MAXBUFFER("stdout");
+        kill();
+      } else {
+        ArrayPrototypePush(_stdout, chunk);
+      }
+    });
+  }
+
+  if (child.stderr) {
+    if (encoding) child.stderr.setEncoding(encoding);
+
+    child.stderr.on("data", function onChildStderr(chunk) {
+      // Do not need to count the length
+      if (options.maxBuffer === Infinity) {
+        ArrayPrototypePush(_stderr, chunk);
+        return;
+      }
+      const encoding = child.stderr.readableEncoding;
+      const length = encoding
+        ? Buffer.byteLength(chunk, encoding)
+        : chunk.length;
+      stderrLen += length;
+
+      if (stderrLen > options.maxBuffer) {
+        const truncatedLen = options.maxBuffer - (stderrLen - length);
+        ArrayPrototypePush(_stderr, chunk.slice(0, truncatedLen));
+
+        ex = new ERR_CHILD_PROCESS_STDIO_MAXBUFFER("stderr");
+        kill();
+      } else {
+        ArrayPrototypePush(_stderr, chunk);
+      }
+    });
+  }
+
+  child.addListener("close", exithandler);
+  child.addListener("error", errorhandler);
+
+  return child;
+}
+
+ObjectDefineProperty(execFile, promisify.custom, {
+  __proto__: null,
+  enumerable: false,
+  value: customPromiseExecFunction(execFile),
+});
+
+function copyProcessEnvToEnv(env, name, optionEnv) {
+  if (
+    process.env[name] &&
+    (!optionEnv || !ObjectPrototypeHasOwnProperty(optionEnv, name))
+  ) {
+    env[name] = process.env[name];
+  }
+}
+
+let permissionModelFlagsToCopy;
+
+function getPermissionModelFlagsToCopy() {
+  if (permissionModelFlagsToCopy === undefined) {
+    permissionModelFlagsToCopy = [
+      ...permission.availableFlags(),
+      "--permission",
+    ];
+  }
+  return permissionModelFlagsToCopy;
+}
+
+function copyPermissionModelFlagsToEnv(env, key, args) {
+  // Do not override if permission was already passed to file
+  if (
+    args.includes("--permission") ||
+    (env[key] && env[key].indexOf("--permission") !== -1)
+  ) {
+    return;
+  }
+
+  const flagsToCopy = getPermissionModelFlagsToCopy();
+  for (const arg of process.execArgv) {
+    for (const flag of flagsToCopy) {
+      if (arg.startsWith(flag)) {
+        env[key] = `${env[key] ? env[key] + " " + arg : arg}`;
+      }
+    }
+  }
+}
+
+let emittedDEP0190Already = false;
+function normalizeSpawnArguments(file, args, options) {
+  validateString(file, "file");
+  validateArgumentNullCheck(file, "file");
+
+  if (file.length === 0)
+    throw new ERR_INVALID_ARG_VALUE("file", file, "cannot be empty");
+
+  if (ArrayIsArray(args)) {
+    args = ArrayPrototypeSlice(args);
+  } else if (args == null) {
+    args = [];
+  } else if (typeof args !== "object") {
+    throw new ERR_INVALID_ARG_TYPE("args", "object", args);
+  } else {
+    options = args;
+    args = [];
+  }
+
+  validateArgumentsNullCheck(args, "args");
+
+  if (options === undefined) options = kEmptyObject;
+  else validateObject(options, "options");
+
+  options = { __proto__: null, ...options };
+  let cwd = options.cwd;
+
+  // Validate the cwd, if present.
+  if (cwd != null) {
+    cwd = getValidatedPath(cwd, "options.cwd");
+  }
+
+  // Validate detached, if present.
+  if (options.detached != null) {
+    validateBoolean(options.detached, "options.detached");
+  }
+
+  // Validate the uid, if present.
+  if (options.uid != null) {
+    validateInt32(options.uid, "options.uid");
+  }
+
+  // Validate the gid, if present.
+  if (options.gid != null) {
+    validateInt32(options.gid, "options.gid");
+  }
+
+  // Validate the shell, if present.
+  if (
+    options.shell != null &&
+    typeof options.shell !== "boolean" &&
+    typeof options.shell !== "string"
+  ) {
+    throw new ERR_INVALID_ARG_TYPE(
+      "options.shell",
+      ["boolean", "string"],
+      options.shell
+    );
+  }
+
+  // Validate argv0, if present.
+  if (options.argv0 != null) {
+    validateString(options.argv0, "options.argv0");
+    validateArgumentNullCheck(options.argv0, "options.argv0");
+  }
+
+  // Validate windowsHide, if present.
+  if (options.windowsHide != null) {
+    validateBoolean(options.windowsHide, "options.windowsHide");
+  }
+
+  // Validate windowsVerbatimArguments, if present.
+  let { windowsVerbatimArguments } = options;
+  if (windowsVerbatimArguments != null) {
+    validateBoolean(
+      windowsVerbatimArguments,
+      "options.windowsVerbatimArguments"
+    );
+  }
+
+  if (options.shell) {
+    validateArgumentNullCheck(options.shell, "options.shell");
+    if (args.length > 0 && !emittedDEP0190Already) {
+      process.emitWarning(
+        "Passing args to a child process with shell option true can lead to security " +
+          "vulnerabilities, as the arguments are not escaped, only concatenated.",
+        "DeprecationWarning",
+        "DEP0190"
+      );
+      emittedDEP0190Already = true;
+    }
+
+    const command =
+      args.length > 0 ? `${file} ${ArrayPrototypeJoin(args, " ")}` : file;
+    // Set the shell, switches, and commands.
+    if (process.platform === "win32") {
+      if (typeof options.shell === "string") file = options.shell;
+      else file = process.env.comspec || "cmd.exe";
+      // '/d /s /c' is used only for cmd.exe.
+      if (RegExpPrototypeExec(/^(?:.*\\)?cmd(?:\.exe)?$/i, file) !== null) {
+        args = ["/d", "/s", "/c", `"${command}"`];
+        windowsVerbatimArguments = true;
+      } else {
+        args = ["-c", command];
+      }
+    } else {
+      if (typeof options.shell === "string") file = options.shell;
+      else if (process.platform === "android") file = "/system/bin/sh";
+      else file = "/bin/sh";
+      args = ["-c", command];
+    }
+  }
+
+  if (typeof options.argv0 === "string") {
+    ArrayPrototypeUnshift(args, options.argv0);
+  } else {
+    ArrayPrototypeUnshift(args, file);
+  }
+
+  // Shallow copy to guarantee changes won't impact process.env
+  const env = options.env || { ...process.env };
+  const envPairs = [];
+
+  // process.env.NODE_V8_COVERAGE always propagates, making it possible to
+  // collect coverage for programs that spawn with white-listed environment.
+  copyProcessEnvToEnv(env, "NODE_V8_COVERAGE", options.env);
+
+  if (isZOS) {
+    // The following environment variables must always propagate if set.
+    copyProcessEnvToEnv(env, "_BPXK_AUTOCVT", options.env);
+    copyProcessEnvToEnv(env, "_CEE_RUNOPTS", options.env);
+    copyProcessEnvToEnv(env, "_TAG_REDIR_ERR", options.env);
+    copyProcessEnvToEnv(env, "_TAG_REDIR_IN", options.env);
+    copyProcessEnvToEnv(env, "_TAG_REDIR_OUT", options.env);
+    copyProcessEnvToEnv(env, "STEPLIB", options.env);
+    copyProcessEnvToEnv(env, "LIBPATH", options.env);
+    copyProcessEnvToEnv(env, "_EDC_SIG_DFLT", options.env);
+    copyProcessEnvToEnv(env, "_EDC_SUSV3", options.env);
+  }
+
+  if (permission.isEnabled()) {
+    copyPermissionModelFlagsToEnv(env, "NODE_OPTIONS", args);
+  }
+
+  let envKeys = [];
+  // Prototype values are intentionally included.
+  for (const key in env) {
+    ArrayPrototypePush(envKeys, key);
+  }
+
+  if (process.platform === "win32") {
+    // On Windows env keys are case insensitive. Filter out duplicates,
+    // keeping only the first one (in lexicographic order)
+    const sawKey = new SafeSet();
+    envKeys = ArrayPrototypeFilter(ArrayPrototypeSort(envKeys), (key) => {
+      const uppercaseKey = StringPrototypeToUpperCase(key);
+      if (sawKey.has(uppercaseKey)) {
+        return false;
+      }
+      sawKey.add(uppercaseKey);
+      return true;
+    });
+  }
+
+  for (const key of envKeys) {
+    const value = env[key];
+    if (value !== undefined) {
+      validateArgumentNullCheck(key, `options.env['${key}']`);
+      validateArgumentNullCheck(value, `options.env['${key}']`);
+      ArrayPrototypePush(envPairs, `${key}=${value}`);
+    }
+  }
+
+  return {
+    // Make a shallow copy so we don't clobber the user's options object.
+    __proto__: null,
+    ...options,
+    args,
+    cwd,
+    detached: !!options.detached,
+    envPairs,
+    file,
+    windowsHide: !!options.windowsHide,
+    windowsVerbatimArguments: !!windowsVerbatimArguments,
+  };
+}
+
+function abortChildProcess(child, killSignal, reason) {
+  if (!child) return;
+  try {
+    if (child.kill(killSignal)) {
+      child.emit("error", new AbortError(undefined, { cause: reason }));
+    }
+  } catch (err) {
+    child.emit("error", err);
+  }
+}
+
+/**
+ * Spawns a new process using the given `file`.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string | URL;
+ *   env?: Record<string, string>;
+ *   argv0?: string;
+ *   stdio?: Array | string;
+ *   detached?: boolean;
+ *   uid?: number;
+ *   gid?: number;
+ *   serialization?: string;
+ *   shell?: boolean | string;
+ *   windowsVerbatimArguments?: boolean;
+ *   windowsHide?: boolean;
+ *   signal?: AbortSignal;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   }} [options]
+ * @returns {ChildProcess}
+ */
+function spawn(file, args, options) {
+  options = normalizeSpawnArguments(file, args, options);
+  validateTimeout(options.timeout);
+  validateAbortSignal(options.signal, "options.signal");
+  const killSignal = sanitizeKillSignal(options.killSignal);
+  const child = new ChildProcess();
+
+  debug("spawn", options);
+  child.spawn(options);
+
+  if (options.timeout > 0) {
+    let timeoutId = setTimeout(() => {
+      if (timeoutId) {
+        try {
+          child.kill(killSignal);
+        } catch (err) {
+          child.emit("error", err);
+        }
+        timeoutId = null;
+      }
+    }, options.timeout);
+
+    child.once("exit", () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    });
+  }
+
+  if (options.signal) {
+    const signal = options.signal;
+    if (signal.aborted) {
+      process.nextTick(onAbortListener);
+    } else {
+      addAbortListener ??=
+        require("internal/events/abort_listener").addAbortListener;
+      const disposable = addAbortListener(signal, onAbortListener);
+      child.once("exit", disposable[SymbolDispose]);
+    }
+
+    function onAbortListener() {
+      abortChildProcess(child, killSignal, options.signal.reason);
+    }
+  }
+
+  return child;
+}
+
+/**
+ * Spawns a new process synchronously using the given `file`.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string | URL;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   argv0?: string;
+ *   stdio?: string | Array;
+ *   env?: Record<string, string>;
+ *   uid?: number;
+ *   gid?: number;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   maxBuffer?: number;
+ *   encoding?: string;
+ *   shell?: boolean | string;
+ *   windowsVerbatimArguments?: boolean;
+ *   windowsHide?: boolean;
+ *   }} [options]
+ * @returns {{
+ *   pid: number;
+ *   output: Array;
+ *   stdout: Buffer | string;
+ *   stderr: Buffer | string;
+ *   status: number | null;
+ *   signal: string | null;
+ *   error: Error;
+ *   }}
+ */
+function spawnSync(file, args, options) {
+  options = {
+    __proto__: null,
+    maxBuffer: MAX_BUFFER,
+    ...normalizeSpawnArguments(file, args, options),
+  };
+
+  debug("spawnSync", options);
+
+  // Validate the timeout, if present.
+  validateTimeout(options.timeout);
+
+  // Validate maxBuffer, if present.
+  validateMaxBuffer(options.maxBuffer);
+
+  // Validate and translate the kill signal, if present.
+  options.killSignal = sanitizeKillSignal(options.killSignal);
+
+  options.stdio = getValidStdio(options.stdio || "pipe", true).stdio;
+
+  if (options.input) {
+    const stdin = (options.stdio[0] = { ...options.stdio[0] });
+    stdin.input = options.input;
+  }
+
+  // We may want to pass data in on any given fd, ensure it is a valid buffer
+  for (let i = 0; i < options.stdio.length; i++) {
+    const input = options.stdio[i]?.input;
+    if (input != null) {
+      const pipe = (options.stdio[i] = { ...options.stdio[i] });
+      if (isArrayBufferView(input)) {
+        pipe.input = input;
+      } else if (typeof input === "string") {
+        pipe.input = Buffer.from(input, options.encoding);
+      } else {
+        throw new ERR_INVALID_ARG_TYPE(
+          `options.stdio[${i}]`,
+          ["Buffer", "TypedArray", "DataView", "string"],
+          input
+        );
+      }
+    }
+  }
+
+  return child_process.spawnSync(options);
+}
+
+function checkExecSyncError(ret, args, cmd) {
+  let err;
+  if (ret.error) {
+    err = ret.error;
+    ObjectAssign(err, ret);
+  } else if (ret.status !== 0) {
+    let msg = "Command failed: ";
+    msg += cmd || ArrayPrototypeJoin(args, " ");
+    if (ret.stderr && ret.stderr.length > 0)
+      msg += `\n${ret.stderr.toString()}`;
+    err = genericNodeError(msg, ret);
+  }
+  return err;
+}
+
+/**
+ * Spawns a file as a shell synchronously.
+ * @param {string} file
+ * @param {string[]} [args]
+ * @param {{
+ *   cwd?: string | URL;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   stdio?: string | Array;
+ *   env?: Record<string, string>;
+ *   uid?: number;
+ *   gid?: number;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   maxBuffer?: number;
+ *   encoding?: string;
+ *   windowsHide?: boolean;
+ *   shell?: boolean | string;
+ *   }} [options]
+ * @returns {Buffer | string}
+ */
+function execFileSync(file, args, options) {
+  ({ file, args, options } = normalizeExecFileArgs(file, args, options));
+
+  const inheritStderr = !options.stdio;
+  const ret = spawnSync(file, args, options);
+
+  if (inheritStderr && ret.stderr) process.stderr.write(ret.stderr);
+
+  const errArgs = [options.argv0 || file];
+  ArrayPrototypePushApply(errArgs, args);
+  const err = checkExecSyncError(ret, errArgs);
+
+  if (err) throw err;
+
+  return ret.stdout;
+}
+
+/**
+ * Spawns a shell executing the given `command` synchronously.
+ * @param {string} command
+ * @param {{
+ *   cwd?: string | URL;
+ *   input?: string | Buffer | TypedArray | DataView;
+ *   stdio?: string | Array;
+ *   env?: Record<string, string>;
+ *   shell?: string;
+ *   uid?: number;
+ *   gid?: number;
+ *   timeout?: number;
+ *   killSignal?: string | number;
+ *   maxBuffer?: number;
+ *   encoding?: string;
+ *   windowsHide?: boolean;
+ *   }} [options]
+ * @returns {Buffer | string}
+ */
+function execSync(command, options) {
+  const opts = normalizeExecArgs(command, options, null);
+  const inheritStderr = !opts.options.stdio;
+
+  const ret = spawnSync(opts.file, opts.options);
+
+  if (inheritStderr && ret.stderr) process.stderr.write(ret.stderr);
+
+  const err = checkExecSyncError(ret, undefined, command);
+
+  if (err) throw err;
+
+  return ret.stdout;
+}
+
+function validateArgumentNullCheck(arg, propName) {
+  if (typeof arg === "string" && StringPrototypeIncludes(arg, "\u0000")) {
+    throw new ERR_INVALID_ARG_VALUE(
+      propName,
+      arg,
+      "must be a string without null bytes"
+    );
+  }
+}
+
+function validateArgumentsNullCheck(args, propName) {
+  for (let i = 0; i < args.length; ++i) {
+    validateArgumentNullCheck(args[i], `${propName}[${i}]`);
+  }
+}
+
+function validateTimeout(timeout) {
+  if (timeout != null) {
+    validateInteger(timeout, "timeout", 0);
+  }
+}
+
+function validateMaxBuffer(maxBuffer) {
+  if (maxBuffer != null) {
+    validateNumber(maxBuffer, "options.maxBuffer", 0);
+  }
+}
+
+function sanitizeKillSignal(killSignal) {
+  if (typeof killSignal === "string" || typeof killSignal === "number") {
+    return convertToValidSignal(killSignal);
+  } else if (killSignal != null) {
+    throw new ERR_INVALID_ARG_TYPE(
+      "options.killSignal",
+      ["string", "number"],
+      killSignal
+    );
+  }
+}
+
+module.exports = {
+  _forkChild,
+  ChildProcess,
+  exec,
+  execFile,
+  execFileSync,
+  execSync,
+  fork,
+  spawn,
+  spawnSync,
+};
diff --git a/.codesandbox/node/cluster.js b/.codesandbox/node/cluster.js
new file mode 100644
index 0000000000..6f3dc16892
--- /dev/null
+++ b/.codesandbox/node/cluster.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const {
+  ObjectPrototypeHasOwnProperty: ObjectHasOwn,
+} = primordials;
+
+const childOrPrimary = ObjectHasOwn(process.env, 'NODE_UNIQUE_ID') ? 'child' : 'primary';
+module.exports = require(`internal/cluster/${childOrPrimary}`);
\ No newline at end of file
diff --git a/.codesandbox/node/console.js b/.codesandbox/node/console.js
new file mode 100644
index 0000000000..d896d2e320
--- /dev/null
+++ b/.codesandbox/node/console.js
@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("internal/console/global");
diff --git a/.codesandbox/node/crypto.js b/.codesandbox/node/crypto.js
new file mode 100644
index 0000000000..06bfebc7e1
--- /dev/null
+++ b/.codesandbox/node/crypto.js
@@ -0,0 +1,1365 @@
+'use strict';
+
+const {
+  Array,
+  ArrayBufferIsView,
+  ArrayIsArray,
+  ArrayPrototypeForEach,
+  MathFloor,
+  MathMin,
+  MathTrunc,
+  NumberIsInteger,
+  NumberIsNaN,
+  NumberMAX_SAFE_INTEGER,
+  NumberMIN_SAFE_INTEGER,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectPrototypeHasOwnProperty,
+  ObjectSetPrototypeOf,
+  RegExpPrototypeSymbolReplace,
+  StringPrototypeCharCodeAt,
+  StringPrototypeSlice,
+  StringPrototypeToLowerCase,
+  StringPrototypeTrim,
+  SymbolSpecies,
+  SymbolToPrimitive,
+  TypedArrayPrototypeFill,
+  TypedArrayPrototypeGetBuffer,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeGetByteOffset,
+  TypedArrayPrototypeGetLength,
+  TypedArrayPrototypeSet,
+  TypedArrayPrototypeSlice,
+  Uint8Array,
+  Uint8ArrayPrototype,
+} = primordials;
+
+const {
+  byteLengthUtf8,
+  compare: _compare,
+  compareOffset,
+  copy: _copy,
+  fill: bindingFill,
+  isAscii: bindingIsAscii,
+  isUtf8: bindingIsUtf8,
+  indexOfBuffer,
+  indexOfNumber,
+  indexOfString,
+  swap16: _swap16,
+  swap32: _swap32,
+  swap64: _swap64,
+  kMaxLength,
+  kStringMaxLength,
+  atob: _atob,
+  btoa: _btoa,
+} = internalBinding('buffer');
+const {
+  constants: {
+    ALL_PROPERTIES,
+    ONLY_ENUMERABLE,
+  },
+  getOwnNonIndexProperties,
+  isInsideNodeModules,
+} = internalBinding('util');
+const {
+  customInspectSymbol,
+  lazyDOMException,
+  normalizeEncoding,
+  kIsEncodingSymbol,
+  defineLazyProperties,
+  encodingsMap,
+  deprecate,
+} = require('internal/util');
+const {
+  isAnyArrayBuffer,
+  isArrayBufferView,
+  isUint8Array,
+  isTypedArray,
+} = require('internal/util/types');
+const {
+  inspect: utilInspect,
+} = require('internal/util/inspect');
+
+const {
+  codes: {
+    ERR_BUFFER_OUT_OF_BOUNDS,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_BUFFER_SIZE,
+    ERR_MISSING_ARGS,
+    ERR_OUT_OF_RANGE,
+    ERR_UNKNOWN_ENCODING,
+  },
+  genericNodeError,
+} = require('internal/errors');
+const {
+  validateArray,
+  validateBuffer,
+  validateInteger,
+  validateNumber,
+  validateString,
+} = require('internal/validators');
+// Provide validateInteger() but with kMaxLength as the default maximum value.
+const validateOffset = (value, name, min = 0, max = kMaxLength) =>
+  validateInteger(value, name, min, max);
+
+const {
+  FastBuffer,
+  markAsUntransferable,
+  addBufferPrototypeMethods,
+  createUnsafeBuffer,
+} = require('internal/buffer');
+
+FastBuffer.prototype.constructor = Buffer;
+Buffer.prototype = FastBuffer.prototype;
+addBufferPrototypeMethods(Buffer.prototype);
+
+const constants = ObjectDefineProperties({}, {
+  MAX_LENGTH: {
+    __proto__: null,
+    value: kMaxLength,
+    writable: false,
+    enumerable: true,
+  },
+  MAX_STRING_LENGTH: {
+    __proto__: null,
+    value: kStringMaxLength,
+    writable: false,
+    enumerable: true,
+  },
+});
+
+Buffer.poolSize = 8 * 1024;
+let poolSize, poolOffset, allocPool, allocBuffer;
+
+function createPool() {
+  poolSize = Buffer.poolSize;
+  allocBuffer = createUnsafeBuffer(poolSize);
+  allocPool = allocBuffer.buffer;
+  markAsUntransferable(allocPool);
+  poolOffset = 0;
+}
+createPool();
+
+function alignPool() {
+  // Ensure aligned slices
+  if (poolOffset & 0x7) {
+    poolOffset |= 0x7;
+    poolOffset++;
+  }
+}
+
+let bufferWarningAlreadyEmitted = false;
+let nodeModulesCheckCounter = 0;
+const bufferWarning = 'Buffer() is deprecated due to security and usability ' +
+                      'issues. Please use the Buffer.alloc(), ' +
+                      'Buffer.allocUnsafe(), or Buffer.from() methods instead.';
+
+function showFlaggedDeprecation() {
+  if (bufferWarningAlreadyEmitted ||
+      ++nodeModulesCheckCounter > 10000 ||
+      (!require('internal/options').getOptionValue('--pending-deprecation') &&
+       isInsideNodeModules(100, true))) {
+    // We don't emit a warning, because we either:
+    // - Already did so, or
+    // - Already checked too many times whether a call is coming
+    //   from node_modules and want to stop slowing down things, or
+    // - We aren't running with `--pending-deprecation` enabled,
+    //   and the code is inside `node_modules`.
+    // - We found node_modules in up to the topmost 100 frames, or
+    //   there are more than 100 frames and we don't want to search anymore.
+    return;
+  }
+
+  process.emitWarning(bufferWarning, 'DeprecationWarning', 'DEP0005');
+  bufferWarningAlreadyEmitted = true;
+}
+
+function toInteger(n, defaultVal) {
+  n = +n;
+  if (!NumberIsNaN(n) &&
+      n >= NumberMIN_SAFE_INTEGER &&
+      n <= NumberMAX_SAFE_INTEGER) {
+    return ((n % 1) === 0 ? n : MathFloor(n));
+  }
+  return defaultVal;
+}
+
+function copyImpl(source, target, targetStart, sourceStart, sourceEnd) {
+  if (!ArrayBufferIsView(source))
+    throw new ERR_INVALID_ARG_TYPE('source', ['Buffer', 'Uint8Array'], source);
+  if (!ArrayBufferIsView(target))
+    throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+
+  if (targetStart === undefined) {
+    targetStart = 0;
+  } else {
+    targetStart = NumberIsInteger(targetStart) ? targetStart : toInteger(targetStart, 0);
+    if (targetStart < 0)
+      throw new ERR_OUT_OF_RANGE('targetStart', '>= 0', targetStart);
+  }
+
+  if (sourceStart === undefined) {
+    sourceStart = 0;
+  } else {
+    sourceStart = NumberIsInteger(sourceStart) ? sourceStart : toInteger(sourceStart, 0);
+    if (sourceStart < 0 || sourceStart > source.byteLength)
+      throw new ERR_OUT_OF_RANGE('sourceStart', `>= 0 && <= ${source.byteLength}`, sourceStart);
+  }
+
+  if (sourceEnd === undefined) {
+    sourceEnd = source.byteLength;
+  } else {
+    sourceEnd = NumberIsInteger(sourceEnd) ? sourceEnd : toInteger(sourceEnd, 0);
+    if (sourceEnd < 0)
+      throw new ERR_OUT_OF_RANGE('sourceEnd', '>= 0', sourceEnd);
+  }
+
+  if (targetStart >= target.byteLength || sourceStart >= sourceEnd)
+    return 0;
+
+  return _copyActual(source, target, targetStart, sourceStart, sourceEnd);
+}
+
+function _copyActual(source, target, targetStart, sourceStart, sourceEnd) {
+  if (sourceEnd - sourceStart > target.byteLength - targetStart)
+    sourceEnd = sourceStart + target.byteLength - targetStart;
+
+  let nb = sourceEnd - sourceStart;
+  const sourceLen = source.byteLength - sourceStart;
+  if (nb > sourceLen)
+    nb = sourceLen;
+
+  if (nb <= 0)
+    return 0;
+
+  _copy(source, target, targetStart, sourceStart, nb);
+
+  return nb;
+}
+
+/**
+ * The Buffer() constructor is deprecated in documentation and should not be
+ * used moving forward. Rather, developers should use one of the three new
+ * factory APIs: Buffer.from(), Buffer.allocUnsafe() or Buffer.alloc() based on
+ * their specific needs. There is no runtime deprecation because of the extent
+ * to which the Buffer constructor is used in the ecosystem currently -- a
+ * runtime deprecation would introduce too much breakage at this time. It's not
+ * likely that the Buffer constructors would ever actually be removed.
+ * Deprecation Code: DEP0005
+ * @returns {Buffer}
+ */
+function Buffer(arg, encodingOrOffset, length) {
+  showFlaggedDeprecation();
+  // Common case.
+  if (typeof arg === 'number') {
+    if (typeof encodingOrOffset === 'string') {
+      throw new ERR_INVALID_ARG_TYPE('string', 'string', arg);
+    }
+    return Buffer.alloc(arg);
+  }
+  return Buffer.from(arg, encodingOrOffset, length);
+}
+
+ObjectDefineProperty(Buffer, SymbolSpecies, {
+  __proto__: null,
+  enumerable: false,
+  configurable: true,
+  get() { return FastBuffer; },
+});
+
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ * @param {any} value
+ * @param {BufferEncoding|number} encodingOrOffset
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.from = function from(value, encodingOrOffset, length) {
+  if (typeof value === 'string')
+    return fromString(value, encodingOrOffset);
+
+  if (typeof value === 'object' && value !== null) {
+    if (isAnyArrayBuffer(value))
+      return fromArrayBuffer(value, encodingOrOffset, length);
+
+    const valueOf = value.valueOf && value.valueOf();
+    if (valueOf != null &&
+        valueOf !== value &&
+        (typeof valueOf === 'string' || typeof valueOf === 'object')) {
+      return from(valueOf, encodingOrOffset, length);
+    }
+
+    const b = fromObject(value);
+    if (b)
+      return b;
+
+    if (typeof value[SymbolToPrimitive] === 'function') {
+      const primitive = value[SymbolToPrimitive]('string');
+      if (typeof primitive === 'string') {
+        return fromString(primitive, encodingOrOffset);
+      }
+    }
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    'first argument',
+    ['string', 'Buffer', 'ArrayBuffer', 'Array', 'Array-like Object'],
+    value,
+  );
+};
+
+/**
+ * Creates the Buffer as a copy of the underlying ArrayBuffer of the view
+ * rather than the contents of the view.
+ * @param {TypedArray} view
+ * @param {number} [offset]
+ * @param {number} [length]
+ * @returns {Buffer}
+ */
+Buffer.copyBytesFrom = function copyBytesFrom(view, offset, length) {
+  if (!isTypedArray(view)) {
+    throw new ERR_INVALID_ARG_TYPE('view', [ 'TypedArray' ], view);
+  }
+
+  const viewLength = TypedArrayPrototypeGetLength(view);
+  if (viewLength === 0) {
+    return Buffer.alloc(0);
+  }
+
+  if (offset !== undefined || length !== undefined) {
+    if (offset !== undefined) {
+      validateInteger(offset, 'offset', 0);
+      if (offset >= viewLength) return Buffer.alloc(0);
+    } else {
+      offset = 0;
+    }
+    let end;
+    if (length !== undefined) {
+      validateInteger(length, 'length', 0);
+      end = offset + length;
+    } else {
+      end = viewLength;
+    }
+
+    view = TypedArrayPrototypeSlice(view, offset, end);
+  }
+
+  return fromArrayLike(new Uint8Array(
+    TypedArrayPrototypeGetBuffer(view),
+    TypedArrayPrototypeGetByteOffset(view),
+    TypedArrayPrototypeGetByteLength(view)));
+};
+
+// Identical to the built-in %TypedArray%.of(), but avoids using the deprecated
+// Buffer() constructor. Must use arrow function syntax to avoid automatically
+// adding a `prototype` property and making the function a constructor.
+//
+// Refs: https://tc39.github.io/ecma262/#sec-%typedarray%.of
+// Refs: https://esdiscuss.org/topic/isconstructor#content-11
+const of = (...items) => {
+  const newObj = createUnsafeBuffer(items.length);
+  for (let k = 0; k < items.length; k++)
+    newObj[k] = items[k];
+  return newObj;
+};
+Buffer.of = of;
+
+ObjectSetPrototypeOf(Buffer, Uint8Array);
+
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ * @returns {FastBuffer}
+ */
+Buffer.alloc = function alloc(size, fill, encoding) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  if (fill !== undefined && fill !== 0 && size > 0) {
+    const buf = createUnsafeBuffer(size);
+    return _fill(buf, fill, 0, buf.length, encoding);
+  }
+  return new FastBuffer(size);
+};
+
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer
+ * instance. If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @returns {FastBuffer}
+ */
+Buffer.allocUnsafe = function allocUnsafe(size) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  return allocate(size);
+};
+
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled
+ * Buffer instance that is not allocated off the pre-initialized pool.
+ * If `--zero-fill-buffers` is set, will zero-fill the buffer.
+ * @param {number} size
+ * @returns {FastBuffer|undefined}
+ */
+Buffer.allocUnsafeSlow = function allocUnsafeSlow(size) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  return createUnsafeBuffer(size);
+};
+
+// If --zero-fill-buffers command line argument is set, a zero-filled
+// buffer is returned.
+function SlowBuffer(size) {
+  validateNumber(size, 'size', 0, kMaxLength);
+  return createUnsafeBuffer(size);
+}
+
+ObjectSetPrototypeOf(SlowBuffer.prototype, Uint8ArrayPrototype);
+ObjectSetPrototypeOf(SlowBuffer, Uint8Array);
+
+function allocate(size) {
+  if (size <= 0) {
+    return new FastBuffer();
+  }
+  if (size < (Buffer.poolSize >>> 1)) {
+    if (size > (poolSize - poolOffset))
+      createPool();
+    const b = new FastBuffer(allocPool, poolOffset, size);
+    poolOffset += size;
+    alignPool();
+    return b;
+  }
+  return createUnsafeBuffer(size);
+}
+
+function fromStringFast(string, ops) {
+  const maxLength = Buffer.poolSize >>> 1;
+
+  let length = string.length; // Min length
+
+  if (length >= maxLength)
+    return createFromString(string, ops);
+
+  length *= 4; // Max length (4 bytes per character)
+
+  if (length >= maxLength)
+    length = ops.byteLength(string); // Actual length
+
+  if (length >= maxLength)
+    return createFromString(string, ops, length);
+
+  if (length > (poolSize - poolOffset))
+    createPool();
+
+  const actual = ops.write(allocBuffer, string, poolOffset, length);
+  const b = new FastBuffer(allocPool, poolOffset, actual);
+
+  poolOffset += actual;
+  alignPool();
+  return b;
+}
+
+function createFromString(string, ops, length = ops.byteLength(string)) {
+  const buf = Buffer.allocUnsafeSlow(length);
+  const actual = ops.write(buf, string, 0, length);
+  return actual < length ? new FastBuffer(buf.buffer, 0, actual) : buf;
+}
+
+function fromString(string, encoding) {
+  let ops;
+  if (!encoding || encoding === 'utf8' || typeof encoding !== 'string') {
+    ops = encodingOps.utf8;
+  } else {
+    ops = getEncodingOps(encoding);
+    if (ops === undefined)
+      throw new ERR_UNKNOWN_ENCODING(encoding);
+  }
+
+  return string.length === 0 ? new FastBuffer() : fromStringFast(string, ops);
+}
+
+function fromArrayBuffer(obj, byteOffset, length) {
+  // Convert byteOffset to integer
+  if (byteOffset === undefined) {
+    byteOffset = 0;
+  } else {
+    byteOffset = +byteOffset;
+    if (NumberIsNaN(byteOffset))
+      byteOffset = 0;
+  }
+
+  const maxLength = obj.byteLength - byteOffset;
+
+  if (maxLength < 0)
+    throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
+
+  if (length !== undefined) {
+    // Convert length to non-negative integer.
+    length = +length;
+    if (length > 0) {
+      if (length > maxLength)
+        throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
+    } else {
+      length = 0;
+    }
+  }
+
+  return new FastBuffer(obj, byteOffset, length);
+}
+
+function fromArrayLike(obj) {
+  if (obj.length <= 0)
+    return new FastBuffer();
+  if (obj.length < (Buffer.poolSize >>> 1)) {
+    if (obj.length > (poolSize - poolOffset))
+      createPool();
+    const b = new FastBuffer(allocPool, poolOffset, obj.length);
+    TypedArrayPrototypeSet(b, obj, 0);
+    poolOffset += obj.length;
+    alignPool();
+    return b;
+  }
+  return new FastBuffer(obj);
+}
+
+function fromObject(obj) {
+  if (obj.length !== undefined || isAnyArrayBuffer(obj.buffer)) {
+    if (typeof obj.length !== 'number') {
+      return new FastBuffer();
+    }
+    return fromArrayLike(obj);
+  }
+
+  if (obj.type === 'Buffer' && ArrayIsArray(obj.data)) {
+    return fromArrayLike(obj.data);
+  }
+}
+
+// Static methods
+
+Buffer.isBuffer = function isBuffer(b) {
+  return b instanceof Buffer;
+};
+
+Buffer.compare = function compare(buf1, buf2) {
+  if (!isUint8Array(buf1)) {
+    throw new ERR_INVALID_ARG_TYPE('buf1', ['Buffer', 'Uint8Array'], buf1);
+  }
+
+  if (!isUint8Array(buf2)) {
+    throw new ERR_INVALID_ARG_TYPE('buf2', ['Buffer', 'Uint8Array'], buf2);
+  }
+
+  if (buf1 === buf2) {
+    return 0;
+  }
+
+  return _compare(buf1, buf2);
+};
+
+Buffer.isEncoding = function isEncoding(encoding) {
+  return typeof encoding === 'string' && encoding.length !== 0 &&
+         normalizeEncoding(encoding) !== undefined;
+};
+Buffer[kIsEncodingSymbol] = Buffer.isEncoding;
+
+Buffer.concat = function concat(list, length) {
+  validateArray(list, 'list');
+
+  if (list.length === 0)
+    return new FastBuffer();
+
+  if (length === undefined) {
+    length = 0;
+    for (let i = 0; i < list.length; i++) {
+      if (list[i].length) {
+        length += list[i].length;
+      }
+    }
+  } else {
+    validateOffset(length, 'length');
+  }
+
+  const buffer = Buffer.allocUnsafe(length);
+  let pos = 0;
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    if (!isUint8Array(buf)) {
+      // TODO(BridgeAR): This should not be of type ERR_INVALID_ARG_TYPE.
+      // Instead, find the proper error code for this.
+      throw new ERR_INVALID_ARG_TYPE(
+        `list[${i}]`, ['Buffer', 'Uint8Array'], list[i]);
+    }
+    pos += _copyActual(buf, buffer, pos, 0, buf.length);
+  }
+
+  // Note: `length` is always equal to `buffer.length` at this point
+  if (pos < length) {
+    // Zero-fill the remaining bytes if the specified `length` was more than
+    // the actual total length, i.e. if we have some remaining allocated bytes
+    // there were not initialized.
+    TypedArrayPrototypeFill(buffer, 0, pos, length);
+  }
+
+  return buffer;
+};
+
+function base64ByteLength(str, bytes) {
+  // Handle padding
+  if (StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+    bytes--;
+  if (bytes > 1 && StringPrototypeCharCodeAt(str, bytes - 1) === 0x3D)
+    bytes--;
+
+  // Base64 ratio: 3/4
+  return (bytes * 3) >>> 2;
+}
+
+const encodingOps = {
+  utf8: {
+    encoding: 'utf8',
+    encodingVal: encodingsMap.utf8,
+    byteLength: byteLengthUtf8,
+    write: (buf, string, offset, len) => buf.utf8Write(string, offset, len),
+    slice: (buf, start, end) => buf.utf8Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.utf8, dir),
+  },
+  ucs2: {
+    encoding: 'ucs2',
+    encodingVal: encodingsMap.utf16le,
+    byteLength: (string) => string.length * 2,
+    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+    slice: (buf, start, end) => buf.ucs2Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+  },
+  utf16le: {
+    encoding: 'utf16le',
+    encodingVal: encodingsMap.utf16le,
+    byteLength: (string) => string.length * 2,
+    write: (buf, string, offset, len) => buf.ucs2Write(string, offset, len),
+    slice: (buf, start, end) => buf.ucs2Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.utf16le, dir),
+  },
+  latin1: {
+    encoding: 'latin1',
+    encodingVal: encodingsMap.latin1,
+    byteLength: (string) => string.length,
+    write: (buf, string, offset, len) => buf.latin1Write(string, offset, len),
+    slice: (buf, start, end) => buf.latin1Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfString(buf, val, byteOffset, encodingsMap.latin1, dir),
+  },
+  ascii: {
+    encoding: 'ascii',
+    encodingVal: encodingsMap.ascii,
+    byteLength: (string) => string.length,
+    write: (buf, string, offset, len) => buf.asciiWrite(string, offset, len),
+    slice: (buf, start, end) => buf.asciiSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.ascii),
+                    byteOffset,
+                    encodingsMap.ascii,
+                    dir),
+  },
+  base64: {
+    encoding: 'base64',
+    encodingVal: encodingsMap.base64,
+    byteLength: (string) => base64ByteLength(string, string.length),
+    write: (buf, string, offset, len) => buf.base64Write(string, offset, len),
+    slice: (buf, start, end) => buf.base64Slice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.base64),
+                    byteOffset,
+                    encodingsMap.base64,
+                    dir),
+  },
+  base64url: {
+    encoding: 'base64url',
+    encodingVal: encodingsMap.base64url,
+    byteLength: (string) => base64ByteLength(string, string.length),
+    write: (buf, string, offset, len) =>
+      buf.base64urlWrite(string, offset, len),
+    slice: (buf, start, end) => buf.base64urlSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.base64url),
+                    byteOffset,
+                    encodingsMap.base64url,
+                    dir),
+  },
+  hex: {
+    encoding: 'hex',
+    encodingVal: encodingsMap.hex,
+    byteLength: (string) => string.length >>> 1,
+    write: (buf, string, offset, len) => buf.hexWrite(string, offset, len),
+    slice: (buf, start, end) => buf.hexSlice(start, end),
+    indexOf: (buf, val, byteOffset, dir) =>
+      indexOfBuffer(buf,
+                    fromStringFast(val, encodingOps.hex),
+                    byteOffset,
+                    encodingsMap.hex,
+                    dir),
+  },
+};
+function getEncodingOps(encoding) {
+  encoding += '';
+  switch (encoding.length) {
+    case 4:
+      if (encoding === 'utf8') return encodingOps.utf8;
+      if (encoding === 'ucs2') return encodingOps.ucs2;
+      encoding = StringPrototypeToLowerCase(encoding);
+      if (encoding === 'utf8') return encodingOps.utf8;
+      if (encoding === 'ucs2') return encodingOps.ucs2;
+      break;
+    case 5:
+      if (encoding === 'utf-8') return encodingOps.utf8;
+      if (encoding === 'ascii') return encodingOps.ascii;
+      if (encoding === 'ucs-2') return encodingOps.ucs2;
+      encoding = StringPrototypeToLowerCase(encoding);
+      if (encoding === 'utf-8') return encodingOps.utf8;
+      if (encoding === 'ascii') return encodingOps.ascii;
+      if (encoding === 'ucs-2') return encodingOps.ucs2;
+      break;
+    case 7:
+      if (encoding === 'utf16le' ||
+          StringPrototypeToLowerCase(encoding) === 'utf16le')
+        return encodingOps.utf16le;
+      break;
+    case 8:
+      if (encoding === 'utf-16le' ||
+          StringPrototypeToLowerCase(encoding) === 'utf-16le')
+        return encodingOps.utf16le;
+      break;
+    case 6:
+      if (encoding === 'latin1' || encoding === 'binary')
+        return encodingOps.latin1;
+      if (encoding === 'base64') return encodingOps.base64;
+      encoding = StringPrototypeToLowerCase(encoding);
+      if (encoding === 'latin1' || encoding === 'binary')
+        return encodingOps.latin1;
+      if (encoding === 'base64') return encodingOps.base64;
+      break;
+    case 3:
+      if (encoding === 'hex' || StringPrototypeToLowerCase(encoding) === 'hex')
+        return encodingOps.hex;
+      break;
+    case 9:
+      if (encoding === 'base64url' ||
+          StringPrototypeToLowerCase(encoding) === 'base64url')
+        return encodingOps.base64url;
+      break;
+  }
+}
+
+function byteLength(string, encoding) {
+  if (typeof string !== 'string') {
+    if (isArrayBufferView(string) || isAnyArrayBuffer(string)) {
+      return string.byteLength;
+    }
+
+    throw new ERR_INVALID_ARG_TYPE(
+      'string', ['string', 'Buffer', 'ArrayBuffer'], string,
+    );
+  }
+
+  const len = string.length;
+  if (len === 0)
+    return 0;
+
+  if (!encoding || encoding === 'utf8') {
+    return byteLengthUtf8(string);
+  }
+
+  if (encoding === 'ascii') {
+    return len;
+  }
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined) {
+    // TODO (ronag): Makes more sense to throw here.
+    // throw new ERR_UNKNOWN_ENCODING(encoding);
+    return byteLengthUtf8(string);
+  }
+
+  return ops.byteLength(string);
+}
+
+Buffer.byteLength = byteLength;
+
+// For backwards compatibility.
+ObjectDefineProperty(Buffer.prototype, 'parent', {
+  __proto__: null,
+  enumerable: true,
+  get() {
+    if (!(this instanceof Buffer))
+      return undefined;
+    return this.buffer;
+  },
+});
+ObjectDefineProperty(Buffer.prototype, 'offset', {
+  __proto__: null,
+  enumerable: true,
+  get() {
+    if (!(this instanceof Buffer))
+      return undefined;
+    return this.byteOffset;
+  },
+});
+
+Buffer.prototype.copy =
+  function copy(target, targetStart, sourceStart, sourceEnd) {
+    return copyImpl(this, target, targetStart, sourceStart, sourceEnd);
+  };
+
+// No need to verify that "buf.length <= MAX_UINT32" since it's a read-only
+// property of a typed array.
+// This behaves neither like String nor Uint8Array in that we set start/end
+// to their upper/lower bounds if the value passed is out of range.
+Buffer.prototype.toString = function toString(encoding, start, end) {
+  if (arguments.length === 0) {
+    return this.utf8Slice(0, this.length);
+  }
+
+  const len = this.length;
+
+  if (start <= 0)
+    start = 0;
+  else if (start >= len)
+    return '';
+  else
+    start = MathTrunc(start) || 0;
+
+  if (end === undefined || end > len)
+    end = len;
+  else
+    end = MathTrunc(end) || 0;
+
+  if (end <= start)
+    return '';
+
+  if (encoding === undefined)
+    return this.utf8Slice(start, end);
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined)
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+
+  return ops.slice(this, start, end);
+};
+
+Buffer.prototype.equals = function equals(otherBuffer) {
+  if (!isUint8Array(otherBuffer)) {
+    throw new ERR_INVALID_ARG_TYPE(
+      'otherBuffer', ['Buffer', 'Uint8Array'], otherBuffer);
+  }
+
+  if (this === otherBuffer)
+    return true;
+  const len = TypedArrayPrototypeGetByteLength(this);
+  if (len !== TypedArrayPrototypeGetByteLength(otherBuffer))
+    return false;
+
+  return len === 0 || _compare(this, otherBuffer) === 0;
+};
+
+let INSPECT_MAX_BYTES = 50;
+// Override how buffers are presented by util.inspect().
+Buffer.prototype[customInspectSymbol] = function inspect(recurseTimes, ctx) {
+  const max = INSPECT_MAX_BYTES;
+  const actualMax = MathMin(max, this.length);
+  const remaining = this.length - max;
+  let str = StringPrototypeTrim(RegExpPrototypeSymbolReplace(
+    /(.{2})/g, this.hexSlice(0, actualMax), '$1 '));
+  if (remaining > 0)
+    str += ` ... ${remaining} more byte${remaining > 1 ? 's' : ''}`;
+  // Inspect special properties as well, if possible.
+  if (ctx) {
+    let extras = false;
+    const filter = ctx.showHidden ? ALL_PROPERTIES : ONLY_ENUMERABLE;
+    const obj = { __proto__: null };
+    ArrayPrototypeForEach(getOwnNonIndexProperties(this, filter),
+                          (key) => {
+                            extras = true;
+                            obj[key] = this[key];
+                          });
+    if (extras) {
+      if (this.length !== 0)
+        str += ', ';
+      // '[Object: null prototype] {'.length === 26
+      // This is guarded with a test.
+      str += StringPrototypeSlice(utilInspect(obj, {
+        ...ctx,
+        breakLength: Infinity,
+        compact: true,
+      }), 27, -2);
+    }
+  }
+  let constructorName = 'Buffer';
+  try {
+    const { constructor } = this;
+    if (typeof constructor === 'function' && ObjectPrototypeHasOwnProperty(constructor, 'name')) {
+      constructorName = constructor.name;
+    }
+  } catch { /* Ignore error and use default name */ }
+  return `<${constructorName} ${str}>`;
+};
+Buffer.prototype.inspect = Buffer.prototype[customInspectSymbol];
+
+Buffer.prototype.compare = function compare(target,
+                                            targetStart,
+                                            targetEnd,
+                                            sourceStart,
+                                            sourceEnd) {
+  if (!isUint8Array(target)) {
+    throw new ERR_INVALID_ARG_TYPE('target', ['Buffer', 'Uint8Array'], target);
+  }
+  if (arguments.length === 1)
+    return _compare(this, target);
+
+  if (targetStart === undefined)
+    targetStart = 0;
+  else
+    validateOffset(targetStart, 'targetStart');
+
+  if (targetEnd === undefined)
+    targetEnd = target.length;
+  else
+    validateOffset(targetEnd, 'targetEnd', 0, target.length);
+
+  if (sourceStart === undefined)
+    sourceStart = 0;
+  else
+    validateOffset(sourceStart, 'sourceStart');
+
+  if (sourceEnd === undefined)
+    sourceEnd = this.length;
+  else
+    validateOffset(sourceEnd, 'sourceEnd', 0, this.length);
+
+  if (sourceStart >= sourceEnd)
+    return (targetStart >= targetEnd ? 0 : -1);
+  if (targetStart >= targetEnd)
+    return 1;
+
+  return compareOffset(this, target, targetStart, sourceStart, targetEnd,
+                       sourceEnd);
+};
+
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant if val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+  validateBuffer(buffer);
+
+  if (typeof byteOffset === 'string') {
+    encoding = byteOffset;
+    byteOffset = undefined;
+  } else if (byteOffset > 0x7fffffff) {
+    byteOffset = 0x7fffffff;
+  } else if (byteOffset < -0x80000000) {
+    byteOffset = -0x80000000;
+  }
+  // Coerce to Number. Values like null and [] become 0.
+  byteOffset = +byteOffset;
+  // If the offset is undefined, "foo", {}, coerces to NaN, search whole buffer.
+  if (NumberIsNaN(byteOffset)) {
+    byteOffset = dir ? 0 : (buffer.length || buffer.byteLength);
+  }
+  dir = !!dir;  // Cast to bool.
+
+  if (typeof val === 'number')
+    return indexOfNumber(buffer, val >>> 0, byteOffset, dir);
+
+  let ops;
+  if (encoding === undefined)
+    ops = encodingOps.utf8;
+  else
+    ops = getEncodingOps(encoding);
+
+  if (typeof val === 'string') {
+    if (ops === undefined)
+      throw new ERR_UNKNOWN_ENCODING(encoding);
+    return ops.indexOf(buffer, val, byteOffset, dir);
+  }
+
+  if (isUint8Array(val)) {
+    const encodingVal =
+      (ops === undefined ? encodingsMap.utf8 : ops.encodingVal);
+    return indexOfBuffer(buffer, val, byteOffset, encodingVal, dir);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    'value', ['number', 'string', 'Buffer', 'Uint8Array'], val,
+  );
+}
+
+Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+};
+
+Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+  return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+};
+
+Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+  return this.indexOf(val, byteOffset, encoding) !== -1;
+};
+
+// Usage:
+//    buffer.fill(number[, offset[, end]])
+//    buffer.fill(buffer[, offset[, end]])
+//    buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill(value, offset, end, encoding) {
+  return _fill(this, value, offset, end, encoding);
+};
+
+function _fill(buf, value, offset, end, encoding) {
+  if (typeof value === 'string') {
+    if (offset === undefined || typeof offset === 'string') {
+      encoding = offset;
+      offset = 0;
+      end = buf.length;
+    } else if (typeof end === 'string') {
+      encoding = end;
+      end = buf.length;
+    }
+
+    const normalizedEncoding = normalizeEncoding(encoding);
+    if (normalizedEncoding === undefined) {
+      validateString(encoding, 'encoding');
+      throw new ERR_UNKNOWN_ENCODING(encoding);
+    }
+
+    if (value.length === 0) {
+      // If value === '' default to zero.
+      value = 0;
+    } else if (value.length === 1) {
+      // Fast path: If `value` fits into a single byte, use that numeric value.
+      if (normalizedEncoding === 'utf8') {
+        const code = StringPrototypeCharCodeAt(value, 0);
+        if (code < 128) {
+          value = code;
+        }
+      } else if (normalizedEncoding === 'latin1') {
+        value = StringPrototypeCharCodeAt(value, 0);
+      }
+    }
+  } else {
+    encoding = undefined;
+  }
+
+  if (offset === undefined) {
+    offset = 0;
+    end = buf.length;
+  } else {
+    validateOffset(offset, 'offset');
+    // Invalid ranges are not set to a default, so can range check early.
+    if (end === undefined) {
+      end = buf.length;
+    } else {
+      validateOffset(end, 'end', 0, buf.length);
+    }
+    if (offset >= end)
+      return buf;
+  }
+
+
+  if (typeof value === 'number') {
+    // OOB check
+    const byteLen = TypedArrayPrototypeGetByteLength(buf);
+    const fillLength = end - offset;
+    if (offset > end || fillLength + offset > byteLen)
+      throw new ERR_BUFFER_OUT_OF_BOUNDS();
+
+    TypedArrayPrototypeFill(buf, value, offset, end);
+  } else {
+    const res = bindingFill(buf, value, offset, end, encoding);
+    if (res < 0) {
+      if (res === -1)
+        throw new ERR_INVALID_ARG_VALUE('value', value);
+      throw new ERR_BUFFER_OUT_OF_BOUNDS();
+    }
+  }
+
+  return buf;
+}
+
+Buffer.prototype.write = function write(string, offset, length, encoding) {
+  // Buffer#write(string);
+  if (offset === undefined) {
+    return this.utf8Write(string, 0, this.length);
+  }
+  // Buffer#write(string, encoding)
+  if (length === undefined && typeof offset === 'string') {
+    encoding = offset;
+    length = this.length;
+    offset = 0;
+
+  // Buffer#write(string, offset[, length][, encoding])
+  } else {
+    validateOffset(offset, 'offset', 0, this.length);
+
+    const remaining = this.length - offset;
+
+    if (length === undefined) {
+      length = remaining;
+    } else if (typeof length === 'string') {
+      encoding = length;
+      length = remaining;
+    } else {
+      validateOffset(length, 'length', 0, this.length);
+      if (length > remaining)
+        length = remaining;
+    }
+  }
+
+  if (!encoding || encoding === 'utf8')
+    return this.utf8Write(string, offset, length);
+  if (encoding === 'ascii')
+    return this.asciiWrite(string, offset, length);
+
+  const ops = getEncodingOps(encoding);
+  if (ops === undefined)
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+  return ops.write(this, string, offset, length);
+};
+
+Buffer.prototype.toJSON = function toJSON() {
+  if (this.length > 0) {
+    const data = new Array(this.length);
+    for (let i = 0; i < this.length; ++i)
+      data[i] = this[i];
+    return { type: 'Buffer', data };
+  }
+  return { type: 'Buffer', data: [] };
+};
+
+function adjustOffset(offset, length) {
+  // Use Math.trunc() to convert offset to an integer value that can be larger
+  // than an Int32. Hence, don't use offset | 0 or similar techniques.
+  offset = MathTrunc(offset);
+  if (offset === 0) {
+    return 0;
+  }
+  if (offset < 0) {
+    offset += length;
+    return offset > 0 ? offset : 0;
+  }
+  if (offset < length) {
+    return offset;
+  }
+  return NumberIsNaN(offset) ? 0 : length;
+}
+
+Buffer.prototype.subarray = function subarray(start, end) {
+  const srcLength = this.length;
+  start = adjustOffset(start, srcLength);
+  end = end !== undefined ? adjustOffset(end, srcLength) : srcLength;
+  const newLength = end > start ? end - start : 0;
+  return new FastBuffer(this.buffer, this.byteOffset + start, newLength);
+};
+
+Buffer.prototype.slice = function slice(start, end) {
+  return this.subarray(start, end);
+};
+
+function swap(b, n, m) {
+  const i = b[n];
+  b[n] = b[m];
+  b[m] = i;
+}
+
+Buffer.prototype.swap16 = function swap16() {
+  // For Buffer.length < 128, it's generally faster to
+  // do the swap in javascript. For larger buffers,
+  // dropping down to the native code is faster.
+  const len = this.length;
+  if (len % 2 !== 0)
+    throw new ERR_INVALID_BUFFER_SIZE('16-bits');
+  if (len < 128) {
+    for (let i = 0; i < len; i += 2)
+      swap(this, i, i + 1);
+    return this;
+  }
+  return _swap16(this);
+};
+
+Buffer.prototype.swap32 = function swap32() {
+  // For Buffer.length < 192, it's generally faster to
+  // do the swap in javascript. For larger buffers,
+  // dropping down to the native code is faster.
+  const len = this.length;
+  if (len % 4 !== 0)
+    throw new ERR_INVALID_BUFFER_SIZE('32-bits');
+  if (len < 192) {
+    for (let i = 0; i < len; i += 4) {
+      swap(this, i, i + 3);
+      swap(this, i + 1, i + 2);
+    }
+    return this;
+  }
+  return _swap32(this);
+};
+
+Buffer.prototype.swap64 = function swap64() {
+  // For Buffer.length < 192, it's generally faster to
+  // do the swap in javascript. For larger buffers,
+  // dropping down to the native code is faster.
+  const len = this.length;
+  if (len % 8 !== 0)
+    throw new ERR_INVALID_BUFFER_SIZE('64-bits');
+  if (len < 192) {
+    for (let i = 0; i < len; i += 8) {
+      swap(this, i, i + 7);
+      swap(this, i + 1, i + 6);
+      swap(this, i + 2, i + 5);
+      swap(this, i + 3, i + 4);
+    }
+    return this;
+  }
+  return _swap64(this);
+};
+
+Buffer.prototype.toLocaleString = Buffer.prototype.toString;
+
+let transcode;
+if (internalBinding('config').hasIntl) {
+  const {
+    icuErrName,
+    transcode: _transcode,
+  } = internalBinding('icu');
+
+  // Transcodes the Buffer from one encoding to another, returning a new
+  // Buffer instance.
+  transcode = function transcode(source, fromEncoding, toEncoding) {
+    if (!isUint8Array(source)) {
+      throw new ERR_INVALID_ARG_TYPE('source',
+                                     ['Buffer', 'Uint8Array'], source);
+    }
+    if (source.length === 0) return Buffer.alloc(0);
+
+    fromEncoding = normalizeEncoding(fromEncoding) || fromEncoding;
+    toEncoding = normalizeEncoding(toEncoding) || toEncoding;
+    const result = _transcode(source, fromEncoding, toEncoding);
+    if (typeof result !== 'number')
+      return result;
+
+    const code = icuErrName(result);
+    const err = genericNodeError(
+      `Unable to transcode Buffer [${code}]`,
+      { code: code, errno: result },
+    );
+    throw err;
+  };
+}
+
+function btoa(input) {
+  // The implementation here has not been performance optimized in any way and
+  // should not be.
+  // Refs: https://github.com/nodejs/node/pull/38433#issuecomment-828426932
+  if (arguments.length === 0) {
+    throw new ERR_MISSING_ARGS('input');
+  }
+  const result = _btoa(`${input}`);
+  if (result === -1) {
+    throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+  }
+  return result;
+}
+
+function atob(input) {
+  if (arguments.length === 0) {
+    throw new ERR_MISSING_ARGS('input');
+  }
+
+  const result = _atob(`${input}`);
+
+  switch (result) {
+    case -2: // Invalid character
+      throw lazyDOMException('Invalid character', 'InvalidCharacterError');
+    case -1: // Single character remained
+      throw lazyDOMException(
+        'The string to be decoded is not correctly encoded.',
+        'InvalidCharacterError');
+    case -3: // Possible overflow
+      // TODO(@anonrig): Throw correct error in here.
+      throw lazyDOMException('The input causes overflow.', 'InvalidCharacterError');
+    default:
+      return result;
+  }
+}
+
+function isUtf8(input) {
+  if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+    return bindingIsUtf8(input);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+function isAscii(input) {
+  if (isTypedArray(input) || isAnyArrayBuffer(input)) {
+    return bindingIsAscii(input);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE('input', ['ArrayBuffer', 'Buffer', 'TypedArray'], input);
+}
+
+module.exports = {
+  Buffer,
+  SlowBuffer: deprecate(
+    SlowBuffer,
+    'SlowBuffer() is deprecated. Please use Buffer.allocUnsafeSlow()',
+    'DEP0030'),
+  transcode,
+  isUtf8,
+  isAscii,
+
+  // Legacy
+  kMaxLength,
+  kStringMaxLength,
+  btoa,
+  atob,
+};
+
+ObjectDefineProperties(module.exports, {
+  constants: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: constants,
+  },
+  INSPECT_MAX_BYTES: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() { return INSPECT_MAX_BYTES; },
+    set(val) {
+      validateNumber(val, 'INSPECT_MAX_BYTES', 0);
+      INSPECT_MAX_BYTES = val;
+    },
+  },
+});
+
+defineLazyProperties(
+  module.exports,
+  'internal/blob',
+  ['Blob', 'resolveObjectURL'],
+);
+defineLazyProperties(
+  module.exports,
+  'internal/file',
+  ['File'],
+);
\ No newline at end of file
diff --git a/.codesandbox/node/dfn.js b/.codesandbox/node/dfn.js
new file mode 100644
index 0000000000..29b453dc2f
--- /dev/null
+++ b/.codesandbox/node/dfn.js
@@ -0,0 +1,118 @@
+var dfnMapTarget = -1;
+var dfnMapDone = 0;
+var dfnMap = {};
+document.addEventListener('DOMContentLoaded', function (event) {
+  var links = [];
+  dfnMapTarget = document.links.length;
+  for (var i = 0; i < dfnMapTarget; i += 1)
+    links[i] = document.links[i];
+  var inc = 100;
+  for (var i = 0; i < dfnMapTarget; i += inc) {
+    setTimeout(function (j) {
+      for (var k = j; k < j+inc && k < dfnMapTarget; k += 1) {
+        if (links[k].href.indexOf('#') >= 0) {
+          if (links[k].className != "no-backref" &&
+              links[k].parentNode.className != "no-backref") {
+            var s = links[k].href.substr(links[k].href.indexOf('#') + 1);
+            if (!(s in dfnMap))
+              dfnMap[s] = [];
+            dfnMap[s].push(links[k]);
+          }
+        }
+        dfnMapDone += 1;
+      }
+    }, 0, i);
+  }
+  document.body.className += " dfnEnabled";
+}, false);
+
+var dfnPanel;
+var dfnUniqueId = 0;
+var dfnTimeout;
+document.addEventListener('click', dfnShow, false);
+function dfnShow(event) {
+  if (dfnTimeout) {
+    clearTimeout(dfnTimeout);
+    dfnTimeout = null;
+  }
+  if (dfnPanel) {
+    dfnPanel.parentNode.removeChild(dfnPanel);
+    dfnPanel = null;
+  }
+  if (dfnMapDone == dfnMapTarget) {
+    var node = event.target;
+    while (node && (node.nodeType != event.target.ELEMENT_NODE || node.tagName != "DFN"))
+      node = node.parentNode;
+    if (node) {
+      var panel = document.createElement('div');
+      panel.className = 'dfnPanel';
+      if (node.id) {
+        var permalinkP = document.createElement('p');
+        var permalinkA = document.createElement('a');
+        permalinkA.href = '#' + node.id;
+        permalinkA.textContent = '#' + node.id;
+        permalinkP.appendChild(permalinkA);
+        panel.appendChild(permalinkP);
+      }
+      var p = document.createElement('p');
+      panel.appendChild(p);
+      if (node.id in dfnMap || node.parentNode.id in dfnMap) {
+        p.textContent = 'Referenced in:';
+        var ul = document.createElement('ul');
+        var lastHeader;
+        var lastLi;
+        var n;
+        var sourceLinks = [];
+        if (node.id in dfnMap)
+          for (var i = 0; i < dfnMap[node.id].length; i += 1)
+            sourceLinks.push(dfnMap[node.id][i]);
+        if (node.parentNode.id in dfnMap)
+          for (var i = 0; i < dfnMap[node.parentNode.id].length; i += 1)
+            sourceLinks.push(dfnMap[node.parentNode.id][i]);
+        for (var i = 0; i < sourceLinks.length; i += 1) {
+          var link = sourceLinks[i];
+          var header = dfnGetCaption(link);
+          var a = document.createElement('a');
+          if (!link.id)
+            link.id = 'dfnReturnLink-' + dfnUniqueId++;
+          a.href = '#' + link.id;
+          if (header != lastHeader) {
+            lastHeader = header;
+            n = 1;
+            var li = document.createElement('li');
+            var cloneHeader = header.cloneNode(true);
+            while (cloneHeader.hasChildNodes())
+              if (cloneHeader.firstChild.className == 'section-link')
+                cloneHeader.removeChild(cloneHeader.firstChild);
+              else
+                a.appendChild(cloneHeader.firstChild);
+            lastLi = li;
+            li.appendChild(a);
+            ul.appendChild(li);
+          } else {
+            n += 1;
+            a.appendChild(document.createTextNode('(' + n + ')'));
+            lastLi.appendChild(document.createTextNode(' '));
+            lastLi.appendChild(a);
+          }
+        }
+        panel.appendChild(ul);
+      } else {
+        p.textContent = 'No references in this file.';
+      }
+      node.appendChild(panel);
+      dfnPanel = panel;
+    }
+  } else {
+    dfnTimeout = setTimeout(dfnShow, 250, event);
+  }
+}
+
+function dfnGetCaption(link) {
+  var node = link;
+  while (node && !(node.parentNode.tagName == "DIV" && node.parentNode.className == "section"))
+    node = node.parentNode;
+  while (node && (node.nodeType != node.ELEMENT_NODE || !node.tagName.match(/^H[1-6]$/)))
+    node = node.previousSibling;
+  return node;
+}
\ No newline at end of file
diff --git a/.codesandbox/node/dgram.js b/.codesandbox/node/dgram.js
new file mode 100644
index 0000000000..c77ea89cc8
--- /dev/null
+++ b/.codesandbox/node/dgram.js
@@ -0,0 +1,1111 @@
+'use strict';
+
+const {
+  Array,
+  ArrayIsArray,
+  ArrayPrototypePush,
+  FunctionPrototypeBind,
+  FunctionPrototypeCall,
+  ObjectDefineProperty,
+  ObjectSetPrototypeOf,
+  ReflectApply,
+  SymbolAsyncDispose,
+  SymbolDispose,
+} = primordials;
+
+const {
+  ErrnoException,
+  ExceptionWithHostPort,
+  codes: {
+    ERR_BUFFER_OUT_OF_BOUNDS,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_FD_TYPE,
+    ERR_IP_BLOCKED,
+    ERR_MISSING_ARGS,
+    ERR_SOCKET_ALREADY_BOUND,
+    ERR_SOCKET_BAD_BUFFER_SIZE,
+    ERR_SOCKET_BUFFER_SIZE,
+    ERR_SOCKET_DGRAM_IS_CONNECTED,
+    ERR_SOCKET_DGRAM_NOT_CONNECTED,
+    ERR_SOCKET_DGRAM_NOT_RUNNING,
+  },
+} = require('internal/errors');
+const {
+  kStateSymbol,
+  _createSocketHandle,
+  newHandle,
+} = require('internal/dgram');
+const { isIP } = require('internal/net');
+const {
+  isInt32,
+  validateAbortSignal,
+  validateString,
+  validateNumber,
+  validatePort,
+  validateUint32,
+} = require('internal/validators');
+const { Buffer } = require('buffer');
+const { deprecate, guessHandleType, promisify } = require('internal/util');
+const { isArrayBufferView } = require('internal/util/types');
+const EventEmitter = require('events');
+const { addAbortListener } = require('internal/events/abort_listener');
+const {
+  defaultTriggerAsyncIdScope,
+  symbols: { async_id_symbol, owner_symbol },
+} = require('internal/async_hooks');
+const { UV_UDP_REUSEADDR } = internalBinding('constants').os;
+
+const {
+  constants: { UV_UDP_IPV6ONLY, UV_UDP_REUSEPORT },
+  UDP,
+  SendWrap,
+} = internalBinding('udp_wrap');
+
+const dc = require('diagnostics_channel');
+const udpSocketChannel = dc.channel('udp.socket');
+
+const BIND_STATE_UNBOUND = 0;
+const BIND_STATE_BINDING = 1;
+const BIND_STATE_BOUND = 2;
+
+const CONNECT_STATE_DISCONNECTED = 0;
+const CONNECT_STATE_CONNECTING = 1;
+const CONNECT_STATE_CONNECTED = 2;
+
+const RECV_BUFFER = true;
+const SEND_BUFFER = false;
+
+// Lazily loaded
+let _cluster = null;
+function lazyLoadCluster() {
+  return _cluster ??= require('cluster');
+}
+let _blockList = null;
+function lazyLoadBlockList() {
+  return _blockList ??= require('internal/blocklist').BlockList;
+}
+
+function Socket(type, listener) {
+  FunctionPrototypeCall(EventEmitter, this);
+  let lookup;
+  let recvBufferSize;
+  let sendBufferSize;
+  let receiveBlockList;
+  let sendBlockList;
+
+  let options;
+  if (type !== null && typeof type === 'object') {
+    options = type;
+    type = options.type;
+    lookup = options.lookup;
+    if (options.recvBufferSize) {
+      validateUint32(options.recvBufferSize, 'options.recvBufferSize');
+    }
+    if (options.sendBufferSize) {
+      validateUint32(options.sendBufferSize, 'options.sendBufferSize');
+    }
+    recvBufferSize = options.recvBufferSize;
+    sendBufferSize = options.sendBufferSize;
+    if (options.receiveBlockList) {
+      if (!lazyLoadBlockList().isBlockList(options.receiveBlockList)) {
+        throw new ERR_INVALID_ARG_TYPE('options.receiveBlockList', 'net.BlockList', options.receiveBlockList);
+      }
+      receiveBlockList = options.receiveBlockList;
+    }
+    if (options.sendBlockList) {
+      if (!lazyLoadBlockList().isBlockList(options.sendBlockList)) {
+        throw new ERR_INVALID_ARG_TYPE('options.sendBlockList', 'net.BlockList', options.sendBlockList);
+      }
+      sendBlockList = options.sendBlockList;
+    }
+  }
+
+  const handle = newHandle(type, lookup);
+  handle[owner_symbol] = this;
+
+  this[async_id_symbol] = handle.getAsyncId();
+  this.type = type;
+
+  if (typeof listener === 'function')
+    this.on('message', listener);
+
+  this[kStateSymbol] = {
+    handle,
+    receiving: false,
+    bindState: BIND_STATE_UNBOUND,
+    connectState: CONNECT_STATE_DISCONNECTED,
+    queue: undefined,
+    reuseAddr: options?.reuseAddr, // Use UV_UDP_REUSEADDR if true.
+    reusePort: options?.reusePort,
+    ipv6Only: options?.ipv6Only,
+    recvBufferSize,
+    sendBufferSize,
+    receiveBlockList,
+    sendBlockList,
+  };
+
+  if (options?.signal !== undefined) {
+    const { signal } = options;
+    validateAbortSignal(signal, 'options.signal');
+    const onAborted = () => {
+      if (this[kStateSymbol].handle) this.close();
+    };
+    if (signal.aborted) {
+      onAborted();
+    } else {
+      const disposable = addAbortListener(signal, onAborted);
+      this.once('close', disposable[SymbolDispose]);
+    }
+  }
+  if (udpSocketChannel.hasSubscribers) {
+    udpSocketChannel.publish({
+      socket: this,
+    });
+  }
+}
+ObjectSetPrototypeOf(Socket.prototype, EventEmitter.prototype);
+ObjectSetPrototypeOf(Socket, EventEmitter);
+
+
+function createSocket(type, listener) {
+  return new Socket(type, listener);
+}
+
+
+function startListening(socket) {
+  const state = socket[kStateSymbol];
+
+  state.handle.onmessage = onMessage;
+  state.handle.onerror = onError;
+  state.handle.recvStart();
+  state.receiving = true;
+  state.bindState = BIND_STATE_BOUND;
+
+  if (state.recvBufferSize)
+    bufferSize(socket, state.recvBufferSize, RECV_BUFFER);
+
+  if (state.sendBufferSize)
+    bufferSize(socket, state.sendBufferSize, SEND_BUFFER);
+
+  socket.emit('listening');
+}
+
+function replaceHandle(self, newHandle) {
+  const state = self[kStateSymbol];
+  const oldHandle = state.handle;
+  // Sync the old handle state to new handle
+  if (!oldHandle.hasRef() && typeof newHandle.unref === 'function') {
+    newHandle.unref();
+  }
+  // Set up the handle that we got from primary.
+  newHandle.lookup = oldHandle.lookup;
+  newHandle.bind = oldHandle.bind;
+  newHandle.send = oldHandle.send;
+  newHandle[owner_symbol] = self;
+
+  // Replace the existing handle by the handle we got from primary.
+  oldHandle.close();
+  state.handle = newHandle;
+}
+
+function bufferSize(self, size, buffer) {
+  if (size >>> 0 !== size)
+    throw new ERR_SOCKET_BAD_BUFFER_SIZE();
+
+  const ctx = {};
+  const ret = self[kStateSymbol].handle.bufferSize(size, buffer, ctx);
+  if (ret === undefined) {
+    throw new ERR_SOCKET_BUFFER_SIZE(ctx);
+  }
+  return ret;
+}
+
+// Query primary process to get the server handle and utilize it.
+function bindServerHandle(self, options, errCb) {
+  const cluster = lazyLoadCluster();
+
+  const state = self[kStateSymbol];
+  cluster._getServer(self, options, (err, handle) => {
+    if (err) {
+      // Do not call callback if socket is closed
+      if (state.handle) {
+        errCb(err);
+      }
+      return;
+    }
+
+    if (!state.handle) {
+      // Handle has been closed in the mean time.
+      return handle.close();
+    }
+
+    replaceHandle(self, handle);
+    startListening(self);
+  });
+}
+
+Socket.prototype.bind = function(port_, address_ /* , callback */) {
+  let port = port_;
+
+  healthCheck(this);
+  const state = this[kStateSymbol];
+
+  if (state.bindState !== BIND_STATE_UNBOUND)
+    throw new ERR_SOCKET_ALREADY_BOUND();
+
+  state.bindState = BIND_STATE_BINDING;
+
+  const cb = arguments.length && arguments[arguments.length - 1];
+  if (typeof cb === 'function') {
+    function removeListeners() {
+      this.removeListener('error', removeListeners);
+      this.removeListener('listening', onListening);
+    }
+
+    function onListening() {
+      FunctionPrototypeCall(removeListeners, this);
+      FunctionPrototypeCall(cb, this);
+    }
+
+    this.on('error', removeListeners);
+    this.on('listening', onListening);
+  }
+
+  if (port !== null &&
+      typeof port === 'object' &&
+      typeof port.recvStart === 'function') {
+    replaceHandle(this, port);
+    startListening(this);
+    return this;
+  }
+
+  // Open an existing fd instead of creating a new one.
+  if (port !== null && typeof port === 'object' &&
+      isInt32(port.fd) && port.fd > 0) {
+    const fd = port.fd;
+    const exclusive = !!port.exclusive;
+    const state = this[kStateSymbol];
+
+    const cluster = lazyLoadCluster();
+
+    if (cluster.isWorker && !exclusive) {
+      bindServerHandle(this, {
+        address: null,
+        port: null,
+        addressType: this.type,
+        fd,
+        flags: null,
+      }, (err) => {
+        // Callback to handle error.
+        const ex = new ErrnoException(err, 'open');
+        state.bindState = BIND_STATE_UNBOUND;
+        this.emit('error', ex);
+      });
+      return this;
+    }
+
+    const type = guessHandleType(fd);
+    if (type !== 'UDP')
+      throw new ERR_INVALID_FD_TYPE(type);
+    const err = state.handle.open(fd);
+
+    if (err)
+      throw new ErrnoException(err, 'open');
+
+    startListening(this);
+    return this;
+  }
+
+  let address;
+  let exclusive;
+
+  if (port !== null && typeof port === 'object') {
+    address = port.address || '';
+    exclusive = !!port.exclusive;
+    port = port.port;
+  } else {
+    address = typeof address_ === 'function' ? '' : address_;
+    exclusive = false;
+  }
+
+  // Defaulting address for bind to all interfaces
+  if (!address) {
+    if (this.type === 'udp4')
+      address = '0.0.0.0';
+    else
+      address = '::';
+  }
+
+  // Resolve address first
+  state.handle.lookup(address, (err, ip) => {
+    if (!state.handle)
+      return; // Handle has been closed in the mean time
+
+    if (err) {
+      state.bindState = BIND_STATE_UNBOUND;
+      this.emit('error', err);
+      return;
+    }
+
+    const cluster = lazyLoadCluster();
+
+    let flags = 0;
+    if (state.reuseAddr)
+      flags |= UV_UDP_REUSEADDR;
+    if (state.ipv6Only)
+      flags |= UV_UDP_IPV6ONLY;
+    if (state.reusePort) {
+      exclusive = true;
+      flags |= UV_UDP_REUSEPORT;
+    }
+
+    if (cluster.isWorker && !exclusive) {
+      bindServerHandle(this, {
+        address: ip,
+        port: port,
+        addressType: this.type,
+        fd: -1,
+        flags: flags,
+      }, (err) => {
+        // Callback to handle error.
+        const ex = new ExceptionWithHostPort(err, 'bind', ip, port);
+        state.bindState = BIND_STATE_UNBOUND;
+        this.emit('error', ex);
+      });
+    } else {
+      const err = state.handle.bind(ip, port || 0, flags);
+      if (err) {
+        const ex = new ExceptionWithHostPort(err, 'bind', ip, port);
+        state.bindState = BIND_STATE_UNBOUND;
+        this.emit('error', ex);
+        // Todo: close?
+        return;
+      }
+
+      startListening(this);
+    }
+  });
+
+  return this;
+};
+
+Socket.prototype.connect = function(port, address, callback) {
+  port = validatePort(port, 'Port', false);
+  if (typeof address === 'function') {
+    callback = address;
+    address = '';
+  } else if (address === undefined) {
+    address = '';
+  }
+
+  validateString(address, 'address');
+
+  const state = this[kStateSymbol];
+
+  if (state.connectState !== CONNECT_STATE_DISCONNECTED)
+    throw new ERR_SOCKET_DGRAM_IS_CONNECTED();
+
+  state.connectState = CONNECT_STATE_CONNECTING;
+  if (state.bindState === BIND_STATE_UNBOUND)
+    this.bind({ port: 0, exclusive: true }, null);
+
+  if (state.bindState !== BIND_STATE_BOUND) {
+    enqueue(this, FunctionPrototypeBind(_connect, this,
+                                        port, address, callback));
+    return;
+  }
+
+  ReflectApply(_connect, this, [port, address, callback]);
+};
+
+
+function _connect(port, address, callback) {
+  const state = this[kStateSymbol];
+  if (callback)
+    this.once('connect', callback);
+
+  const afterDns = (ex, ip) => {
+    defaultTriggerAsyncIdScope(
+      this[async_id_symbol],
+      doConnect,
+      ex, this, ip, address, port, callback,
+    );
+  };
+
+  state.handle.lookup(address, afterDns);
+}
+
+
+function doConnect(ex, self, ip, address, port, callback) {
+  const state = self[kStateSymbol];
+  if (!state.handle)
+    return;
+  if (!ex && state.sendBlockList?.check(ip, `ipv${isIP(ip)}`)) {
+    ex = new ERR_IP_BLOCKED(ip);
+  }
+  if (!ex) {
+    const err = state.handle.connect(ip, port);
+    if (err) {
+      ex = new ExceptionWithHostPort(err, 'connect', address, port);
+    }
+  }
+
+  if (ex) {
+    state.connectState = CONNECT_STATE_DISCONNECTED;
+    return process.nextTick(() => {
+      if (callback) {
+        self.removeListener('connect', callback);
+        callback(ex);
+      } else {
+        self.emit('error', ex);
+      }
+    });
+  }
+
+  state.connectState = CONNECT_STATE_CONNECTED;
+  process.nextTick(() => self.emit('connect'));
+}
+
+
+Socket.prototype.disconnect = function() {
+  const state = this[kStateSymbol];
+  if (state.connectState !== CONNECT_STATE_CONNECTED)
+    throw new ERR_SOCKET_DGRAM_NOT_CONNECTED();
+
+  const err = state.handle.disconnect();
+  if (err)
+    throw new ErrnoException(err, 'connect');
+  else
+    state.connectState = CONNECT_STATE_DISCONNECTED;
+};
+
+
+// Thin wrapper around `send`, here for compatibility with dgram_legacy.js
+Socket.prototype.sendto = function(buffer,
+                                   offset,
+                                   length,
+                                   port,
+                                   address,
+                                   callback) {
+  validateNumber(offset, 'offset');
+  validateNumber(length, 'length');
+  validateNumber(port, 'port');
+  validateString(address, 'address');
+
+  this.send(buffer, offset, length, port, address, callback);
+};
+
+
+function sliceBuffer(buffer, offset, length) {
+  if (typeof buffer === 'string') {
+    buffer = Buffer.from(buffer);
+  } else if (!isArrayBufferView(buffer)) {
+    throw new ERR_INVALID_ARG_TYPE('buffer',
+                                   ['Buffer',
+                                    'TypedArray',
+                                    'DataView',
+                                    'string'],
+                                   buffer);
+  }
+
+  offset = offset >>> 0;
+  length = length >>> 0;
+  if (offset > buffer.byteLength) {
+    throw new ERR_BUFFER_OUT_OF_BOUNDS('offset');
+  }
+
+  if (offset + length > buffer.byteLength) {
+    throw new ERR_BUFFER_OUT_OF_BOUNDS('length');
+  }
+
+  return Buffer.from(buffer.buffer, buffer.byteOffset + offset, length);
+}
+
+
+function fixBufferList(list) {
+  const newlist = new Array(list.length);
+
+  for (let i = 0, l = list.length; i < l; i++) {
+    const buf = list[i];
+    if (typeof buf === 'string')
+      newlist[i] = Buffer.from(buf);
+    else if (Buffer.isBuffer(buf))
+      newlist[i] = buf;
+    else if (!isArrayBufferView(buf))
+      return null;
+    else
+      newlist[i] = Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+
+  return newlist;
+}
+
+
+function enqueue(self, toEnqueue) {
+  const state = self[kStateSymbol];
+
+  // If the send queue hasn't been initialized yet, do it, and install an
+  // event handler that flushes the send queue after binding is done.
+  if (state.queue === undefined) {
+    state.queue = [];
+    self.once(EventEmitter.errorMonitor, onListenError);
+    self.once('listening', onListenSuccess);
+  }
+  ArrayPrototypePush(state.queue, toEnqueue);
+}
+
+
+function onListenSuccess() {
+  this.removeListener(EventEmitter.errorMonitor, onListenError);
+  FunctionPrototypeCall(clearQueue, this);
+}
+
+
+function onListenError(err) {
+  this.removeListener('listening', onListenSuccess);
+  this[kStateSymbol].queue = undefined;
+}
+
+
+function clearQueue() {
+  const state = this[kStateSymbol];
+  const queue = state.queue;
+  state.queue = undefined;
+
+  // Flush the send queue.
+  for (const queueEntry of queue)
+    queueEntry();
+}
+
+// valid combinations
+// For connectionless sockets
+// send(buffer, offset, length, port, address, callback)
+// send(buffer, offset, length, port, address)
+// send(buffer, offset, length, port, callback)
+// send(buffer, offset, length, port)
+// send(bufferOrList, port, address, callback)
+// send(bufferOrList, port, address)
+// send(bufferOrList, port, callback)
+// send(bufferOrList, port)
+// For connected sockets
+// send(buffer, offset, length, callback)
+// send(buffer, offset, length)
+// send(bufferOrList, callback)
+// send(bufferOrList)
+Socket.prototype.send = function(buffer,
+                                 offset,
+                                 length,
+                                 port,
+                                 address,
+                                 callback) {
+
+  let list;
+  const state = this[kStateSymbol];
+  const connected = state.connectState === CONNECT_STATE_CONNECTED;
+  if (!connected) {
+    if (address || (port && typeof port !== 'function')) {
+      buffer = sliceBuffer(buffer, offset, length);
+    } else {
+      callback = port;
+      port = offset;
+      address = length;
+    }
+  } else {
+    if (typeof length === 'number') {
+      buffer = sliceBuffer(buffer, offset, length);
+      if (typeof port === 'function') {
+        callback = port;
+        port = null;
+      }
+    } else {
+      callback = offset;
+    }
+
+    if (port || address)
+      throw new ERR_SOCKET_DGRAM_IS_CONNECTED();
+  }
+
+  if (!ArrayIsArray(buffer)) {
+    if (typeof buffer === 'string') {
+      list = [ Buffer.from(buffer) ];
+    } else if (!isArrayBufferView(buffer)) {
+      throw new ERR_INVALID_ARG_TYPE('buffer',
+                                     ['Buffer',
+                                      'TypedArray',
+                                      'DataView',
+                                      'string'],
+                                     buffer);
+    } else {
+      list = [ buffer ];
+    }
+  } else if (!(list = fixBufferList(buffer))) {
+    throw new ERR_INVALID_ARG_TYPE('buffer list arguments',
+                                   ['Buffer',
+                                    'TypedArray',
+                                    'DataView',
+                                    'string'],
+                                   buffer);
+  }
+
+  if (!connected)
+    port = validatePort(port, 'Port', false);
+
+  // Normalize callback so it's either a function or undefined but not anything
+  // else.
+  if (typeof callback !== 'function')
+    callback = undefined;
+
+  if (typeof address === 'function') {
+    callback = address;
+    address = undefined;
+  } else if (address != null) {
+    validateString(address, 'address');
+  }
+
+  healthCheck(this);
+
+  if (state.bindState === BIND_STATE_UNBOUND)
+    this.bind({ port: 0, exclusive: true }, null);
+
+  if (list.length === 0)
+    ArrayPrototypePush(list, Buffer.alloc(0));
+
+  // If the socket hasn't been bound yet, push the outbound packet onto the
+  // send queue and send after binding is complete.
+  if (state.bindState !== BIND_STATE_BOUND) {
+    enqueue(this, FunctionPrototypeBind(this.send, this,
+                                        list, port, address, callback));
+    return;
+  }
+
+  const afterDns = (ex, ip) => {
+    defaultTriggerAsyncIdScope(
+      this[async_id_symbol],
+      doSend,
+      ex, this, ip, list, address, port, callback,
+    );
+  };
+
+  if (!connected) {
+    state.handle.lookup(address, afterDns);
+  } else {
+    afterDns(null, null);
+  }
+};
+
+function doSend(ex, self, ip, list, address, port, callback) {
+  const state = self[kStateSymbol];
+
+  if (ex) {
+    if (typeof callback === 'function') {
+      process.nextTick(callback, ex);
+      return;
+    }
+
+    process.nextTick(() => self.emit('error', ex));
+    return;
+  } else if (!state.handle) {
+    return;
+  }
+
+  if (ip && state.sendBlockList?.check(ip, `ipv${isIP(ip)}`)) {
+    if (callback) {
+      process.nextTick(callback, new ERR_IP_BLOCKED(ip));
+    }
+    return;
+  }
+
+  const req = new SendWrap();
+  req.list = list;  // Keep reference alive.
+  req.address = address;
+  req.port = port;
+  if (callback) {
+    req.callback = callback;
+    req.oncomplete = afterSend;
+  }
+
+  let err;
+  if (port)
+    err = state.handle.send(req, list, list.length, port, ip, !!callback);
+  else
+    err = state.handle.send(req, list, list.length, !!callback);
+
+  if (err >= 1) {
+    // Synchronous finish. The return code is msg_length + 1 so that we can
+    // distinguish between synchronous success and asynchronous success.
+    if (callback)
+      process.nextTick(callback, null, err - 1);
+    return;
+  }
+
+  if (err && callback) {
+    // Don't emit as error, dgram_legacy.js compatibility
+    const ex = new ExceptionWithHostPort(err, 'send', address, port);
+    process.nextTick(callback, ex);
+  }
+}
+
+function afterSend(err, sent) {
+  if (err) {
+    err = new ExceptionWithHostPort(err, 'send', this.address, this.port);
+  } else {
+    err = null;
+  }
+
+  this.callback(err, sent);
+}
+
+Socket.prototype.close = function(callback) {
+  const state = this[kStateSymbol];
+  const queue = state.queue;
+
+  if (typeof callback === 'function')
+    this.on('close', callback);
+
+  if (queue !== undefined) {
+    ArrayPrototypePush(queue, FunctionPrototypeBind(this.close, this));
+    return this;
+  }
+
+  healthCheck(this);
+  stopReceiving(this);
+  state.handle.close();
+  state.handle = null;
+  defaultTriggerAsyncIdScope(this[async_id_symbol],
+                             process.nextTick,
+                             socketCloseNT,
+                             this);
+
+  return this;
+};
+
+Socket.prototype[SymbolAsyncDispose] = async function() {
+  if (!this[kStateSymbol].handle) {
+    return;
+  }
+  await FunctionPrototypeCall(promisify(this.close), this);
+};
+
+
+function socketCloseNT(self) {
+  self.emit('close');
+}
+
+
+Socket.prototype.address = function() {
+  healthCheck(this);
+
+  const out = {};
+  const err = this[kStateSymbol].handle.getsockname(out);
+  if (err) {
+    throw new ErrnoException(err, 'getsockname');
+  }
+
+  return out;
+};
+
+Socket.prototype.remoteAddress = function() {
+  healthCheck(this);
+
+  const state = this[kStateSymbol];
+  if (state.connectState !== CONNECT_STATE_CONNECTED)
+    throw new ERR_SOCKET_DGRAM_NOT_CONNECTED();
+
+  const out = {};
+  const err = state.handle.getpeername(out);
+  if (err)
+    throw new ErrnoException(err, 'getpeername');
+
+  return out;
+};
+
+
+Socket.prototype.setBroadcast = function(arg) {
+  const err = this[kStateSymbol].handle.setBroadcast(arg ? 1 : 0);
+  if (err) {
+    throw new ErrnoException(err, 'setBroadcast');
+  }
+};
+
+
+Socket.prototype.setTTL = function(ttl) {
+  validateNumber(ttl, 'ttl');
+
+  const err = this[kStateSymbol].handle.setTTL(ttl);
+  if (err) {
+    throw new ErrnoException(err, 'setTTL');
+  }
+
+  return ttl;
+};
+
+
+Socket.prototype.setMulticastTTL = function(ttl) {
+  validateNumber(ttl, 'ttl');
+
+  const err = this[kStateSymbol].handle.setMulticastTTL(ttl);
+  if (err) {
+    throw new ErrnoException(err, 'setMulticastTTL');
+  }
+
+  return ttl;
+};
+
+
+Socket.prototype.setMulticastLoopback = function(arg) {
+  const err = this[kStateSymbol].handle.setMulticastLoopback(arg ? 1 : 0);
+  if (err) {
+    throw new ErrnoException(err, 'setMulticastLoopback');
+  }
+
+  return arg; // 0.4 compatibility
+};
+
+
+Socket.prototype.setMulticastInterface = function(interfaceAddress) {
+  healthCheck(this);
+  validateString(interfaceAddress, 'interfaceAddress');
+
+  const err = this[kStateSymbol].handle.setMulticastInterface(interfaceAddress);
+  if (err) {
+    throw new ErrnoException(err, 'setMulticastInterface');
+  }
+};
+
+Socket.prototype.addMembership = function(multicastAddress,
+                                          interfaceAddress) {
+  healthCheck(this);
+
+  if (!multicastAddress) {
+    throw new ERR_MISSING_ARGS('multicastAddress');
+  }
+
+  const { handle } = this[kStateSymbol];
+  const err = handle.addMembership(multicastAddress, interfaceAddress);
+  if (err) {
+    throw new ErrnoException(err, 'addMembership');
+  }
+};
+
+
+Socket.prototype.dropMembership = function(multicastAddress,
+                                           interfaceAddress) {
+  healthCheck(this);
+
+  if (!multicastAddress) {
+    throw new ERR_MISSING_ARGS('multicastAddress');
+  }
+
+  const { handle } = this[kStateSymbol];
+  const err = handle.dropMembership(multicastAddress, interfaceAddress);
+  if (err) {
+    throw new ErrnoException(err, 'dropMembership');
+  }
+};
+
+Socket.prototype.addSourceSpecificMembership = function(sourceAddress,
+                                                        groupAddress,
+                                                        interfaceAddress) {
+  healthCheck(this);
+
+  validateString(sourceAddress, 'sourceAddress');
+  validateString(groupAddress, 'groupAddress');
+
+  const err =
+    this[kStateSymbol].handle.addSourceSpecificMembership(sourceAddress,
+                                                          groupAddress,
+                                                          interfaceAddress);
+  if (err) {
+    throw new ErrnoException(err, 'addSourceSpecificMembership');
+  }
+};
+
+
+Socket.prototype.dropSourceSpecificMembership = function(sourceAddress,
+                                                         groupAddress,
+                                                         interfaceAddress) {
+  healthCheck(this);
+
+  validateString(sourceAddress, 'sourceAddress');
+  validateString(groupAddress, 'groupAddress');
+
+  const err =
+    this[kStateSymbol].handle.dropSourceSpecificMembership(sourceAddress,
+                                                           groupAddress,
+                                                           interfaceAddress);
+  if (err) {
+    throw new ErrnoException(err, 'dropSourceSpecificMembership');
+  }
+};
+
+
+function healthCheck(socket) {
+  if (!socket[kStateSymbol].handle) {
+    // Error message from dgram_legacy.js.
+    throw new ERR_SOCKET_DGRAM_NOT_RUNNING();
+  }
+}
+
+
+function stopReceiving(socket) {
+  const state = socket[kStateSymbol];
+
+  if (!state.receiving)
+    return;
+
+  state.handle.recvStop();
+  state.receiving = false;
+}
+
+
+function onMessage(nread, handle, buf, rinfo) {
+  const self = handle[owner_symbol];
+  if (nread < 0) {
+    return self.emit('error', new ErrnoException(nread, 'recvmsg'));
+  }
+  if (self[kStateSymbol]?.receiveBlockList?.check(rinfo.address,
+                                                  rinfo.family?.toLocaleLowerCase())) {
+    return;
+  }
+  rinfo.size = buf.length; // compatibility
+  self.emit('message', buf, rinfo);
+}
+
+
+function onError(nread, handle, error) {
+  const self = handle[owner_symbol];
+  return self.emit('error', error);
+}
+
+
+Socket.prototype.ref = function() {
+  const handle = this[kStateSymbol].handle;
+
+  if (handle)
+    handle.ref();
+
+  return this;
+};
+
+
+Socket.prototype.unref = function() {
+  const handle = this[kStateSymbol].handle;
+
+  if (handle)
+    handle.unref();
+
+  return this;
+};
+
+
+Socket.prototype.setRecvBufferSize = function(size) {
+  bufferSize(this, size, RECV_BUFFER);
+};
+
+
+Socket.prototype.setSendBufferSize = function(size) {
+  bufferSize(this, size, SEND_BUFFER);
+};
+
+
+Socket.prototype.getRecvBufferSize = function() {
+  return bufferSize(this, 0, RECV_BUFFER);
+};
+
+
+Socket.prototype.getSendBufferSize = function() {
+  return bufferSize(this, 0, SEND_BUFFER);
+};
+
+Socket.prototype.getSendQueueSize = function() {
+  return this[kStateSymbol].handle.getSendQueueSize();
+};
+
+Socket.prototype.getSendQueueCount = function() {
+  return this[kStateSymbol].handle.getSendQueueCount();
+};
+
+// Deprecated private APIs.
+ObjectDefineProperty(Socket.prototype, '_handle', {
+  __proto__: null,
+  get: deprecate(function() {
+    return this[kStateSymbol].handle;
+  }, 'Socket.prototype._handle is deprecated', 'DEP0112'),
+  set: deprecate(function(val) {
+    this[kStateSymbol].handle = val;
+  }, 'Socket.prototype._handle is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_receiving', {
+  __proto__: null,
+  get: deprecate(function() {
+    return this[kStateSymbol].receiving;
+  }, 'Socket.prototype._receiving is deprecated', 'DEP0112'),
+  set: deprecate(function(val) {
+    this[kStateSymbol].receiving = val;
+  }, 'Socket.prototype._receiving is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_bindState', {
+  __proto__: null,
+  get: deprecate(function() {
+    return this[kStateSymbol].bindState;
+  }, 'Socket.prototype._bindState is deprecated', 'DEP0112'),
+  set: deprecate(function(val) {
+    this[kStateSymbol].bindState = val;
+  }, 'Socket.prototype._bindState is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_queue', {
+  __proto__: null,
+  get: deprecate(function() {
+    return this[kStateSymbol].queue;
+  }, 'Socket.prototype._queue is deprecated', 'DEP0112'),
+  set: deprecate(function(val) {
+    this[kStateSymbol].queue = val;
+  }, 'Socket.prototype._queue is deprecated', 'DEP0112'),
+});
+
+
+ObjectDefineProperty(Socket.prototype, '_reuseAddr', {
+  __proto__: null,
+  get: deprecate(function() {
+    return this[kStateSymbol].reuseAddr;
+  }, 'Socket.prototype._reuseAddr is deprecated', 'DEP0112'),
+  set: deprecate(function(val) {
+    this[kStateSymbol].reuseAddr = val;
+  }, 'Socket.prototype._reuseAddr is deprecated', 'DEP0112'),
+});
+
+
+Socket.prototype._healthCheck = deprecate(function() {
+  healthCheck(this);
+}, 'Socket.prototype._healthCheck() is deprecated', 'DEP0112');
+
+
+Socket.prototype._stopReceiving = deprecate(function() {
+  stopReceiving(this);
+}, 'Socket.prototype._stopReceiving() is deprecated', 'DEP0112');
+
+
+// Legacy alias on the C++ wrapper object. This is not public API, so we may
+// want to runtime-deprecate it at some point. There's no hurry, though.
+ObjectDefineProperty(UDP.prototype, 'owner', {
+  __proto__: null,
+  get() { return this[owner_symbol]; },
+  set(v) { return this[owner_symbol] = v; },
+});
+
+
+module.exports = {
+  _createSocketHandle: deprecate(
+    _createSocketHandle,
+    'dgram._createSocketHandle() is deprecated',
+    'DEP0112',
+  ),
+  createSocket,
+  Socket,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/diagnostics_channel.js b/.codesandbox/node/diagnostics_channel.js
new file mode 100644
index 0000000000..1422b0dbdf
--- /dev/null
+++ b/.codesandbox/node/diagnostics_channel.js
@@ -0,0 +1,439 @@
+"use strict";
+
+const {
+  ArrayPrototypeAt,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypePushApply,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ObjectDefineProperty,
+  ObjectGetPrototypeOf,
+  ObjectSetPrototypeOf,
+  Promise,
+  PromisePrototypeThen,
+  PromiseReject,
+  PromiseResolve,
+  ReflectApply,
+  SafeFinalizationRegistry,
+  SafeMap,
+  SymbolHasInstance,
+} = primordials;
+
+const {
+  codes: { ERR_INVALID_ARG_TYPE },
+} = require("internal/errors");
+const { validateFunction } = require("internal/validators");
+
+const { triggerUncaughtException } = internalBinding("errors");
+
+const { WeakReference } = require("internal/util");
+
+// Can't delete when weakref count reaches 0 as it could increment again.
+// Only GC can be used as a valid time to clean up the channels map.
+class WeakRefMap extends SafeMap {
+  #finalizers = new SafeFinalizationRegistry((key) => {
+    // Check that the key doesn't have any value before deleting, as the WeakRef for the key
+    // may have been replaced since finalization callbacks aren't synchronous with GC.
+    if (!this.has(key)) this.delete(key);
+  });
+
+  set(key, value) {
+    this.#finalizers.register(value, key);
+    return super.set(key, new WeakReference(value));
+  }
+
+  get(key) {
+    return super.get(key)?.get();
+  }
+
+  has(key) {
+    return !!this.get(key);
+  }
+
+  incRef(key) {
+    return super.get(key)?.incRef();
+  }
+
+  decRef(key) {
+    return super.get(key)?.decRef();
+  }
+}
+
+function markActive(channel) {
+  // eslint-disable-next-line no-use-before-define
+  ObjectSetPrototypeOf(channel, ActiveChannel.prototype);
+  channel._subscribers = [];
+  channel._stores = new SafeMap();
+}
+
+function maybeMarkInactive(channel) {
+  // When there are no more active subscribers or bound, restore to fast prototype.
+  if (!channel._subscribers.length && !channel._stores.size) {
+    // eslint-disable-next-line no-use-before-define
+    ObjectSetPrototypeOf(channel, Channel.prototype);
+    channel._subscribers = undefined;
+    channel._stores = undefined;
+  }
+}
+
+function defaultTransform(data) {
+  return data;
+}
+
+function wrapStoreRun(store, data, next, transform = defaultTransform) {
+  return () => {
+    let context;
+    try {
+      context = transform(data);
+    } catch (err) {
+      process.nextTick(() => {
+        triggerUncaughtException(err, false);
+      });
+      return next();
+    }
+
+    return store.run(context, next);
+  };
+}
+
+// TODO(qard): should there be a C++ channel interface?
+class ActiveChannel {
+  subscribe(subscription) {
+    validateFunction(subscription, "subscription");
+    this._subscribers = ArrayPrototypeSlice(this._subscribers);
+    ArrayPrototypePush(this._subscribers, subscription);
+    channels.incRef(this.name);
+  }
+
+  unsubscribe(subscription) {
+    const index = ArrayPrototypeIndexOf(this._subscribers, subscription);
+    if (index === -1) return false;
+
+    const before = ArrayPrototypeSlice(this._subscribers, 0, index);
+    const after = ArrayPrototypeSlice(this._subscribers, index + 1);
+    this._subscribers = before;
+    ArrayPrototypePushApply(this._subscribers, after);
+
+    channels.decRef(this.name);
+    maybeMarkInactive(this);
+
+    return true;
+  }
+
+  bindStore(store, transform) {
+    const replacing = this._stores.has(store);
+    if (!replacing) channels.incRef(this.name);
+    this._stores.set(store, transform);
+  }
+
+  unbindStore(store) {
+    if (!this._stores.has(store)) {
+      return false;
+    }
+
+    this._stores.delete(store);
+
+    channels.decRef(this.name);
+    maybeMarkInactive(this);
+
+    return true;
+  }
+
+  get hasSubscribers() {
+    return true;
+  }
+
+  publish(data) {
+    const subscribers = this._subscribers;
+    for (let i = 0; i < (subscribers?.length || 0); i++) {
+      try {
+        const onMessage = subscribers[i];
+        onMessage(data, this.name);
+      } catch (err) {
+        process.nextTick(() => {
+          triggerUncaughtException(err, false);
+        });
+      }
+    }
+  }
+
+  runStores(data, fn, thisArg, ...args) {
+    let run = () => {
+      this.publish(data);
+      return ReflectApply(fn, thisArg, args);
+    };
+
+    for (const entry of this._stores.entries()) {
+      const store = entry[0];
+      const transform = entry[1];
+      run = wrapStoreRun(store, data, run, transform);
+    }
+
+    return run();
+  }
+}
+
+class Channel {
+  constructor(name) {
+    this._subscribers = undefined;
+    this._stores = undefined;
+    this.name = name;
+
+    channels.set(name, this);
+  }
+
+  static [SymbolHasInstance](instance) {
+    const prototype = ObjectGetPrototypeOf(instance);
+    return (
+      prototype === Channel.prototype || prototype === ActiveChannel.prototype
+    );
+  }
+
+  subscribe(subscription) {
+    markActive(this);
+    this.subscribe(subscription);
+  }
+
+  unsubscribe() {
+    return false;
+  }
+
+  bindStore(store, transform) {
+    markActive(this);
+    this.bindStore(store, transform);
+  }
+
+  unbindStore() {
+    return false;
+  }
+
+  get hasSubscribers() {
+    return false;
+  }
+
+  publish() {}
+
+  runStores(data, fn, thisArg, ...args) {
+    return ReflectApply(fn, thisArg, args);
+  }
+}
+
+const channels = new WeakRefMap();
+
+function channel(name) {
+  const channel = channels.get(name);
+  if (channel) return channel;
+
+  if (typeof name !== "string" && typeof name !== "symbol") {
+    throw new ERR_INVALID_ARG_TYPE("channel", ["string", "symbol"], name);
+  }
+
+  return new Channel(name);
+}
+
+function subscribe(name, subscription) {
+  return channel(name).subscribe(subscription);
+}
+
+function unsubscribe(name, subscription) {
+  return channel(name).unsubscribe(subscription);
+}
+
+function hasSubscribers(name) {
+  const channel = channels.get(name);
+  if (!channel) return false;
+
+  return channel.hasSubscribers;
+}
+
+const traceEvents = ["start", "end", "asyncStart", "asyncEnd", "error"];
+
+function assertChannel(value, name) {
+  if (!(value instanceof Channel)) {
+    throw new ERR_INVALID_ARG_TYPE(name, ["Channel"], value);
+  }
+}
+
+function tracingChannelFrom(nameOrChannels, name) {
+  if (typeof nameOrChannels === "string") {
+    return channel(`tracing:${nameOrChannels}:${name}`);
+  }
+
+  if (typeof nameOrChannels === "object" && nameOrChannels !== null) {
+    const channel = nameOrChannels[name];
+    assertChannel(channel, `nameOrChannels.${name}`);
+    return channel;
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    "nameOrChannels",
+    ["string", "object", "TracingChannel"],
+    nameOrChannels
+  );
+}
+
+class TracingChannel {
+  constructor(nameOrChannels) {
+    for (let i = 0; i < traceEvents.length; ++i) {
+      const eventName = traceEvents[i];
+      ObjectDefineProperty(this, eventName, {
+        __proto__: null,
+        value: tracingChannelFrom(nameOrChannels, eventName),
+      });
+    }
+  }
+
+  get hasSubscribers() {
+    return (
+      this.start?.hasSubscribers ||
+      this.end?.hasSubscribers ||
+      this.asyncStart?.hasSubscribers ||
+      this.asyncEnd?.hasSubscribers ||
+      this.error?.hasSubscribers
+    );
+  }
+
+  subscribe(handlers) {
+    for (let i = 0; i < traceEvents.length; ++i) {
+      const name = traceEvents[i];
+      if (!handlers[name]) continue;
+
+      this[name]?.subscribe(handlers[name]);
+    }
+  }
+
+  unsubscribe(handlers) {
+    let done = true;
+
+    for (let i = 0; i < traceEvents.length; ++i) {
+      const name = traceEvents[i];
+      if (!handlers[name]) continue;
+
+      if (!this[name]?.unsubscribe(handlers[name])) {
+        done = false;
+      }
+    }
+
+    return done;
+  }
+
+  traceSync(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
+    const { start, end, error } = this;
+
+    return start.runStores(context, () => {
+      try {
+        const result = ReflectApply(fn, thisArg, args);
+        context.result = result;
+        return result;
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+
+  tracePromise(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
+    const { start, end, asyncStart, asyncEnd, error } = this;
+
+    function reject(err) {
+      context.error = err;
+      error.publish(context);
+      asyncStart.publish(context);
+      // TODO: Is there a way to have asyncEnd _after_ the continuation?
+      asyncEnd.publish(context);
+      return PromiseReject(err);
+    }
+
+    function resolve(result) {
+      context.result = result;
+      asyncStart.publish(context);
+      // TODO: Is there a way to have asyncEnd _after_ the continuation?
+      asyncEnd.publish(context);
+      return result;
+    }
+
+    return start.runStores(context, () => {
+      try {
+        let promise = ReflectApply(fn, thisArg, args);
+        // Convert thenables to native promises
+        if (!(promise instanceof Promise)) {
+          promise = PromiseResolve(promise);
+        }
+        return PromisePrototypeThen(promise, resolve, reject);
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+
+  traceCallback(fn, position = -1, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
+    const { start, end, asyncStart, asyncEnd, error } = this;
+
+    function wrappedCallback(err, res) {
+      if (err) {
+        context.error = err;
+        error.publish(context);
+      } else {
+        context.result = res;
+      }
+
+      // Using runStores here enables manual context failure recovery
+      asyncStart.runStores(context, () => {
+        try {
+          return ReflectApply(callback, this, arguments);
+        } finally {
+          asyncEnd.publish(context);
+        }
+      });
+    }
+
+    const callback = ArrayPrototypeAt(args, position);
+    validateFunction(callback, "callback");
+    ArrayPrototypeSplice(args, position, 1, wrappedCallback);
+
+    return start.runStores(context, () => {
+      try {
+        return ReflectApply(fn, thisArg, args);
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+}
+
+function tracingChannel(nameOrChannels) {
+  return new TracingChannel(nameOrChannels);
+}
+
+module.exports = {
+  channel,
+  hasSubscribers,
+  subscribe,
+  tracingChannel,
+  unsubscribe,
+  Channel,
+};
diff --git a/.codesandbox/node/dns.js b/.codesandbox/node/dns.js
new file mode 100644
index 0000000000..22d23dea58
--- /dev/null
+++ b/.codesandbox/node/dns.js
@@ -0,0 +1,345 @@
+"use strict";
+
+const { ObjectDefineProperties, ObjectDefineProperty, Symbol } = primordials;
+
+const cares = internalBinding("cares_wrap");
+const { isIP } = require("internal/net");
+const { customPromisifyArgs } = require("internal/util");
+const {
+  DNSException,
+  codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS },
+} = require("internal/errors");
+const {
+  bindDefaultResolver,
+  setDefaultResolver,
+  validateHints,
+  getDefaultResultOrder,
+  setDefaultResultOrder,
+  errorCodes: dnsErrorCodes,
+  validDnsOrders,
+  validFamilies,
+} = require("internal/dns/utils");
+const { Resolver } = require("internal/dns/callback_resolver");
+const {
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  LOADIPHLPAPI,
+  ADDRGETNETWORKPARAMS,
+  CANCELLED,
+} = dnsErrorCodes;
+const {
+  validateBoolean,
+  validateFunction,
+  validateNumber,
+  validateOneOf,
+  validatePort,
+  validateString,
+} = require("internal/validators");
+
+const {
+  GetAddrInfoReqWrap,
+  GetNameInfoReqWrap,
+  DNS_ORDER_VERBATIM,
+  DNS_ORDER_IPV4_FIRST,
+  DNS_ORDER_IPV6_FIRST,
+} = cares;
+
+const kPerfHooksDnsLookupContext = Symbol("kPerfHooksDnsLookupContext");
+const kPerfHooksDnsLookupServiceContext = Symbol(
+  "kPerfHooksDnsLookupServiceContext"
+);
+
+const { hasObserver, startPerf, stopPerf } = require("internal/perf/observe");
+
+let promises = null; // Lazy loaded
+
+function onlookup(err, addresses) {
+  if (err) {
+    return this.callback(new DNSException(err, "getaddrinfo", this.hostname));
+  }
+  this.callback(null, addresses[0], this.family || isIP(addresses[0]));
+  if (this[kPerfHooksDnsLookupContext] && hasObserver("dns")) {
+    stopPerf(this, kPerfHooksDnsLookupContext, { detail: { addresses } });
+  }
+}
+
+function onlookupall(err, addresses) {
+  if (err) {
+    return this.callback(new DNSException(err, "getaddrinfo", this.hostname));
+  }
+
+  const family = this.family;
+  for (let i = 0; i < addresses.length; i++) {
+    const addr = addresses[i];
+    addresses[i] = {
+      address: addr,
+      family: family || isIP(addr),
+    };
+  }
+
+  this.callback(null, addresses);
+  if (this[kPerfHooksDnsLookupContext] && hasObserver("dns")) {
+    stopPerf(this, kPerfHooksDnsLookupContext, { detail: { addresses } });
+  }
+}
+
+// Easy DNS A/AAAA look up
+// lookup(hostname, [options,] callback)
+function lookup(hostname, options, callback) {
+  let hints = 0;
+  let family = 0;
+  let all = false;
+  let dnsOrder = getDefaultResultOrder();
+
+  // Parse arguments
+  if (hostname) {
+    validateString(hostname, "hostname");
+  }
+
+  if (typeof options === "function") {
+    callback = options;
+    family = 0;
+  } else if (typeof options === "number") {
+    validateFunction(callback, "callback");
+
+    validateOneOf(options, "family", validFamilies);
+    family = options;
+  } else if (options !== undefined && typeof options !== "object") {
+    validateFunction(arguments.length === 2 ? options : callback, "callback");
+    throw new ERR_INVALID_ARG_TYPE("options", ["integer", "object"], options);
+  } else {
+    validateFunction(callback, "callback");
+
+    if (options?.hints != null) {
+      validateNumber(options.hints, "options.hints");
+      hints = options.hints >>> 0;
+      validateHints(hints);
+    }
+    if (options?.family != null) {
+      switch (options.family) {
+        case "IPv4":
+          family = 4;
+          break;
+        case "IPv6":
+          family = 6;
+          break;
+        default:
+          validateOneOf(options.family, "options.family", validFamilies);
+          family = options.family;
+          break;
+      }
+    }
+    if (options?.all != null) {
+      validateBoolean(options.all, "options.all");
+      all = options.all;
+    }
+    if (options?.verbatim != null) {
+      validateBoolean(options.verbatim, "options.verbatim");
+      dnsOrder = options.verbatim ? "verbatim" : "ipv4first";
+    }
+    if (options?.order != null) {
+      validateOneOf(options.order, "options.order", validDnsOrders);
+      dnsOrder = options.order;
+    }
+  }
+
+  if (!hostname) {
+    throw new ERR_INVALID_ARG_VALUE(
+      "hostname",
+      hostname,
+      "must be a non-empty string"
+    );
+  }
+
+  const matchedFamily = isIP(hostname);
+  if (matchedFamily) {
+    if (all) {
+      process.nextTick(callback, null, [
+        { address: hostname, family: matchedFamily },
+      ]);
+    } else {
+      process.nextTick(callback, null, hostname, matchedFamily);
+    }
+    return {};
+  }
+
+  const req = new GetAddrInfoReqWrap();
+  req.callback = callback;
+  req.family = family;
+  req.hostname = hostname;
+  req.oncomplete = all ? onlookupall : onlookup;
+
+  let order = DNS_ORDER_VERBATIM;
+
+  if (dnsOrder === "ipv4first") {
+    order = DNS_ORDER_IPV4_FIRST;
+  } else if (dnsOrder === "ipv6first") {
+    order = DNS_ORDER_IPV6_FIRST;
+  }
+
+  const err = cares.getaddrinfo(req, hostname, family, hints, order);
+  if (err) {
+    process.nextTick(callback, new DNSException(err, "getaddrinfo", hostname));
+    return {};
+  }
+  if (hasObserver("dns")) {
+    const detail = {
+      hostname,
+      family,
+      hints,
+      verbatim: order === DNS_ORDER_VERBATIM,
+      order: dnsOrder,
+    };
+
+    startPerf(req, kPerfHooksDnsLookupContext, {
+      type: "dns",
+      name: "lookup",
+      detail,
+    });
+  }
+  return req;
+}
+
+ObjectDefineProperty(lookup, customPromisifyArgs, {
+  __proto__: null,
+  value: ["address", "family"],
+  enumerable: false,
+});
+
+function onlookupservice(err, hostname, service) {
+  if (err)
+    return this.callback(new DNSException(err, "getnameinfo", this.hostname));
+
+  this.callback(null, hostname, service);
+  if (this[kPerfHooksDnsLookupServiceContext] && hasObserver("dns")) {
+    stopPerf(this, kPerfHooksDnsLookupServiceContext, {
+      detail: { hostname, service },
+    });
+  }
+}
+
+function lookupService(address, port, callback) {
+  if (arguments.length !== 3)
+    throw new ERR_MISSING_ARGS("address", "port", "callback");
+
+  if (isIP(address) === 0) throw new ERR_INVALID_ARG_VALUE("address", address);
+
+  validatePort(port);
+
+  validateFunction(callback, "callback");
+
+  port = +port;
+
+  const req = new GetNameInfoReqWrap();
+  req.callback = callback;
+  req.hostname = address;
+  req.port = port;
+  req.oncomplete = onlookupservice;
+
+  const err = cares.getnameinfo(req, address, port);
+  if (err) throw new DNSException(err, "getnameinfo", address);
+  if (hasObserver("dns")) {
+    startPerf(req, kPerfHooksDnsLookupServiceContext, {
+      type: "dns",
+      name: "lookupService",
+      detail: {
+        host: address,
+        port,
+      },
+    });
+  }
+  return req;
+}
+
+ObjectDefineProperty(lookupService, customPromisifyArgs, {
+  __proto__: null,
+  value: ["hostname", "service"],
+  enumerable: false,
+});
+
+function defaultResolverSetServers(servers) {
+  const resolver = new Resolver();
+
+  resolver.setServers(servers);
+  setDefaultResolver(resolver);
+  bindDefaultResolver(module.exports, Resolver.prototype);
+
+  if (promises !== null)
+    bindDefaultResolver(promises, promises.Resolver.prototype);
+}
+
+module.exports = {
+  lookup,
+  lookupService,
+
+  Resolver,
+  getDefaultResultOrder,
+  setDefaultResultOrder,
+  setServers: defaultResolverSetServers,
+
+  // uv_getaddrinfo flags
+  ADDRCONFIG: cares.AI_ADDRCONFIG,
+  ALL: cares.AI_ALL,
+  V4MAPPED: cares.AI_V4MAPPED,
+
+  // ERROR CODES
+  NODATA,
+  FORMERR,
+  SERVFAIL,
+  NOTFOUND,
+  NOTIMP,
+  REFUSED,
+  BADQUERY,
+  BADNAME,
+  BADFAMILY,
+  BADRESP,
+  CONNREFUSED,
+  TIMEOUT,
+  EOF,
+  FILE,
+  NOMEM,
+  DESTRUCTION,
+  BADSTR,
+  BADFLAGS,
+  NONAME,
+  BADHINTS,
+  NOTINITIALIZED,
+  LOADIPHLPAPI,
+  ADDRGETNETWORKPARAMS,
+  CANCELLED,
+};
+
+bindDefaultResolver(module.exports, Resolver.prototype);
+
+ObjectDefineProperties(module.exports, {
+  promises: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      if (promises === null) {
+        promises = require("internal/dns/promises");
+      }
+      return promises;
+    },
+  },
+});
diff --git a/.codesandbox/node/domain.js b/.codesandbox/node/domain.js
new file mode 100644
index 0000000000..29aefdb9ac
--- /dev/null
+++ b/.codesandbox/node/domain.js
@@ -0,0 +1,529 @@
+"use strict";
+
+// WARNING: THIS MODULE IS PENDING DEPRECATION.
+//
+// No new pull requests targeting this module will be accepted
+// unless they address existing, critical bugs.
+
+const {
+  ArrayPrototypeEvery,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeLastIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  Error,
+  FunctionPrototypeCall,
+  ObjectDefineProperty,
+  Promise,
+  ReflectApply,
+  SafeMap,
+  SafeWeakMap,
+  StringPrototypeRepeat,
+  Symbol,
+} = primordials;
+
+const EventEmitter = require("events");
+const {
+  ERR_DOMAIN_CALLBACK_NOT_AVAILABLE,
+  ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE,
+  ERR_UNHANDLED_ERROR,
+} = require("internal/errors").codes;
+const { createHook } = require("async_hooks");
+const { useDomainTrampoline } = require("internal/async_hooks");
+
+const kWeak = Symbol("kWeak");
+const { WeakReference } = require("internal/util");
+
+// Overwrite process.domain with a getter/setter that will allow for more
+// effective optimizations
+const _domain = [null];
+ObjectDefineProperty(process, "domain", {
+  __proto__: null,
+  enumerable: true,
+  get: function () {
+    return _domain[0];
+  },
+  set: function (arg) {
+    return (_domain[0] = arg);
+  },
+});
+
+const vmPromises = new SafeWeakMap();
+const pairing = new SafeMap();
+const asyncHook = createHook({
+  init(asyncId, type, triggerAsyncId, resource) {
+    if (process.domain !== null && process.domain !== undefined) {
+      // If this operation is created while in a domain, let's mark it
+      pairing.set(asyncId, process.domain[kWeak]);
+      // Promises from other contexts, such as with the VM module, should not
+      // have a domain property as it can be used to escape the sandbox.
+      if (type !== "PROMISE" || resource instanceof Promise) {
+        ObjectDefineProperty(resource, "domain", {
+          __proto__: null,
+          configurable: true,
+          enumerable: false,
+          value: process.domain,
+          writable: true,
+        });
+        // Because promises from other contexts don't get a domain field,
+        // the domain needs to be held alive another way. Stuffing it in a
+        // weakmap connected to the promise lifetime can fix that.
+      } else {
+        vmPromises.set(resource, process.domain);
+      }
+    }
+  },
+  before(asyncId) {
+    const current = pairing.get(asyncId);
+    if (current !== undefined) {
+      // Enter domain for this cb
+      // We will get the domain through current.get(), because the resource
+      // object's .domain property makes sure it is not garbage collected.
+      // However, we do need to make the reference to the domain non-weak,
+      // so that it cannot be garbage collected before the after() hook.
+      current.incRef();
+      current.get().enter();
+    }
+  },
+  after(asyncId) {
+    const current = pairing.get(asyncId);
+    if (current !== undefined) {
+      // Exit domain for this cb
+      const domain = current.get();
+      current.decRef();
+      domain.exit();
+    }
+  },
+  destroy(asyncId) {
+    pairing.delete(asyncId); // cleaning up
+  },
+});
+
+// When domains are in use, they claim full ownership of the
+// uncaught exception capture callback.
+if (process.hasUncaughtExceptionCaptureCallback()) {
+  throw new ERR_DOMAIN_CALLBACK_NOT_AVAILABLE();
+}
+
+// Get the stack trace at the point where `domain` was required.
+// eslint-disable-next-line no-restricted-syntax
+const domainRequireStack = new Error("require(`domain`) at this point").stack;
+
+const { setUncaughtExceptionCaptureCallback } = process;
+process.setUncaughtExceptionCaptureCallback = function (fn) {
+  const err = new ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE();
+  err.stack += `\n${StringPrototypeRepeat("-", 40)}\n${domainRequireStack}`;
+  throw err;
+};
+
+let sendMakeCallbackDeprecation = false;
+function emitMakeCallbackDeprecation({ target, method }) {
+  if (!sendMakeCallbackDeprecation) {
+    process.emitWarning(
+      "Using a domain property in MakeCallback is deprecated. Use the " +
+        "async_context variant of MakeCallback or the AsyncResource class " +
+        "instead. " +
+        `(Triggered by calling ${method?.name || "<anonymous>"} ` +
+        `on ${target?.constructor?.name}.)`,
+      "DeprecationWarning",
+      "DEP0097"
+    );
+    sendMakeCallbackDeprecation = true;
+  }
+}
+
+function topLevelDomainCallback(cb, ...args) {
+  const domain = this.domain;
+  if (exports.active && domain)
+    emitMakeCallbackDeprecation({ target: this, method: cb });
+
+  if (domain) domain.enter();
+  const ret = ReflectApply(cb, this, args);
+  if (domain) domain.exit();
+
+  return ret;
+}
+
+// It's possible to enter one domain while already inside
+// another one. The stack is each entered domain.
+let stack = [];
+exports._stack = stack;
+useDomainTrampoline(topLevelDomainCallback);
+
+function updateExceptionCapture() {
+  if (
+    ArrayPrototypeEvery(stack, (domain) => domain.listenerCount("error") === 0)
+  ) {
+    setUncaughtExceptionCaptureCallback(null);
+  } else {
+    setUncaughtExceptionCaptureCallback(null);
+    setUncaughtExceptionCaptureCallback((er) => {
+      return process.domain._errorHandler(er);
+    });
+  }
+}
+
+process.on("newListener", (name, listener) => {
+  if (
+    name === "uncaughtException" &&
+    listener !== domainUncaughtExceptionClear
+  ) {
+    // Make sure the first listener for `uncaughtException` always clears
+    // the domain stack.
+    process.removeListener(name, domainUncaughtExceptionClear);
+    process.prependListener(name, domainUncaughtExceptionClear);
+  }
+});
+
+process.on("removeListener", (name, listener) => {
+  if (
+    name === "uncaughtException" &&
+    listener !== domainUncaughtExceptionClear
+  ) {
+    // If the domain listener would be the only remaining one, remove it.
+    const listeners = process.listeners("uncaughtException");
+    if (listeners.length === 1 && listeners[0] === domainUncaughtExceptionClear)
+      process.removeListener(name, domainUncaughtExceptionClear);
+  }
+});
+
+function domainUncaughtExceptionClear() {
+  stack.length = 0;
+  exports.active = process.domain = null;
+  updateExceptionCapture();
+}
+
+class Domain extends EventEmitter {
+  constructor() {
+    super();
+
+    this.members = [];
+    this[kWeak] = new WeakReference(this);
+    asyncHook.enable();
+
+    this.on("removeListener", updateExceptionCapture);
+    this.on("newListener", updateExceptionCapture);
+  }
+}
+
+exports.Domain = Domain;
+
+exports.create = exports.createDomain = function createDomain() {
+  return new Domain();
+};
+
+// The active domain is always the one that we're currently in.
+exports.active = null;
+Domain.prototype.members = undefined;
+
+// Called by process._fatalException in case an error was thrown.
+Domain.prototype._errorHandler = function (er) {
+  let caught = false;
+
+  if ((typeof er === "object" && er !== null) || typeof er === "function") {
+    ObjectDefineProperty(er, "domain", {
+      __proto__: null,
+      configurable: true,
+      enumerable: false,
+      value: this,
+      writable: true,
+    });
+    er.domainThrown = true;
+  }
+  // Pop all adjacent duplicates of the currently active domain from the stack.
+  // This is done to prevent a domain's error handler to run within the context
+  // of itself, and re-entering itself recursively handler as a result of an
+  // exception thrown in its context.
+  while (exports.active === this) {
+    this.exit();
+  }
+
+  // The top-level domain-handler is handled separately.
+  //
+  // The reason is that if V8 was passed a command line option
+  // asking it to abort on an uncaught exception (currently
+  // "--abort-on-uncaught-exception"), we want an uncaught exception
+  // in the top-level domain error handler to make the
+  // process abort. Using try/catch here would always make V8 think
+  // that these exceptions are caught, and thus would prevent it from
+  // aborting in these cases.
+  if (stack.length === 0) {
+    // If there's no error handler, do not emit an 'error' event
+    // as this would throw an error, make the process exit, and thus
+    // prevent the process 'uncaughtException' event from being emitted
+    // if a listener is set.
+    if (this.listenerCount("error") > 0) {
+      // Clear the uncaughtExceptionCaptureCallback so that we know that, since
+      // the top-level domain is not active anymore, it would be ok to abort on
+      // an uncaught exception at this point
+      setUncaughtExceptionCaptureCallback(null);
+      try {
+        caught = this.emit("error", er);
+      } finally {
+        updateExceptionCapture();
+      }
+    }
+  } else {
+    // Wrap this in a try/catch so we don't get infinite throwing
+    try {
+      // One of three things will happen here.
+      //
+      // 1. There is a handler, caught = true
+      // 2. There is no handler, caught = false
+      // 3. It throws, caught = false
+      //
+      // If caught is false after this, then there's no need to exit()
+      // the domain, because we're going to crash the process anyway.
+      caught = this.emit("error", er);
+    } catch (er2) {
+      // The domain error handler threw!  oh no!
+      // See if another domain can catch THIS error,
+      // or else crash on the original one.
+      updateExceptionCapture();
+      if (stack.length) {
+        exports.active = process.domain = stack[stack.length - 1];
+        caught = process.domain._errorHandler(er2);
+      } else {
+        // Pass on to the next exception handler.
+        throw er2;
+      }
+    }
+  }
+
+  // Exit all domains on the stack.  Uncaught exceptions end the
+  // current tick and no domains should be left on the stack
+  // between ticks.
+  domainUncaughtExceptionClear();
+
+  return caught;
+};
+
+Domain.prototype.enter = function () {
+  // Note that this might be a no-op, but we still need
+  // to push it onto the stack so that we can pop it later.
+  exports.active = process.domain = this;
+  ArrayPrototypePush(stack, this);
+  updateExceptionCapture();
+};
+
+Domain.prototype.exit = function () {
+  // Don't do anything if this domain is not on the stack.
+  const index = ArrayPrototypeLastIndexOf(stack, this);
+  if (index === -1) return;
+
+  // Exit all domains until this one.
+  ArrayPrototypeSplice(stack, index);
+
+  exports.active = stack.length === 0 ? undefined : stack[stack.length - 1];
+  process.domain = exports.active;
+  updateExceptionCapture();
+};
+
+// note: this works for timers as well.
+Domain.prototype.add = function (ee) {
+  // If the domain is already added, then nothing left to do.
+  if (ee.domain === this) return;
+
+  // Has a domain already - remove it first.
+  if (ee.domain) ee.domain.remove(ee);
+
+  // Check for circular Domain->Domain links.
+  // They cause big issues.
+  //
+  // For example:
+  // var d = domain.create();
+  // var e = domain.create();
+  // d.add(e);
+  // e.add(d);
+  // e.emit('error', er); // RangeError, stack overflow!
+  if (this.domain && ee instanceof Domain) {
+    for (let d = this.domain; d; d = d.domain) {
+      if (ee === d) return;
+    }
+  }
+
+  ObjectDefineProperty(ee, "domain", {
+    __proto__: null,
+    configurable: true,
+    enumerable: false,
+    value: this,
+    writable: true,
+  });
+  ArrayPrototypePush(this.members, ee);
+};
+
+Domain.prototype.remove = function (ee) {
+  ee.domain = null;
+  const index = ArrayPrototypeIndexOf(this.members, ee);
+  if (index !== -1) ArrayPrototypeSplice(this.members, index, 1);
+};
+
+Domain.prototype.run = function (fn) {
+  this.enter();
+  const ret = ReflectApply(fn, this, ArrayPrototypeSlice(arguments, 1));
+  this.exit();
+
+  return ret;
+};
+
+function intercepted(_this, self, cb, fnargs) {
+  if (fnargs[0] && fnargs[0] instanceof Error) {
+    const er = fnargs[0];
+    er.domainBound = cb;
+    er.domainThrown = false;
+    ObjectDefineProperty(er, "domain", {
+      __proto__: null,
+      configurable: true,
+      enumerable: false,
+      value: self,
+      writable: true,
+    });
+    self.emit("error", er);
+    return;
+  }
+
+  self.enter();
+  const ret = ReflectApply(cb, _this, ArrayPrototypeSlice(fnargs, 1));
+  self.exit();
+
+  return ret;
+}
+
+Domain.prototype.intercept = function (cb) {
+  const self = this;
+
+  function runIntercepted() {
+    return intercepted(this, self, cb, arguments);
+  }
+
+  return runIntercepted;
+};
+
+function bound(_this, self, cb, fnargs) {
+  self.enter();
+  const ret = ReflectApply(cb, _this, fnargs);
+  self.exit();
+
+  return ret;
+}
+
+Domain.prototype.bind = function (cb) {
+  const self = this;
+
+  function runBound() {
+    return bound(this, self, cb, arguments);
+  }
+
+  ObjectDefineProperty(runBound, "domain", {
+    __proto__: null,
+    configurable: true,
+    enumerable: false,
+    value: this,
+    writable: true,
+  });
+
+  return runBound;
+};
+
+// Override EventEmitter methods to make it domain-aware.
+EventEmitter.usingDomains = true;
+
+const eventInit = EventEmitter.init;
+EventEmitter.init = function (opts) {
+  ObjectDefineProperty(this, "domain", {
+    __proto__: null,
+    configurable: true,
+    enumerable: false,
+    value: null,
+    writable: true,
+  });
+  if (exports.active && !(this instanceof exports.Domain)) {
+    this.domain = exports.active;
+  }
+
+  return FunctionPrototypeCall(eventInit, this, opts);
+};
+
+const eventEmit = EventEmitter.prototype.emit;
+EventEmitter.prototype.emit = function emit(...args) {
+  const domain = this.domain;
+
+  const type = args[0];
+  const shouldEmitError = type === "error" && this.listenerCount(type) > 0;
+
+  // Just call original `emit` if current EE instance has `error`
+  // handler, there's no active domain or this is process
+  if (
+    shouldEmitError ||
+    domain === null ||
+    domain === undefined ||
+    this === process
+  ) {
+    return ReflectApply(eventEmit, this, args);
+  }
+
+  if (type === "error") {
+    const er = args.length > 1 && args[1] ? args[1] : new ERR_UNHANDLED_ERROR();
+
+    if (typeof er === "object") {
+      er.domainEmitter = this;
+      ObjectDefineProperty(er, "domain", {
+        __proto__: null,
+        configurable: true,
+        enumerable: false,
+        value: domain,
+        writable: true,
+      });
+      er.domainThrown = false;
+    }
+
+    // Remove the current domain (and its duplicates) from the domains stack and
+    // set the active domain to its parent (if any) so that the domain's error
+    // handler doesn't run in its own context. This prevents any event emitter
+    // created or any exception thrown in that error handler from recursively
+    // executing that error handler.
+    const origDomainsStack = ArrayPrototypeSlice(stack);
+    const origActiveDomain = process.domain;
+
+    // Travel the domains stack from top to bottom to find the first domain
+    // instance that is not a duplicate of the current active domain.
+    let idx = stack.length - 1;
+    while (idx > -1 && process.domain === stack[idx]) {
+      --idx;
+    }
+
+    // Change the stack to not contain the current active domain, and only the
+    // domains above it on the stack.
+    if (idx < 0) {
+      stack.length = 0;
+    } else {
+      ArrayPrototypeSplice(stack, idx + 1);
+    }
+
+    // Change the current active domain
+    if (stack.length > 0) {
+      exports.active = process.domain = stack[stack.length - 1];
+    } else {
+      exports.active = process.domain = null;
+    }
+
+    updateExceptionCapture();
+
+    domain.emit("error", er);
+
+    // Now that the domain's error handler has completed, restore the domains
+    // stack and the active domain to their original values.
+    exports._stack = stack = origDomainsStack;
+    exports.active = process.domain = origActiveDomain;
+    updateExceptionCapture();
+
+    return false;
+  }
+
+  domain.enter();
+  const ret = ReflectApply(eventEmit, this, args);
+  domain.exit();
+
+  return ret;
+};
diff --git a/.codesandbox/node/events.js b/.codesandbox/node/events.js
new file mode 100644
index 0000000000..fdb1605ea9
--- /dev/null
+++ b/.codesandbox/node/events.js
@@ -0,0 +1,1244 @@
+"use strict";
+
+const {
+  ArrayPrototypeJoin,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  AsyncIteratorPrototype,
+  Boolean,
+  Error,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  NumberMAX_SAFE_INTEGER,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectGetPrototypeOf,
+  ObjectSetPrototypeOf,
+  Promise,
+  PromiseReject,
+  PromiseResolve,
+  ReflectApply,
+  ReflectOwnKeys,
+  String,
+  StringPrototypeSplit,
+  Symbol,
+  SymbolAsyncIterator,
+  SymbolDispose,
+  SymbolFor,
+} = primordials;
+const kRejection = SymbolFor("nodejs.rejection");
+
+const { kEmptyObject, spliceOne } = require("internal/util");
+
+const { inspect, identicalSequenceRange } = require("internal/util/inspect");
+
+let FixedQueue;
+let kFirstEventParam;
+let kResistStopPropagation;
+
+const {
+  AbortError,
+  codes: { ERR_INVALID_ARG_TYPE, ERR_UNHANDLED_ERROR },
+  genericNodeError,
+  kEnhanceStackBeforeInspector,
+} = require("internal/errors");
+
+const {
+  validateInteger,
+  validateAbortSignal,
+  validateBoolean,
+  validateFunction,
+  validateNumber,
+  validateObject,
+  validateString,
+} = require("internal/validators");
+const { addAbortListener } = require("internal/events/abort_listener");
+
+const kCapture = Symbol("kCapture");
+const kErrorMonitor = Symbol("events.errorMonitor");
+const kShapeMode = Symbol("shapeMode");
+const kMaxEventTargetListeners = Symbol("events.maxEventTargetListeners");
+const kMaxEventTargetListenersWarned = Symbol(
+  "events.maxEventTargetListenersWarned"
+);
+const kWatermarkData = SymbolFor("nodejs.watermarkData");
+
+let EventEmitterAsyncResource;
+// The EventEmitterAsyncResource has to be initialized lazily because event.js
+// is loaded so early in the bootstrap process, before async_hooks is available.
+//
+// This implementation was adapted straight from addaleax's
+// eventemitter-asyncresource MIT-licensed userland module.
+// https://github.com/addaleax/eventemitter-asyncresource
+function lazyEventEmitterAsyncResource() {
+  if (EventEmitterAsyncResource === undefined) {
+    const { AsyncResource } = require("async_hooks");
+
+    class EventEmitterReferencingAsyncResource extends AsyncResource {
+      #eventEmitter;
+
+      /**
+       * @param {EventEmitter} ee
+       * @param {string} [type]
+       * @param {{
+       *   triggerAsyncId?: number,
+       *   requireManualDestroy?: boolean,
+       * }} [options]
+       */
+      constructor(ee, type, options) {
+        super(type, options);
+        this.#eventEmitter = ee;
+      }
+
+      /**
+       * @type {EventEmitter}
+       */
+      get eventEmitter() {
+        return this.#eventEmitter;
+      }
+    }
+
+    EventEmitterAsyncResource = class EventEmitterAsyncResource extends (
+      EventEmitter
+    ) {
+      #asyncResource;
+
+      /**
+       * @param {{
+       *   name?: string,
+       *   triggerAsyncId?: number,
+       *   requireManualDestroy?: boolean,
+       * }} [options]
+       */
+      constructor(options = undefined) {
+        let name;
+        if (typeof options === "string") {
+          name = options;
+          options = undefined;
+        } else {
+          if (new.target === EventEmitterAsyncResource) {
+            validateString(options?.name, "options.name");
+          }
+          name = options?.name || new.target.name;
+        }
+        super(options);
+
+        this.#asyncResource = new EventEmitterReferencingAsyncResource(
+          this,
+          name,
+          options
+        );
+      }
+
+      /**
+       * @param {symbol|string} event
+       * @param {any[]} args
+       * @returns {boolean}
+       */
+      emit(event, ...args) {
+        const asyncResource = this.#asyncResource;
+        ArrayPrototypeUnshift(args, super.emit, this, event);
+        return ReflectApply(asyncResource.runInAsyncScope, asyncResource, args);
+      }
+
+      /**
+       * @returns {void}
+       */
+      emitDestroy() {
+        this.#asyncResource.emitDestroy();
+      }
+
+      /**
+       * @type {number}
+       */
+      get asyncId() {
+        return this.#asyncResource.asyncId();
+      }
+
+      /**
+       * @type {number}
+       */
+      get triggerAsyncId() {
+        return this.#asyncResource.triggerAsyncId();
+      }
+
+      /**
+       * @type {EventEmitterReferencingAsyncResource}
+       */
+      get asyncResource() {
+        return this.#asyncResource;
+      }
+    };
+  }
+  return EventEmitterAsyncResource;
+}
+
+/**
+ * Creates a new `EventEmitter` instance.
+ * @param {{ captureRejections?: boolean; }} [opts]
+ * @constructs EventEmitter
+ */
+function EventEmitter(opts) {
+  EventEmitter.init.call(this, opts);
+}
+module.exports = EventEmitter;
+module.exports.addAbortListener = addAbortListener;
+module.exports.once = once;
+module.exports.on = on;
+module.exports.getEventListeners = getEventListeners;
+module.exports.getMaxListeners = getMaxListeners;
+module.exports.listenerCount = listenerCount;
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.usingDomains = false;
+
+EventEmitter.captureRejectionSymbol = kRejection;
+ObjectDefineProperty(EventEmitter, "captureRejections", {
+  __proto__: null,
+  get() {
+    return EventEmitter.prototype[kCapture];
+  },
+  set(value) {
+    validateBoolean(value, "EventEmitter.captureRejections");
+
+    EventEmitter.prototype[kCapture] = value;
+  },
+  enumerable: true,
+});
+
+ObjectDefineProperty(EventEmitter, "EventEmitterAsyncResource", {
+  __proto__: null,
+  enumerable: true,
+  get: lazyEventEmitterAsyncResource,
+  set: undefined,
+  configurable: true,
+});
+
+EventEmitter.errorMonitor = kErrorMonitor;
+
+// The default for captureRejections is false
+ObjectDefineProperty(EventEmitter.prototype, kCapture, {
+  __proto__: null,
+  value: false,
+  writable: true,
+  enumerable: false,
+});
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+let defaultMaxListeners = 10;
+let isEventTarget;
+
+function checkListener(listener) {
+  validateFunction(listener, "listener");
+}
+
+ObjectDefineProperty(EventEmitter, "defaultMaxListeners", {
+  __proto__: null,
+  enumerable: true,
+  get: function () {
+    return defaultMaxListeners;
+  },
+  set: function (arg) {
+    validateNumber(arg, "defaultMaxListeners", 0);
+    defaultMaxListeners = arg;
+  },
+});
+
+ObjectDefineProperties(EventEmitter, {
+  kMaxEventTargetListeners: {
+    __proto__: null,
+    value: kMaxEventTargetListeners,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  },
+  kMaxEventTargetListenersWarned: {
+    __proto__: null,
+    value: kMaxEventTargetListenersWarned,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  },
+});
+
+/**
+ * Sets the max listeners.
+ * @param {number} n
+ * @param {EventTarget[] | EventEmitter[]} [eventTargets]
+ * @returns {void}
+ */
+EventEmitter.setMaxListeners = function (
+  n = defaultMaxListeners,
+  ...eventTargets
+) {
+  validateNumber(n, "setMaxListeners", 0);
+  if (eventTargets.length === 0) {
+    defaultMaxListeners = n;
+  } else {
+    if (isEventTarget === undefined)
+      isEventTarget = require("internal/event_target").isEventTarget;
+
+    for (let i = 0; i < eventTargets.length; i++) {
+      const target = eventTargets[i];
+      if (isEventTarget(target)) {
+        target[kMaxEventTargetListeners] = n;
+        target[kMaxEventTargetListenersWarned] = false;
+      } else if (typeof target.setMaxListeners === "function") {
+        target.setMaxListeners(n);
+      } else {
+        throw new ERR_INVALID_ARG_TYPE(
+          "eventTargets",
+          ["EventEmitter", "EventTarget"],
+          target
+        );
+      }
+    }
+  }
+};
+
+// If you're updating this function definition, please also update any
+// re-definitions, such as the one in the Domain module (lib/domain.js).
+EventEmitter.init = function (opts) {
+  if (
+    this._events === undefined ||
+    this._events === ObjectGetPrototypeOf(this)._events
+  ) {
+    this._events = { __proto__: null };
+    this._eventsCount = 0;
+    this[kShapeMode] = false;
+  } else {
+    this[kShapeMode] = true;
+  }
+
+  this._maxListeners ||= undefined;
+
+  if (opts?.captureRejections) {
+    validateBoolean(opts.captureRejections, "options.captureRejections");
+    this[kCapture] = Boolean(opts.captureRejections);
+  } else {
+    // Assigning the kCapture property directly saves an expensive
+    // prototype lookup in a very sensitive hot path.
+    this[kCapture] = EventEmitter.prototype[kCapture];
+  }
+};
+
+function addCatch(that, promise, type, args) {
+  if (!that[kCapture]) {
+    return;
+  }
+
+  // Handle Promises/A+ spec, then could be a getter
+  // that throws on second use.
+  try {
+    const then = promise.then;
+
+    if (typeof then === "function") {
+      then.call(promise, undefined, function (err) {
+        // The callback is called with nextTick to avoid a follow-up
+        // rejection from this promise.
+        process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args);
+      });
+    }
+  } catch (err) {
+    that.emit("error", err);
+  }
+}
+
+function emitUnhandledRejectionOrErr(ee, err, type, args) {
+  if (typeof ee[kRejection] === "function") {
+    ee[kRejection](err, type, ...args);
+  } else {
+    // We have to disable the capture rejections mechanism, otherwise
+    // we might end up in an infinite loop.
+    const prev = ee[kCapture];
+
+    // If the error handler throws, it is not catchable and it
+    // will end up in 'uncaughtException'. We restore the previous
+    // value of kCapture in case the uncaughtException is present
+    // and the exception is handled.
+    try {
+      ee[kCapture] = false;
+      ee.emit("error", err);
+    } finally {
+      ee[kCapture] = prev;
+    }
+  }
+}
+
+/**
+ * Increases the max listeners of the event emitter.
+ * @param {number} n
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  validateNumber(n, "setMaxListeners", 0);
+  this._maxListeners = n;
+  return this;
+};
+
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined) return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+/**
+ * Returns the current max listener value for the event emitter.
+ * @returns {number}
+ */
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+
+function enhanceStackTrace(err, own) {
+  let ctorInfo = "";
+  try {
+    const { name } = this.constructor;
+    if (name !== "EventEmitter") ctorInfo = ` on ${name} instance`;
+  } catch {
+    // Continue regardless of error.
+  }
+  const sep = `\nEmitted 'error' event${ctorInfo} at:\n`;
+
+  const errStack = ArrayPrototypeSlice(
+    StringPrototypeSplit(err.stack, "\n"),
+    1
+  );
+  const ownStack = ArrayPrototypeSlice(
+    StringPrototypeSplit(own.stack, "\n"),
+    1
+  );
+
+  const { len, offset } = identicalSequenceRange(ownStack, errStack);
+  if (len > 0) {
+    ArrayPrototypeSplice(
+      ownStack,
+      offset + 1,
+      len - 2,
+      "    [... lines matching original stack trace ...]"
+    );
+  }
+
+  return err.stack + sep + ArrayPrototypeJoin(ownStack, "\n");
+}
+
+/**
+ * Synchronously calls each of the listeners registered
+ * for the event.
+ * @param {string | symbol} type
+ * @param {...any} [args]
+ * @returns {boolean}
+ */
+EventEmitter.prototype.emit = function emit(type, ...args) {
+  let doError = type === "error";
+
+  const events = this._events;
+  if (events !== undefined) {
+    if (doError && events[kErrorMonitor] !== undefined)
+      this.emit(kErrorMonitor, ...args);
+    doError &&= events.error === undefined;
+  } else if (!doError) return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    let er;
+    if (args.length > 0) er = args[0];
+    if (er instanceof Error) {
+      try {
+        const capture = {};
+        ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
+        ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
+          __proto__: null,
+          value: FunctionPrototypeBind(enhanceStackTrace, this, er, capture),
+          configurable: true,
+        });
+      } catch {
+        // Continue regardless of error.
+      }
+
+      // Note: The comments on the `throw` lines are intentional, they show
+      // up in Node's output if this results in an unhandled exception.
+      throw er; // Unhandled 'error' event
+    }
+
+    let stringifiedEr;
+    try {
+      stringifiedEr = inspect(er);
+    } catch {
+      stringifiedEr = er;
+    }
+
+    // At least give some kind of context to the user
+    const err = new ERR_UNHANDLED_ERROR(stringifiedEr);
+    err.context = er;
+    throw err; // Unhandled 'error' event
+  }
+
+  const handler = events[type];
+
+  if (handler === undefined) return false;
+
+  if (typeof handler === "function") {
+    const result = ReflectApply(handler, this, args);
+
+    // We check if result is undefined first because that
+    // is the most common case so we do not pay any perf
+    // penalty
+    if (result !== undefined && result !== null) {
+      addCatch(this, result, type, args);
+    }
+  } else {
+    const len = handler.length;
+    const listeners = arrayClone(handler);
+    for (let i = 0; i < len; ++i) {
+      const result = ReflectApply(listeners[i], this, args);
+
+      // We check if result is undefined first because that
+      // is the most common case so we do not pay any perf
+      // penalty.
+      // This code is duplicated because extracting it away
+      // would make it non-inlineable.
+      if (result !== undefined && result !== null) {
+        addCatch(this, result, type, args);
+      }
+    }
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  let m;
+  let events;
+  let existing;
+
+  checkListener(listener);
+
+  events = target._events;
+  if (events === undefined) {
+    events = target._events = { __proto__: null };
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener !== undefined) {
+      target.emit("newListener", type, listener.listener ?? listener);
+
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
+    }
+    existing = events[type];
+  }
+
+  if (existing === undefined) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === "function") {
+      // Adding the second element, need to change to array.
+      existing = events[type] = prepend
+        ? [listener, existing]
+        : [existing, listener];
+      // If we've already got an array, just append.
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+
+    // Check for listener leak
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      // No error code for this since it is a Warning
+      const w = genericNodeError(
+        `Possible EventEmitter memory leak detected. ${
+          existing.length
+        } ${String(type)} listeners ` +
+          `added to ${inspect(target, {
+            depth: -1,
+          })}. MaxListeners is ${m}. Use emitter.setMaxListeners() to increase limit`,
+        {
+          name: "MaxListenersExceededWarning",
+          emitter: target,
+          type: type,
+          count: existing.length,
+        }
+      );
+      process.emitWarning(w);
+    }
+  }
+
+  return target;
+}
+
+/**
+ * Adds a listener to the event emitter.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+/**
+ * Adds the `listener` function to the beginning of
+ * the listeners array.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.prependListener = function prependListener(
+  type,
+  listener
+) {
+  return _addListener(this, type, listener, true);
+};
+
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0) return this.listener.call(this.target);
+    return ReflectApply(this.listener, this.target, arguments);
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  const state = { fired: false, wrapFn: undefined, target, type, listener };
+  const wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+/**
+ * Adds a one-time `listener` function to the event emitter.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+/**
+ * Adds a one-time `listener` function to the beginning of
+ * the listeners array.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.prependOnceListener = function prependOnceListener(
+  type,
+  listener
+) {
+  checkListener(listener);
+
+  this.prependListener(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+/**
+ * Removes the specified `listener` from the listeners array.
+ * @param {string | symbol} type
+ * @param {Function} listener
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.removeListener = function removeListener(
+  type,
+  listener
+) {
+  checkListener(listener);
+
+  const events = this._events;
+  if (events === undefined) return this;
+
+  const list = events[type];
+  if (list === undefined) return this;
+
+  if (list === listener || list.listener === listener) {
+    this._eventsCount -= 1;
+
+    if (this[kShapeMode]) {
+      events[type] = undefined;
+    } else if (this._eventsCount === 0) {
+      this._events = { __proto__: null };
+    } else {
+      delete events[type];
+      if (events.removeListener)
+        this.emit("removeListener", type, list.listener || listener);
+    }
+  } else if (typeof list !== "function") {
+    let position = -1;
+
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i] === listener || list[i].listener === listener) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0) return this;
+
+    if (position === 0) list.shift();
+    else {
+      spliceOne(list, position);
+    }
+
+    if (list.length === 1) events[type] = list[0];
+
+    if (events.removeListener !== undefined)
+      this.emit("removeListener", type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+/**
+ * Removes all listeners from the event emitter. (Only
+ * removes listeners for a specific event name if specified
+ * as `type`).
+ * @param {string | symbol} [type]
+ * @returns {EventEmitter}
+ */
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+  const events = this._events;
+  if (events === undefined) return this;
+
+  // Not listening for removeListener, no need to emit
+  if (events.removeListener === undefined) {
+    if (arguments.length === 0) {
+      this._events = { __proto__: null };
+      this._eventsCount = 0;
+    } else if (events[type] !== undefined) {
+      if (--this._eventsCount === 0) this._events = { __proto__: null };
+      else delete events[type];
+    }
+    this[kShapeMode] = false;
+    return this;
+  }
+
+  // Emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (const key of ReflectOwnKeys(events)) {
+      if (key === "removeListener") continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners("removeListener");
+    this._events = { __proto__: null };
+    this._eventsCount = 0;
+    this[kShapeMode] = false;
+    return this;
+  }
+
+  const listeners = events[type];
+
+  if (typeof listeners === "function") {
+    this.removeListener(type, listeners);
+  } else if (listeners !== undefined) {
+    // LIFO order
+    for (let i = listeners.length - 1; i >= 0; i--) {
+      this.removeListener(type, listeners[i]);
+    }
+  }
+
+  return this;
+};
+
+function _listeners(target, type, unwrap) {
+  const events = target._events;
+
+  if (events === undefined) return [];
+
+  const evlistener = events[type];
+  if (evlistener === undefined) return [];
+
+  if (typeof evlistener === "function")
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener);
+}
+
+/**
+ * Returns a copy of the array of listeners for the event name
+ * specified as `type`.
+ * @param {string | symbol} type
+ * @returns {Function[]}
+ */
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+/**
+ * Returns a copy of the array of listeners and wrappers for
+ * the event name specified as `type`.
+ * @param {string | symbol} type
+ * @returns {Function[]}
+ */
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+/**
+ * Returns the number of listeners listening to event name
+ * specified as `type`.
+ * @param {string | symbol} type
+ * @param {Function} [listener]
+ * @returns {number}
+ */
+EventEmitter.prototype.listenerCount = function listenerCount(type, listener) {
+  const events = this._events;
+
+  if (events !== undefined) {
+    const evlistener = events[type];
+
+    if (typeof evlistener === "function") {
+      if (listener != null) {
+        return listener === evlistener || listener === evlistener.listener
+          ? 1
+          : 0;
+      }
+
+      return 1;
+    } else if (evlistener !== undefined) {
+      if (listener != null) {
+        let matching = 0;
+
+        for (let i = 0, l = evlistener.length; i < l; i++) {
+          if (
+            evlistener[i] === listener ||
+            evlistener[i].listener === listener
+          ) {
+            matching++;
+          }
+        }
+
+        return matching;
+      }
+
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+};
+
+/**
+ * Returns an array listing the events for which
+ * the emitter has registered listeners.
+ * @returns {(string | symbol)[]}
+ */
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr) {
+  // At least since V8 8.3, this implementation is faster than the previous
+  // which always used a simple for-loop
+  switch (arr.length) {
+    case 2:
+      return [arr[0], arr[1]];
+    case 3:
+      return [arr[0], arr[1], arr[2]];
+    case 4:
+      return [arr[0], arr[1], arr[2], arr[3]];
+    case 5:
+      return [arr[0], arr[1], arr[2], arr[3], arr[4]];
+    case 6:
+      return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]];
+  }
+  return ArrayPrototypeSlice(arr);
+}
+
+function unwrapListeners(arr) {
+  const ret = arrayClone(arr);
+  for (let i = 0; i < ret.length; ++i) {
+    const orig = ret[i].listener;
+    if (typeof orig === "function") ret[i] = orig;
+  }
+  return ret;
+}
+
+/**
+ * Returns a copy of the array of listeners for the event name
+ * specified as `type`.
+ * @param {EventEmitter | EventTarget} emitterOrTarget
+ * @param {string | symbol} type
+ * @returns {Function[]}
+ */
+function getEventListeners(emitterOrTarget, type) {
+  // First check if EventEmitter
+  if (typeof emitterOrTarget.listeners === "function") {
+    return emitterOrTarget.listeners(type);
+  }
+  // Require event target lazily to avoid always loading it
+  const { isEventTarget, kEvents } = require("internal/event_target");
+  if (isEventTarget(emitterOrTarget)) {
+    const root = emitterOrTarget[kEvents].get(type);
+    const listeners = [];
+    let handler = root?.next;
+    while (handler?.listener !== undefined) {
+      const listener = handler.listener?.deref
+        ? handler.listener.deref()
+        : handler.listener;
+      listeners.push(listener);
+      handler = handler.next;
+    }
+    return listeners;
+  }
+  throw new ERR_INVALID_ARG_TYPE(
+    "emitter",
+    ["EventEmitter", "EventTarget"],
+    emitterOrTarget
+  );
+}
+
+/**
+ * Returns the max listeners set.
+ * @param {EventEmitter | EventTarget} emitterOrTarget
+ * @returns {number}
+ */
+function getMaxListeners(emitterOrTarget) {
+  if (typeof emitterOrTarget?.getMaxListeners === "function") {
+    return _getMaxListeners(emitterOrTarget);
+  } else if (typeof emitterOrTarget?.[kMaxEventTargetListeners] === "number") {
+    return emitterOrTarget[kMaxEventTargetListeners];
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    "emitter",
+    ["EventEmitter", "EventTarget"],
+    emitterOrTarget
+  );
+}
+
+/**
+ * Returns the number of registered listeners for `type`.
+ * @param {EventEmitter | EventTarget} emitterOrTarget
+ * @param {string | symbol} type
+ * @returns {number}
+ */
+function listenerCount(emitterOrTarget, type) {
+  if (typeof emitterOrTarget.listenerCount === "function") {
+    return emitterOrTarget.listenerCount(type);
+  }
+  const { isEventTarget, kEvents } = require("internal/event_target");
+  if (isEventTarget(emitterOrTarget)) {
+    return emitterOrTarget[kEvents].get(type)?.size ?? 0;
+  }
+  throw new ERR_INVALID_ARG_TYPE(
+    "emitter",
+    ["EventEmitter", "EventTarget"],
+    emitterOrTarget
+  );
+}
+
+/**
+ * Creates a `Promise` that is fulfilled when the emitter
+ * emits the given event.
+ * @param {EventEmitter} emitter
+ * @param {string | symbol} name
+ * @param {{ signal: AbortSignal; }} [options]
+ * @returns {Promise}
+ */
+async function once(emitter, name, options = kEmptyObject) {
+  validateObject(options, "options");
+  const { signal } = options;
+  validateAbortSignal(signal, "options.signal");
+  if (signal?.aborted)
+    throw new AbortError(undefined, { cause: signal.reason });
+  return new Promise((resolve, reject) => {
+    const errorListener = (err) => {
+      emitter.removeListener(name, resolver);
+      if (signal != null) {
+        eventTargetAgnosticRemoveListener(signal, "abort", abortListener);
+      }
+      reject(err);
+    };
+    const resolver = (...args) => {
+      if (typeof emitter.removeListener === "function") {
+        emitter.removeListener("error", errorListener);
+      }
+      if (signal != null) {
+        eventTargetAgnosticRemoveListener(signal, "abort", abortListener);
+      }
+      resolve(args);
+    };
+
+    kResistStopPropagation ??=
+      require("internal/event_target").kResistStopPropagation;
+    const opts = {
+      __proto__: null,
+      once: true,
+      [kResistStopPropagation]: true,
+    };
+    eventTargetAgnosticAddListener(emitter, name, resolver, opts);
+    if (name !== "error" && typeof emitter.once === "function") {
+      // EventTarget does not have `error` event semantics like Node
+      // EventEmitters, we listen to `error` events only on EventEmitters.
+      emitter.once("error", errorListener);
+    }
+    function abortListener() {
+      eventTargetAgnosticRemoveListener(emitter, name, resolver);
+      eventTargetAgnosticRemoveListener(emitter, "error", errorListener);
+      reject(new AbortError(undefined, { cause: signal?.reason }));
+    }
+    if (signal != null) {
+      eventTargetAgnosticAddListener(signal, "abort", abortListener, {
+        __proto__: null,
+        once: true,
+        [kResistStopPropagation]: true,
+      });
+    }
+  });
+}
+
+function createIterResult(value, done) {
+  return { value, done };
+}
+
+function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
+  if (typeof emitter.removeListener === "function") {
+    emitter.removeListener(name, listener);
+  } else if (typeof emitter.removeEventListener === "function") {
+    emitter.removeEventListener(name, listener, flags);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === "function") {
+    if (flags?.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === "function") {
+    emitter.addEventListener(name, listener, flags);
+  } else {
+    throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter);
+  }
+}
+
+/**
+ * Returns an `AsyncIterator` that iterates `event` events.
+ * @param {EventEmitter} emitter
+ * @param {string | symbol} event
+ * @param {{
+ *    signal: AbortSignal;
+ *    close?: string[];
+ *    highWaterMark?: number,
+ *    lowWaterMark?: number
+ *   }} [options]
+ * @returns {AsyncIterator}
+ */
+function on(emitter, event, options = kEmptyObject) {
+  // Parameters validation
+  validateObject(options, "options");
+  const signal = options.signal;
+  validateAbortSignal(signal, "options.signal");
+  if (signal?.aborted)
+    throw new AbortError(undefined, { cause: signal.reason });
+  // Support both highWaterMark and highWatermark for backward compatibility
+  const highWatermark =
+    options.highWaterMark ?? options.highWatermark ?? NumberMAX_SAFE_INTEGER;
+  validateInteger(highWatermark, "options.highWaterMark", 1);
+  // Support both lowWaterMark and lowWatermark for backward compatibility
+  const lowWatermark = options.lowWaterMark ?? options.lowWatermark ?? 1;
+  validateInteger(lowWatermark, "options.lowWaterMark", 1);
+
+  // Preparing controlling queues and variables
+  FixedQueue ??= require("internal/fixed_queue");
+  const unconsumedEvents = new FixedQueue();
+  const unconsumedPromises = new FixedQueue();
+  let paused = false;
+  let error = null;
+  let finished = false;
+  let size = 0;
+
+  const iterator = ObjectSetPrototypeOf(
+    {
+      next() {
+        // First, we consume all unread events
+        if (size) {
+          const value = unconsumedEvents.shift();
+          size--;
+          if (paused && size < lowWatermark) {
+            emitter.resume();
+            paused = false;
+          }
+          return PromiseResolve(createIterResult(value, false));
+        }
+
+        // Then we error, if an error happened
+        // This happens one time if at all, because after 'error'
+        // we stop listening
+        if (error) {
+          const p = PromiseReject(error);
+          // Only the first element errors
+          error = null;
+          return p;
+        }
+
+        // If the iterator is finished, resolve to done
+        if (finished) return closeHandler();
+
+        // Wait until an event happens
+        return new Promise(function (resolve, reject) {
+          unconsumedPromises.push({ resolve, reject });
+        });
+      },
+
+      return() {
+        return closeHandler();
+      },
+
+      throw(err) {
+        if (!err || !(err instanceof Error)) {
+          throw new ERR_INVALID_ARG_TYPE(
+            "EventEmitter.AsyncIterator",
+            "Error",
+            err
+          );
+        }
+        errorHandler(err);
+      },
+      [SymbolAsyncIterator]() {
+        return this;
+      },
+      [kWatermarkData]: {
+        /**
+         * The current queue size
+         * @returns {number}
+         */
+        get size() {
+          return size;
+        },
+        /**
+         * The low watermark. The emitter is resumed every time size is lower than it
+         * @returns {number}
+         */
+        get low() {
+          return lowWatermark;
+        },
+        /**
+         * The high watermark. The emitter is paused every time size is higher than it
+         * @returns {number}
+         */
+        get high() {
+          return highWatermark;
+        },
+        /**
+         * It checks whether the emitter is paused by the watermark controller or not
+         * @returns {boolean}
+         */
+        get isPaused() {
+          return paused;
+        },
+      },
+    },
+    AsyncIteratorPrototype
+  );
+
+  // Adding event handlers
+  const { addEventListener, removeAll } = listenersController();
+  kFirstEventParam ??= require("internal/events/symbols").kFirstEventParam;
+  addEventListener(
+    emitter,
+    event,
+    options[kFirstEventParam]
+      ? eventHandler
+      : function (...args) {
+          return eventHandler(args);
+        }
+  );
+  if (event !== "error" && typeof emitter.on === "function") {
+    addEventListener(emitter, "error", errorHandler);
+  }
+  const closeEvents = options?.close;
+  if (closeEvents?.length) {
+    for (let i = 0; i < closeEvents.length; i++) {
+      addEventListener(emitter, closeEvents[i], closeHandler);
+    }
+  }
+
+  const abortListenerDisposable = signal
+    ? addAbortListener(signal, abortListener)
+    : null;
+
+  return iterator;
+
+  function abortListener() {
+    errorHandler(new AbortError(undefined, { cause: signal?.reason }));
+  }
+
+  function eventHandler(value) {
+    if (unconsumedPromises.isEmpty()) {
+      size++;
+      if (!paused && size > highWatermark) {
+        paused = true;
+        emitter.pause();
+      }
+      unconsumedEvents.push(value);
+    } else unconsumedPromises.shift().resolve(createIterResult(value, false));
+  }
+
+  function errorHandler(err) {
+    if (unconsumedPromises.isEmpty()) error = err;
+    else unconsumedPromises.shift().reject(err);
+
+    closeHandler();
+  }
+
+  function closeHandler() {
+    abortListenerDisposable?.[SymbolDispose]();
+    removeAll();
+    finished = true;
+    const doneResult = createIterResult(undefined, true);
+    while (!unconsumedPromises.isEmpty()) {
+      unconsumedPromises.shift().resolve(doneResult);
+    }
+
+    return PromiseResolve(doneResult);
+  }
+}
+
+function listenersController() {
+  const listeners = [];
+
+  return {
+    addEventListener(emitter, event, handler, flags) {
+      eventTargetAgnosticAddListener(emitter, event, handler, flags);
+      ArrayPrototypePush(listeners, [emitter, event, handler, flags]);
+    },
+    removeAll() {
+      while (listeners.length > 0) {
+        ReflectApply(
+          eventTargetAgnosticRemoveListener,
+          undefined,
+          ArrayPrototypePop(listeners)
+        );
+      }
+    },
+  };
+}
diff --git a/.codesandbox/node/fs.js b/.codesandbox/node/fs.js
new file mode 100644
index 0000000000..c505db7363
--- /dev/null
+++ b/.codesandbox/node/fs.js
@@ -0,0 +1,3397 @@
+"use strict";
+
+const {
+  ArrayFromAsync,
+  ArrayPrototypePush,
+  BigIntPrototypeToString,
+  Boolean,
+  FunctionPrototypeCall,
+  MathMax,
+  Number,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  Promise,
+  PromisePrototypeThen,
+  PromiseResolve,
+  ReflectApply,
+  SafeMap,
+  SafeSet,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIndexOf,
+  StringPrototypeSlice,
+  SymbolDispose,
+  uncurryThis,
+} = primordials;
+
+const { fs: constants } = internalBinding("constants");
+const {
+  S_IFIFO,
+  S_IFLNK,
+  S_IFMT,
+  S_IFREG,
+  S_IFSOCK,
+  F_OK,
+  O_WRONLY,
+  O_SYMLINK,
+} = constants;
+
+const pathModule = require("path");
+const { isArrayBufferView } = require("internal/util/types");
+
+const binding = internalBinding("fs");
+
+const { createBlobFromFilePath } = require("internal/blob");
+
+const { Buffer } = require("buffer");
+const { isBuffer: BufferIsBuffer } = Buffer;
+const BufferToString = uncurryThis(Buffer.prototype.toString);
+const {
+  AbortError,
+  aggregateTwoErrors,
+  codes: { ERR_ACCESS_DENIED, ERR_FS_FILE_TOO_LARGE, ERR_INVALID_ARG_VALUE },
+} = require("internal/errors");
+
+const { FSReqCallback, statValues } = binding;
+const { toPathIfFileURL } = require("internal/url");
+const {
+  customPromisifyArgs: kCustomPromisifyArgsSymbol,
+  getLazy,
+  kEmptyObject,
+  promisify: { custom: kCustomPromisifiedSymbol },
+  SideEffectFreeRegExpPrototypeExec,
+  defineLazyProperties,
+  isWindows,
+  isMacOS,
+} = require("internal/util");
+const {
+  constants: { kIoMaxLength, kMaxUserId },
+  copyObject,
+  Dirent,
+  getDirent,
+  getDirents,
+  getOptions,
+  getValidatedFd,
+  getValidatedPath,
+  handleErrorFromBinding,
+  preprocessSymlinkDestination,
+  Stats,
+  getStatFsFromBinding,
+  getStatsFromBinding,
+  realpathCacheKey,
+  stringToFlags,
+  stringToSymlinkType,
+  toUnixTimestamp,
+  validateBufferArray,
+  validateCpOptions,
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+  validatePath,
+  validatePosition,
+  validateRmOptions,
+  validateRmOptionsSync,
+  validateRmdirOptions,
+  validateStringAfterArrayBufferView,
+  warnOnNonPortableTemplate,
+} = require("internal/fs/utils");
+const {
+  CHAR_FORWARD_SLASH,
+  CHAR_BACKWARD_SLASH,
+} = require("internal/constants");
+const {
+  isInt32,
+  parseFileMode,
+  validateBoolean,
+  validateBuffer,
+  validateEncoding,
+  validateFunction,
+  validateInteger,
+  validateObject,
+  validateOneOf,
+  validateString,
+  kValidateObjectAllowNullable,
+} = require("internal/validators");
+
+const permission = require("internal/process/permission");
+
+let fs;
+
+// Lazy loaded
+let cpFn;
+let cpSyncFn;
+let promises = null;
+let ReadStream;
+let WriteStream;
+let rimraf;
+let kResistStopPropagation;
+let ReadFileContext;
+
+// These have to be separate because of how graceful-fs happens to do it's
+// monkeypatching.
+let FileReadStream;
+let FileWriteStream;
+let Utf8Stream;
+
+function lazyLoadUtf8Stream() {
+  Utf8Stream ??= require("internal/streams/fast-utf8-stream");
+}
+
+// Ensure that callbacks run in the global context. Only use this function
+// for callbacks that are passed to the binding layer, callbacks that are
+// invoked from JS already run in the proper scope.
+function makeCallback(cb) {
+  validateFunction(cb, "cb");
+
+  return (...args) => ReflectApply(cb, this, args);
+}
+
+// Special case of `makeCallback()` that is specific to async `*stat()` calls as
+// an optimization, since the data passed back to the callback needs to be
+// transformed anyway.
+function makeStatsCallback(cb) {
+  validateFunction(cb, "cb");
+
+  return (err, stats) => {
+    if (err) return cb(err);
+    cb(err, getStatsFromBinding(stats));
+  };
+}
+
+const isFd = isInt32;
+
+function isFileType(stats, fileType) {
+  // Use stats array directly to avoid creating an fs.Stats instance just for
+  // our internal use.
+  let mode = stats[1];
+  if (typeof mode === "bigint") mode = Number(mode);
+  return (mode & S_IFMT) === fileType;
+}
+
+/**
+ * Tests a user's permissions for the file or directory
+ * specified by `path`.
+ * @param {string | Buffer | URL} path
+ * @param {number} [mode]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function access(path, mode, callback) {
+  if (typeof mode === "function") {
+    callback = mode;
+    mode = F_OK;
+  }
+
+  path = getValidatedPath(path);
+  callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.access(path, mode, req);
+}
+
+/**
+ * Synchronously tests a user's permissions for the file or
+ * directory specified by `path`.
+ * @param {string | Buffer | URL} path
+ * @param {number} [mode]
+ * @returns {void}
+ */
+function accessSync(path, mode) {
+  binding.access(getValidatedPath(path), mode);
+}
+
+/**
+ * Tests whether or not the given path exists.
+ * @param {string | Buffer | URL} path
+ * @param {(exists?: boolean) => any} callback
+ * @returns {void}
+ */
+function exists(path, callback) {
+  validateFunction(callback, "cb");
+
+  function suppressedCallback(err) {
+    callback(!err);
+  }
+
+  try {
+    fs.access(path, F_OK, suppressedCallback);
+  } catch {
+    return callback(false);
+  }
+}
+
+ObjectDefineProperty(exists, kCustomPromisifiedSymbol, {
+  __proto__: null,
+  value: function exists(path) {
+    // eslint-disable-line func-name-matching
+    return new Promise((resolve) => fs.exists(path, resolve));
+  },
+});
+
+let showExistsDeprecation = true;
+/**
+ * Synchronously tests whether or not the given path exists.
+ * @param {string | Buffer | URL} path
+ * @returns {boolean}
+ */
+function existsSync(path) {
+  try {
+    path = getValidatedPath(path);
+  } catch (err) {
+    if (showExistsDeprecation && err?.code === "ERR_INVALID_ARG_TYPE") {
+      process.emitWarning(
+        "Passing invalid argument types to fs.existsSync is deprecated",
+        "DeprecationWarning",
+        "DEP0187"
+      );
+      showExistsDeprecation = false;
+    }
+    return false;
+  }
+
+  return binding.existsSync(path);
+}
+
+function readFileAfterOpen(err, fd) {
+  const context = this.context;
+
+  if (err) {
+    context.callback(err);
+    return;
+  }
+
+  context.fd = fd;
+
+  const req = new FSReqCallback();
+  req.oncomplete = readFileAfterStat;
+  req.context = context;
+  binding.fstat(fd, false, req);
+}
+
+function readFileAfterStat(err, stats) {
+  const context = this.context;
+
+  if (err) return context.close(err);
+
+  // TODO(BridgeAR): Check if allocating a smaller chunk is better performance
+  // wise, similar to the promise based version (less peak memory and chunked
+  // stringify operations vs multiple C++/JS boundary crossings).
+  const size = (context.size = isFileType(stats, S_IFREG) ? stats[8] : 0);
+
+  if (size > kIoMaxLength) {
+    err = new ERR_FS_FILE_TOO_LARGE(size);
+    return context.close(err);
+  }
+
+  try {
+    if (size === 0) {
+      // TODO(BridgeAR): If an encoding is set, use the StringDecoder to concat
+      // the result and reuse the buffer instead of allocating a new one.
+      context.buffers = [];
+    } else {
+      context.buffer = Buffer.allocUnsafeSlow(size);
+    }
+  } catch (err) {
+    return context.close(err);
+  }
+  context.read();
+}
+
+function checkAborted(signal, callback) {
+  if (signal?.aborted) {
+    callback(new AbortError(undefined, { cause: signal.reason }));
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Asynchronously reads the entire contents of a file.
+ * @param {string | Buffer | URL | number} path
+ * @param {{
+ *   encoding?: string | null;
+ *   flag?: string;
+ *   signal?: AbortSignal;
+ *   } | string} [options]
+ * @param {(
+ *   err?: Error,
+ *   data?: string | Buffer
+ *   ) => any} callback
+ * @returns {void}
+ */
+function readFile(path, options, callback) {
+  callback ||= options;
+  validateFunction(callback, "cb");
+  options = getOptions(options, { flag: "r" });
+  ReadFileContext ??= require("internal/fs/read/context");
+  const context = new ReadFileContext(callback, options.encoding);
+  context.isUserFd = isFd(path); // File descriptor ownership
+
+  if (options.signal) {
+    context.signal = options.signal;
+  }
+  if (context.isUserFd) {
+    process.nextTick(function tick(context) {
+      FunctionPrototypeCall(readFileAfterOpen, { context }, null, path);
+    }, context);
+    return;
+  }
+
+  if (checkAborted(options.signal, callback)) return;
+
+  const flagsNumber = stringToFlags(options.flag, "options.flag");
+  const req = new FSReqCallback();
+  req.context = context;
+  req.oncomplete = readFileAfterOpen;
+  binding.open(getValidatedPath(path), flagsNumber, 0o666, req);
+}
+
+function tryStatSync(fd, isUserFd) {
+  const stats = binding.fstat(fd, false, undefined, true /* shouldNotThrow */);
+  if (stats === undefined && !isUserFd) {
+    fs.closeSync(fd);
+  }
+  return stats;
+}
+
+function tryCreateBuffer(size, fd, isUserFd) {
+  let threw = true;
+  let buffer;
+  try {
+    if (size > kIoMaxLength) {
+      throw new ERR_FS_FILE_TOO_LARGE(size);
+    }
+    buffer = Buffer.allocUnsafe(size);
+    threw = false;
+  } finally {
+    if (threw && !isUserFd) fs.closeSync(fd);
+  }
+  return buffer;
+}
+
+function tryReadSync(fd, isUserFd, buffer, pos, len) {
+  let threw = true;
+  let bytesRead;
+  try {
+    bytesRead = fs.readSync(fd, buffer, pos, len);
+    threw = false;
+  } finally {
+    if (threw && !isUserFd) fs.closeSync(fd);
+  }
+  return bytesRead;
+}
+
+/**
+ * Synchronously reads the entire contents of a file.
+ * @param {string | Buffer | URL | number} path
+ * @param {{
+ *   encoding?: string | null;
+ *   flag?: string;
+ *   }} [options]
+ * @returns {string | Buffer}
+ */
+function readFileSync(path, options) {
+  options = getOptions(options, { flag: "r" });
+
+  if (options.encoding === "utf8" || options.encoding === "utf-8") {
+    if (!isInt32(path)) {
+      path = getValidatedPath(path);
+    }
+    return binding.readFileUtf8(path, stringToFlags(options.flag));
+  }
+
+  const isUserFd = isFd(path); // File descriptor ownership
+  const fd = isUserFd ? path : fs.openSync(path, options.flag, 0o666);
+
+  const stats = tryStatSync(fd, isUserFd);
+  const size = isFileType(stats, S_IFREG) ? stats[8] : 0;
+  let pos = 0;
+  let buffer; // Single buffer with file data
+  let buffers; // List for when size is unknown
+
+  if (size === 0) {
+    buffers = [];
+  } else {
+    buffer = tryCreateBuffer(size, fd, isUserFd);
+  }
+
+  let bytesRead;
+
+  if (size !== 0) {
+    do {
+      bytesRead = tryReadSync(fd, isUserFd, buffer, pos, size - pos);
+      pos += bytesRead;
+    } while (bytesRead !== 0 && pos < size);
+  } else {
+    do {
+      // The kernel lies about many files.
+      // Go ahead and try to read some bytes.
+      buffer = Buffer.allocUnsafe(8192);
+      bytesRead = tryReadSync(fd, isUserFd, buffer, 0, 8192);
+      if (bytesRead !== 0) {
+        ArrayPrototypePush(buffers, buffer.slice(0, bytesRead));
+      }
+      pos += bytesRead;
+    } while (bytesRead !== 0);
+  }
+
+  if (!isUserFd) fs.closeSync(fd);
+
+  if (size === 0) {
+    // Data was collected into the buffers list.
+    buffer = Buffer.concat(buffers, pos);
+  } else if (pos < size) {
+    buffer = buffer.slice(0, pos);
+  }
+
+  if (options.encoding) buffer = buffer.toString(options.encoding);
+  return buffer;
+}
+
+function defaultCloseCallback(err) {
+  if (err != null) throw err;
+}
+
+/**
+ * Closes the file descriptor.
+ * @param {number} fd
+ * @param {(err?: Error) => any} [callback]
+ * @returns {void}
+ */
+function close(fd, callback = defaultCloseCallback) {
+  if (callback !== defaultCloseCallback) callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.close(fd, req);
+}
+
+/**
+ * Synchronously closes the file descriptor.
+ * @param {number} fd
+ * @returns {void}
+ */
+function closeSync(fd) {
+  binding.close(fd);
+}
+
+/**
+ * Asynchronously opens a file.
+ * @param {string | Buffer | URL} path
+ * @param {string | number} [flags]
+ * @param {string | number} [mode]
+ * @param {(
+ *   err?: Error,
+ *   fd?: number
+ *   ) => any} callback
+ * @returns {void}
+ */
+function open(path, flags, mode, callback) {
+  path = getValidatedPath(path);
+  if (arguments.length < 3) {
+    callback = flags;
+    flags = "r";
+    mode = 0o666;
+  } else if (typeof mode === "function") {
+    callback = mode;
+    mode = 0o666;
+  } else {
+    mode = parseFileMode(mode, "mode", 0o666);
+  }
+  const flagsNumber = stringToFlags(flags);
+  callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+
+  binding.open(path, flagsNumber, mode, req);
+}
+
+/**
+ * Synchronously opens a file.
+ * @param {string | Buffer | URL} path
+ * @param {string | number} [flags]
+ * @param {string | number} [mode]
+ * @returns {number}
+ */
+function openSync(path, flags, mode) {
+  return binding.open(
+    getValidatedPath(path),
+    stringToFlags(flags),
+    parseFileMode(mode, "mode", 0o666)
+  );
+}
+
+/**
+ * @param {string | Buffer | URL } path
+ * @param {{
+ *   type?: string;
+ *   }} [options]
+ * @returns {Promise<Blob>}
+ */
+function openAsBlob(path, options = kEmptyObject) {
+  validateObject(options, "options");
+  const type = options.type || "";
+  validateString(type, "options.type");
+  // The underlying implementation here returns the Blob synchronously for now.
+  // To give ourselves flexibility to maybe return the Blob asynchronously,
+  // this API returns a Promise.
+  path = getValidatedPath(path);
+  return PromiseResolve(createBlobFromFilePath(path, { type }));
+}
+
+/**
+ * Reads file from the specified `fd` (file descriptor).
+ * @param {number} fd
+ * @param {Buffer | TypedArray | DataView} buffer
+ * @param {number | {
+ *   offset?: number;
+ *   length?: number;
+ *   position?: number | bigint | null;
+ *   }} [offsetOrOptions]
+ * @param {number} length
+ * @param {number | bigint | null} position
+ * @param {(
+ *   err?: Error,
+ *   bytesRead?: number,
+ *   buffer?: Buffer
+ *   ) => any} callback
+ * @returns {void}
+ */
+function read(fd, buffer, offsetOrOptions, length, position, callback) {
+  fd = getValidatedFd(fd);
+
+  let offset = offsetOrOptions;
+  let params = null;
+  if (arguments.length <= 4) {
+    if (arguments.length === 4) {
+      // This is fs.read(fd, buffer, options, callback)
+      validateObject(offsetOrOptions, "options", kValidateObjectAllowNullable);
+      callback = length;
+      params = offsetOrOptions;
+    } else if (arguments.length === 3) {
+      // This is fs.read(fd, bufferOrParams, callback)
+      if (!isArrayBufferView(buffer)) {
+        // This is fs.read(fd, params, callback)
+        params = buffer;
+        ({ buffer = Buffer.alloc(16384) } = params ?? kEmptyObject);
+      }
+      callback = offsetOrOptions;
+    } else {
+      // This is fs.read(fd, callback)
+      callback = buffer;
+      buffer = Buffer.alloc(16384);
+    }
+
+    if (params !== undefined) {
+      validateObject(params, "options", kValidateObjectAllowNullable);
+    }
+    ({
+      offset = 0,
+      length = buffer?.byteLength - offset,
+      position = null,
+    } = params ?? kEmptyObject);
+  }
+
+  validateBuffer(buffer);
+  validateFunction(callback, "cb");
+
+  if (offset == null) {
+    offset = 0;
+  } else {
+    validateInteger(offset, "offset", 0);
+  }
+
+  length |= 0;
+
+  if (length === 0) {
+    return process.nextTick(function tick() {
+      callback(null, 0, buffer);
+    });
+  }
+
+  if (buffer.byteLength === 0) {
+    throw new ERR_INVALID_ARG_VALUE(
+      "buffer",
+      buffer,
+      "is empty and cannot be written"
+    );
+  }
+
+  validateOffsetLengthRead(offset, length, buffer.byteLength);
+
+  if (position == null) {
+    position = -1;
+  } else {
+    validatePosition(position, "position", length);
+  }
+
+  function wrapper(err, bytesRead) {
+    // Retain a reference to buffer so that it can't be GC'ed too soon.
+    callback(err, bytesRead || 0, buffer);
+  }
+
+  const req = new FSReqCallback();
+  req.oncomplete = wrapper;
+
+  binding.read(fd, buffer, offset, length, position, req);
+}
+
+ObjectDefineProperty(read, kCustomPromisifyArgsSymbol, {
+  __proto__: null,
+  value: ["bytesRead", "buffer"],
+  enumerable: false,
+});
+
+/**
+ * Synchronously reads the file from the
+ * specified `fd` (file descriptor).
+ * @param {number} fd
+ * @param {Buffer | TypedArray | DataView} buffer
+ * @param {number | {
+ *   offset?: number;
+ *   length?: number;
+ *   position?: number | bigint | null;
+ *   }} [offsetOrOptions]
+ * @param {number} [length]
+ * @param {number} [position]
+ * @returns {number}
+ */
+function readSync(fd, buffer, offsetOrOptions, length, position) {
+  fd = getValidatedFd(fd);
+
+  validateBuffer(buffer);
+
+  let offset = offsetOrOptions;
+  if (arguments.length <= 3 || typeof offsetOrOptions === "object") {
+    if (offsetOrOptions !== undefined) {
+      validateObject(offsetOrOptions, "options", kValidateObjectAllowNullable);
+    }
+
+    ({
+      offset = 0,
+      length = buffer.byteLength - offset,
+      position = null,
+    } = offsetOrOptions ?? kEmptyObject);
+  }
+
+  if (offset === undefined) {
+    offset = 0;
+  } else {
+    validateInteger(offset, "offset", 0);
+  }
+
+  length |= 0;
+
+  if (length === 0) {
+    return 0;
+  }
+
+  if (buffer.byteLength === 0) {
+    throw new ERR_INVALID_ARG_VALUE(
+      "buffer",
+      buffer,
+      "is empty and cannot be written"
+    );
+  }
+
+  validateOffsetLengthRead(offset, length, buffer.byteLength);
+
+  if (position == null) {
+    position = -1;
+  } else {
+    validatePosition(position, "position", length);
+  }
+
+  return binding.read(fd, buffer, offset, length, position);
+}
+
+/**
+ * Reads file from the specified `fd` (file descriptor)
+ * and writes to an array of `ArrayBufferView`s.
+ * @param {number} fd
+ * @param {ArrayBufferView[]} buffers
+ * @param {number | null} [position]
+ * @param {(
+ *   err?: Error,
+ *   bytesRead?: number,
+ *   buffers?: ArrayBufferView[]
+ * ) => any} callback
+ * @returns {void}
+ */
+function readv(fd, buffers, position, callback) {
+  function wrapper(err, read) {
+    callback(err, read || 0, buffers);
+  }
+
+  fd = getValidatedFd(fd);
+  validateBufferArray(buffers);
+  callback ||= position;
+  validateFunction(callback, "cb");
+
+  const req = new FSReqCallback();
+  req.oncomplete = wrapper;
+
+  if (typeof position !== "number") position = null;
+
+  binding.readBuffers(fd, buffers, position, req);
+}
+
+ObjectDefineProperty(readv, kCustomPromisifyArgsSymbol, {
+  __proto__: null,
+  value: ["bytesRead", "buffers"],
+  enumerable: false,
+});
+
+/**
+ * Synchronously reads file from the
+ * specified `fd` (file descriptor) and writes to an array
+ * of `ArrayBufferView`s.
+ * @param {number} fd
+ * @param {ArrayBufferView[]} buffers
+ * @param {number | null} [position]
+ * @returns {number}
+ */
+function readvSync(fd, buffers, position) {
+  fd = getValidatedFd(fd);
+  validateBufferArray(buffers);
+
+  if (typeof position !== "number") position = null;
+
+  return binding.readBuffers(fd, buffers, position);
+}
+
+/**
+ * Writes `buffer` to the specified `fd` (file descriptor).
+ * @param {number} fd
+ * @param {Buffer | TypedArray | DataView | string} buffer
+ * @param {number | object} [offsetOrOptions]
+ * @param {number} [length]
+ * @param {number | null} [position]
+ * @param {(
+ *   err?: Error,
+ *   bytesWritten?: number,
+ *   buffer?: Buffer | TypedArray | DataView
+ * ) => any} callback
+ * @returns {void}
+ */
+function write(fd, buffer, offsetOrOptions, length, position, callback) {
+  function wrapper(err, written) {
+    // Retain a reference to buffer so that it can't be GC'ed too soon.
+    callback(err, written || 0, buffer);
+  }
+
+  fd = getValidatedFd(fd);
+
+  let offset = offsetOrOptions;
+  if (isArrayBufferView(buffer)) {
+    callback ||= position || length || offset;
+    validateFunction(callback, "cb");
+
+    if (typeof offset === "object") {
+      ({
+        offset = 0,
+        length = buffer.byteLength - offset,
+        position = null,
+      } = offsetOrOptions ?? kEmptyObject);
+    }
+
+    if (offset == null || typeof offset === "function") {
+      offset = 0;
+    } else {
+      validateInteger(offset, "offset", 0);
+    }
+    if (typeof length !== "number") length = buffer.byteLength - offset;
+    if (typeof position !== "number") position = null;
+    validateOffsetLengthWrite(offset, length, buffer.byteLength);
+
+    const req = new FSReqCallback();
+    req.oncomplete = wrapper;
+    binding.writeBuffer(fd, buffer, offset, length, position, req);
+    return;
+  }
+
+  validateStringAfterArrayBufferView(buffer, "buffer");
+
+  if (typeof position !== "function") {
+    if (typeof offset === "function") {
+      position = offset;
+      offset = null;
+    } else {
+      position = length;
+    }
+    length = "utf8";
+  }
+
+  const str = buffer;
+  validateEncoding(str, length);
+  callback = position;
+  validateFunction(callback, "cb");
+
+  const req = new FSReqCallback();
+  req.oncomplete = wrapper;
+  binding.writeString(fd, str, offset, length, req);
+}
+
+ObjectDefineProperty(write, kCustomPromisifyArgsSymbol, {
+  __proto__: null,
+  value: ["bytesWritten", "buffer"],
+  enumerable: false,
+});
+
+/**
+ * Synchronously writes `buffer` to the
+ * specified `fd` (file descriptor).
+ * @param {number} fd
+ * @param {Buffer | TypedArray | DataView | string} buffer
+ * @param {{
+ *   offset?: number;
+ *   length?: number;
+ *   position?: number | null;
+ *   }} [offsetOrOptions]
+ * @param {number} [length]
+ * @param {number} [position]
+ * @returns {number}
+ */
+function writeSync(fd, buffer, offsetOrOptions, length, position) {
+  fd = getValidatedFd(fd);
+  const ctx = {};
+  let result;
+
+  let offset = offsetOrOptions;
+  if (isArrayBufferView(buffer)) {
+    if (typeof offset === "object") {
+      ({
+        offset = 0,
+        length = buffer.byteLength - offset,
+        position = null,
+      } = offsetOrOptions ?? kEmptyObject);
+    }
+    if (position === undefined) position = null;
+    if (offset == null) {
+      offset = 0;
+    } else {
+      validateInteger(offset, "offset", 0);
+    }
+    if (typeof length !== "number") length = buffer.byteLength - offset;
+    validateOffsetLengthWrite(offset, length, buffer.byteLength);
+    result = binding.writeBuffer(
+      fd,
+      buffer,
+      offset,
+      length,
+      position,
+      undefined,
+      ctx
+    );
+  } else {
+    validateStringAfterArrayBufferView(buffer, "buffer");
+    validateEncoding(buffer, length);
+
+    if (offset === undefined) offset = null;
+    result = binding.writeString(fd, buffer, offset, length, undefined, ctx);
+  }
+  handleErrorFromBinding(ctx);
+  return result;
+}
+
+/**
+ * Writes an array of `ArrayBufferView`s to the
+ * specified `fd` (file descriptor).
+ * @param {number} fd
+ * @param {ArrayBufferView[]} buffers
+ * @param {number | null} [position]
+ * @param {(
+ *   err?: Error,
+ *   bytesWritten?: number,
+ *   buffers?: ArrayBufferView[]
+ *   ) => any} callback
+ * @returns {void}
+ */
+function writev(fd, buffers, position, callback) {
+  function wrapper(err, written) {
+    callback(err, written || 0, buffers);
+  }
+
+  fd = getValidatedFd(fd);
+  validateBufferArray(buffers);
+  callback ||= position;
+  validateFunction(callback, "cb");
+
+  if (buffers.length === 0) {
+    process.nextTick(callback, null, 0, buffers);
+    return;
+  }
+
+  const req = new FSReqCallback();
+  req.oncomplete = wrapper;
+
+  if (typeof position !== "number") position = null;
+
+  binding.writeBuffers(fd, buffers, position, req);
+}
+
+ObjectDefineProperty(writev, kCustomPromisifyArgsSymbol, {
+  __proto__: null,
+  value: ["bytesWritten", "buffer"],
+  enumerable: false,
+});
+
+/**
+ * Synchronously writes an array of `ArrayBufferView`s
+ * to the specified `fd` (file descriptor).
+ * @param {number} fd
+ * @param {ArrayBufferView[]} buffers
+ * @param {number | null} [position]
+ * @returns {number}
+ */
+function writevSync(fd, buffers, position) {
+  fd = getValidatedFd(fd);
+  validateBufferArray(buffers);
+
+  if (buffers.length === 0) {
+    return 0;
+  }
+
+  if (typeof position !== "number") position = null;
+
+  return binding.writeBuffers(fd, buffers, position);
+}
+
+/**
+ * Asynchronously renames file at `oldPath` to
+ * the pathname provided as `newPath`.
+ * @param {string | Buffer | URL} oldPath
+ * @param {string | Buffer | URL} newPath
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function rename(oldPath, newPath, callback) {
+  callback = makeCallback(callback);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.rename(
+    getValidatedPath(oldPath, "oldPath"),
+    getValidatedPath(newPath, "newPath"),
+    req
+  );
+}
+
+/**
+ * Synchronously renames file at `oldPath` to
+ * the pathname provided as `newPath`.
+ * @param {string | Buffer | URL} oldPath
+ * @param {string | Buffer | URL} newPath
+ * @returns {void}
+ */
+function renameSync(oldPath, newPath) {
+  binding.rename(
+    getValidatedPath(oldPath, "oldPath"),
+    getValidatedPath(newPath, "newPath")
+  );
+}
+
+/**
+ * Truncates the file.
+ * @param {string | Buffer | URL} path
+ * @param {number} [len]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function truncate(path, len, callback) {
+  if (typeof len === "function") {
+    callback = len;
+    len = 0;
+  } else if (len === undefined) {
+    len = 0;
+  }
+
+  validateInteger(len, "len");
+  len = MathMax(0, len);
+  validateFunction(callback, "cb");
+  fs.open(path, "r+", (er, fd) => {
+    if (er) return callback(er);
+    const req = new FSReqCallback();
+    req.oncomplete = function oncomplete(er) {
+      fs.close(fd, (er2) => {
+        callback(aggregateTwoErrors(er2, er));
+      });
+    };
+    binding.ftruncate(fd, len, req);
+  });
+}
+
+/**
+ * Synchronously truncates the file.
+ * @param {string | Buffer | URL} path
+ * @param {number} [len]
+ * @returns {void}
+ */
+function truncateSync(path, len) {
+  if (len === undefined) {
+    len = 0;
+  }
+  // Allow error to be thrown, but still close fd.
+  const fd = fs.openSync(path, "r+");
+  try {
+    fs.ftruncateSync(fd, len);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/**
+ * Truncates the file descriptor.
+ * @param {number} fd
+ * @param {number} [len]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function ftruncate(fd, len = 0, callback) {
+  if (typeof len === "function") {
+    callback = len;
+    len = 0;
+  }
+  validateInteger(len, "len");
+  len = MathMax(0, len);
+  callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.ftruncate(fd, len, req);
+}
+
+/**
+ * Synchronously truncates the file descriptor.
+ * @param {number} fd
+ * @param {number} [len]
+ * @returns {void}
+ */
+function ftruncateSync(fd, len = 0) {
+  validateInteger(len, "len");
+  binding.ftruncate(fd, len < 0 ? 0 : len);
+}
+
+function lazyLoadCp() {
+  if (cpFn === undefined) {
+    ({ cpFn } = require("internal/fs/cp/cp"));
+    cpFn = require("util").callbackify(cpFn);
+    ({ cpSyncFn } = require("internal/fs/cp/cp-sync"));
+  }
+}
+
+function lazyLoadRimraf() {
+  if (rimraf === undefined) ({ rimraf } = require("internal/fs/rimraf"));
+}
+
+/**
+ * Asynchronously removes a directory.
+ * @param {string | Buffer | URL} path
+ * @param {object} [options]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function rmdir(path, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = undefined;
+  }
+
+  if (options?.recursive !== undefined) {
+    // This API previously accepted a `recursive` option that was deprecated
+    // and removed. However, in order to make the change more visible, we
+    // opted to throw an error if recursive is specified rather than removing it
+    // entirely.
+    throw new ERR_INVALID_ARG_VALUE(
+      "options.recursive",
+      options.recursive,
+      "is no longer supported"
+    );
+  }
+
+  callback = makeCallback(callback);
+  path = getValidatedPath(path);
+
+  validateRmdirOptions(options);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.rmdir(path, req);
+}
+
+/**
+ * Synchronously removes a directory.
+ * @param {string | Buffer | URL} path
+ * @param {object} [options]
+ * @returns {void}
+ */
+function rmdirSync(path, options) {
+  path = getValidatedPath(path);
+
+  if (options?.recursive !== undefined) {
+    throw new ERR_INVALID_ARG_VALUE(
+      "options.recursive",
+      options.recursive,
+      "is no longer supported"
+    );
+  }
+
+  validateRmdirOptions(options);
+  binding.rmdir(path);
+}
+
+/**
+ * Asynchronously removes files and
+ * directories (modeled on the standard POSIX `rm` utility).
+ * @param {string | Buffer | URL} path
+ * @param {{
+ *   force?: boolean;
+ *   maxRetries?: number;
+ *   recursive?: boolean;
+ *   retryDelay?: number;
+ *   }} [options]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function rm(path, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = undefined;
+  }
+  path = getValidatedPath(path);
+
+  validateRmOptions(path, options, false, (err, options) => {
+    if (err) {
+      return callback(err);
+    }
+    lazyLoadRimraf();
+    return rimraf(path, options, callback);
+  });
+}
+
+/**
+ * Synchronously removes files and
+ * directories (modeled on the standard POSIX `rm` utility).
+ * @param {string | Buffer | URL} path
+ * @param {{
+ *   force?: boolean;
+ *   maxRetries?: number;
+ *   recursive?: boolean;
+ *   retryDelay?: number;
+ *   }} [options]
+ * @returns {void}
+ */
+function rmSync(path, options) {
+  const opts = validateRmOptionsSync(path, options, false);
+  return binding.rmSync(
+    getValidatedPath(path),
+    opts.maxRetries,
+    opts.recursive,
+    opts.retryDelay
+  );
+}
+
+/**
+ * Forces all currently queued I/O operations associated
+ * with the file to the operating system's synchronized
+ * I/O completion state.
+ * @param {number} fd
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function fdatasync(fd, callback) {
+  const req = new FSReqCallback();
+  req.oncomplete = makeCallback(callback);
+
+  if (permission.isEnabled()) {
+    callback(
+      new ERR_ACCESS_DENIED(
+        "fdatasync API is disabled when Permission Model is enabled."
+      )
+    );
+    return;
+  }
+  binding.fdatasync(fd, req);
+}
+
+/**
+ * Synchronously forces all currently queued I/O operations
+ * associated with the file to the operating
+ * system's synchronized I/O completion state.
+ * @param {number} fd
+ * @returns {void}
+ */
+function fdatasyncSync(fd) {
+  if (permission.isEnabled()) {
+    throw new ERR_ACCESS_DENIED(
+      "fdatasync API is disabled when Permission Model is enabled."
+    );
+  }
+  binding.fdatasync(fd);
+}
+
+/**
+ * Requests for all data for the open file descriptor
+ * to be flushed to the storage device.
+ * @param {number} fd
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function fsync(fd, callback) {
+  const req = new FSReqCallback();
+  req.oncomplete = makeCallback(callback);
+  if (permission.isEnabled()) {
+    callback(
+      new ERR_ACCESS_DENIED(
+        "fsync API is disabled when Permission Model is enabled."
+      )
+    );
+    return;
+  }
+  binding.fsync(fd, req);
+}
+
+/**
+ * Synchronously requests for all data for the open
+ * file descriptor to be flushed to the storage device.
+ * @param {number} fd
+ * @returns {void}
+ */
+function fsyncSync(fd) {
+  if (permission.isEnabled()) {
+    throw new ERR_ACCESS_DENIED(
+      "fsync API is disabled when Permission Model is enabled."
+    );
+  }
+  binding.fsync(fd);
+}
+
+/**
+ * Asynchronously creates a directory.
+ * @param {string | Buffer | URL} path
+ * @param {{
+ *   recursive?: boolean;
+ *   mode?: string | number;
+ *   } | number} [options]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function mkdir(path, options, callback) {
+  let mode = 0o777;
+  let recursive = false;
+  if (typeof options === "function") {
+    callback = options;
+  } else if (typeof options === "number" || typeof options === "string") {
+    mode = parseFileMode(options, "mode");
+  } else if (options) {
+    if (options.recursive !== undefined) {
+      recursive = options.recursive;
+      validateBoolean(recursive, "options.recursive");
+    }
+    if (options.mode !== undefined) {
+      mode = parseFileMode(options.mode, "options.mode");
+    }
+  }
+  callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.mkdir(getValidatedPath(path), mode, recursive, req);
+}
+
+/**
+ * Synchronously creates a directory.
+ * @param {string | Buffer | URL} path
+ * @param {{
+ *   recursive?: boolean;
+ *   mode?: string | number;
+ *   } | number} [options]
+ * @returns {string | void}
+ */
+function mkdirSync(path, options) {
+  let mode = 0o777;
+  let recursive = false;
+  if (typeof options === "number" || typeof options === "string") {
+    mode = parseFileMode(options, "mode");
+  } else if (options) {
+    if (options.recursive !== undefined) {
+      recursive = options.recursive;
+      validateBoolean(recursive, "options.recursive");
+    }
+    if (options.mode !== undefined) {
+      mode = parseFileMode(options.mode, "options.mode");
+    }
+  }
+
+  const result = binding.mkdir(getValidatedPath(path), mode, recursive);
+
+  if (recursive) {
+    return result;
+  }
+}
+
+/*
+ * An recursive algorithm for reading the entire contents of the `basePath` directory.
+ * This function does not validate `basePath` as a directory. It is passed directly to
+ * `binding.readdir`.
+ * @param {string} basePath
+ * @param {{ encoding: string, withFileTypes: boolean }} options
+ * @param {(
+ *   err?: Error,
+ *   files?: string[] | Buffer[] | Dirent[]
+ * ) => any} callback
+ * @returns {void}
+ */
+function readdirRecursive(basePath, options, callback) {
+  const context = {
+    withFileTypes: Boolean(options.withFileTypes),
+    encoding: options.encoding,
+    basePath,
+    readdirResults: [],
+    pathsQueue: [basePath],
+  };
+
+  let i = 0;
+
+  function read(path) {
+    const req = new FSReqCallback();
+    req.oncomplete = (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      if (result === undefined) {
+        callback(null, context.readdirResults);
+        return;
+      }
+
+      processReaddirResult({
+        result,
+        currentPath: path,
+        context,
+      });
+
+      if (i < context.pathsQueue.length) {
+        read(context.pathsQueue[i++]);
+      } else {
+        callback(null, context.readdirResults);
+      }
+    };
+
+    binding.readdir(path, context.encoding, context.withFileTypes, req);
+  }
+
+  read(context.pathsQueue[i++]);
+}
+
+// Calling `readdir` with `withFileTypes=true`, the result is an array of arrays.
+// The first array is the names, and the second array is the types.
+// They are guaranteed to be the same length; hence, setting `length` to the length
+// of the first array within the result.
+const processReaddirResult = (args) =>
+  args.context.withFileTypes ? handleDirents(args) : handleFilePaths(args);
+
+function handleDirents({ result, currentPath, context }) {
+  const { 0: names, 1: types } = result;
+  const { length } = names;
+
+  for (let i = 0; i < length; i++) {
+    // Avoid excluding symlinks, as they are not directories.
+    // Refs: https://github.com/nodejs/node/issues/52663
+    const fullPath = pathModule.join(currentPath, names[i]);
+    const dirent = getDirent(currentPath, names[i], types[i]);
+    ArrayPrototypePush(context.readdirResults, dirent);
+
+    if (dirent.isDirectory() || binding.internalModuleStat(fullPath) === 1) {
+      ArrayPrototypePush(context.pathsQueue, fullPath);
+    }
+  }
+}
+
+function handleFilePaths({ result, currentPath, context }) {
+  for (let i = 0; i < result.length; i++) {
+    const resultPath = pathModule.join(currentPath, result[i]);
+    const relativeResultPath = pathModule.relative(
+      context.basePath,
+      resultPath
+    );
+    const stat = binding.internalModuleStat(resultPath);
+    ArrayPrototypePush(context.readdirResults, relativeResultPath);
+
+    if (stat === 1) {
+      ArrayPrototypePush(context.pathsQueue, resultPath);
+    }
+  }
+}
+
+/**
+ * An iterative algorithm for reading the entire contents of the `basePath` directory.
+ * This function does not validate `basePath` as a directory. It is passed directly to
+ * `binding.readdir`.
+ * @param {string} basePath
+ * @param {{ encoding: string, withFileTypes: boolean }} options
+ * @returns {string[] | Dirent[]}
+ */
+function readdirSyncRecursive(basePath, options) {
+  const context = {
+    withFileTypes: Boolean(options.withFileTypes),
+    encoding: options.encoding,
+    basePath,
+    readdirResults: [],
+    pathsQueue: [basePath],
+  };
+
+  function read(path) {
+    const readdirResult = binding.readdir(
+      path,
+      context.encoding,
+      context.withFileTypes
+    );
+
+    if (readdirResult === undefined) {
+      return;
+    }
+
+    processReaddirResult({
+      result: readdirResult,
+      currentPath: path,
+      context,
+    });
+  }
+
+  for (let i = 0; i < context.pathsQueue.length; i++) {
+    read(context.pathsQueue[i]);
+  }
+
+  return context.readdirResults;
+}
+
+/**
+ * Reads the contents of a directory.
+ * @param {string | Buffer | URL} path
+ * @param {string | {
+ *   encoding?: string;
+ *   withFileTypes?: boolean;
+ *   recursive?: boolean;
+ *   }} [options]
+ * @param {(
+ *   err?: Error,
+ *   files?: string[] | Buffer[] | Dirent[]
+ * ) => any} callback
+ * @returns {void}
+ */
+function readdir(path, options, callback) {
+  callback = makeCallback(typeof options === "function" ? options : callback);
+  options = getOptions(options);
+  path = getValidatedPath(path);
+  if (options.recursive != null) {
+    validateBoolean(options.recursive, "options.recursive");
+  }
+
+  if (options.recursive) {
+    // Make shallow copy to prevent mutating options from affecting results
+    options = copyObject(options);
+
+    readdirRecursive(path, options, callback);
+    return;
+  }
+
+  const req = new FSReqCallback();
+  if (!options.withFileTypes) {
+    req.oncomplete = callback;
+  } else {
+    req.oncomplete = (err, result) => {
+      if (err) {
+        callback(err);
+        return;
+      }
+      getDirents(path, result, callback);
+    };
+  }
+  binding.readdir(path, options.encoding, !!options.withFileTypes, req);
+}
+
+/**
+ * Synchronously reads the contents of a directory.
+ * @param {string | Buffer | URL} path
+ * @param {string | {
+ *   encoding?: string;
+ *   withFileTypes?: boolean;
+ *   recursive?: boolean;
+ *   }} [options]
+ * @returns {string | Buffer[] | Dirent[]}
+ */
+function readdirSync(path, options) {
+  options = getOptions(options);
+  path = getValidatedPath(path);
+  if (options.recursive != null) {
+    validateBoolean(options.recursive, "options.recursive");
+  }
+
+  if (options.recursive) {
+    return readdirSyncRecursive(path, options);
+  }
+
+  const result = binding.readdir(
+    path,
+    options.encoding,
+    !!options.withFileTypes
+  );
+
+  return result !== undefined && options.withFileTypes
+    ? getDirents(path, result)
+    : result;
+}
+
+/**
+ * Invokes the callback with the `fs.Stats`
+ * for the file descriptor.
+ * @param {number} fd
+ * @param {{ bigint?: boolean; }} [options]
+ * @param {(
+ *   err?: Error,
+ *   stats?: Stats
+ *   ) => any} [callback]
+ * @returns {void}
+ */
+function fstat(fd, options = { bigint: false }, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = kEmptyObject;
+  }
+  callback = makeStatsCallback(callback);
+
+  const req = new FSReqCallback(options.bigint);
+  req.oncomplete = callback;
+  binding.fstat(fd, options.bigint, req);
+}
+
+/**
+ * Retrieves the `fs.Stats` for the symbolic link
+ * referred to by the `path`.
+ * @param {string | Buffer | URL} path
+ * @param {{ bigint?: boolean; }} [options]
+ * @param {(
+ *   err?: Error,
+ *   stats?: Stats
+ *   ) => any} callback
+ * @returns {void}
+ */
+function lstat(path, options = { bigint: false }, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = kEmptyObject;
+  }
+  callback = makeStatsCallback(callback);
+  path = getValidatedPath(path);
+  if (permission.isEnabled() && !permission.has("fs.read", path)) {
+    const resource = BufferIsBuffer(path) ? BufferToString(path) : path;
+    callback(
+      new ERR_ACCESS_DENIED(
+        "Access to this API has been restricted",
+        "FileSystemRead",
+        resource
+      )
+    );
+    return;
+  }
+
+  const req = new FSReqCallback(options.bigint);
+  req.oncomplete = callback;
+  binding.lstat(path, options.bigint, req);
+}
+
+/**
+ * Asynchronously gets the stats of a file.
+ * @param {string | Buffer | URL} path
+ * @param {{ bigint?: boolean; }} [options]
+ * @param {(
+ *   err?: Error,
+ *   stats?: Stats
+ *   ) => any} callback
+ * @returns {void}
+ */
+function stat(path, options = { bigint: false }, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = kEmptyObject;
+  }
+  callback = makeStatsCallback(callback);
+
+  const req = new FSReqCallback(options.bigint);
+  req.oncomplete = callback;
+  binding.stat(getValidatedPath(path), options.bigint, req);
+}
+
+function statfs(path, options = { bigint: false }, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = kEmptyObject;
+  }
+  validateFunction(callback, "cb");
+  path = getValidatedPath(path);
+  const req = new FSReqCallback(options.bigint);
+  req.oncomplete = (err, stats) => {
+    if (err) {
+      return callback(err);
+    }
+
+    callback(err, getStatFsFromBinding(stats));
+  };
+  binding.statfs(getValidatedPath(path), options.bigint, req);
+}
+
+/**
+ * Synchronously retrieves the `fs.Stats` for
+ * the file descriptor.
+ * @param {number} fd
+ * @param {{ bigint?: boolean; }} [options]
+ * @returns {Stats | undefined}
+ */
+function fstatSync(fd, options = { bigint: false }) {
+  const stats = binding.fstat(fd, options.bigint, undefined, false);
+  if (stats === undefined) {
+    return;
+  }
+  return getStatsFromBinding(stats);
+}
+
+/**
+ * Synchronously retrieves the `fs.Stats` for
+ * the symbolic link referred to by the `path`.
+ * @param {string | Buffer | URL} path
+ * @param {{
+ *   bigint?: boolean;
+ *   throwIfNoEntry?: boolean;
+ *   }} [options]
+ * @returns {Stats | undefined}
+ */
+function lstatSync(path, options = { bigint: false, throwIfNoEntry: true }) {
+  path = getValidatedPath(path);
+  if (permission.isEnabled() && !permission.has("fs.read", path)) {
+    const resource = BufferIsBuffer(path) ? BufferToString(path) : path;
+    throw new ERR_ACCESS_DENIED(
+      "Access to this API has been restricted",
+      "FileSystemRead",
+      resource
+    );
+  }
+  const stats = binding.lstat(
+    getValidatedPath(path),
+    options.bigint,
+    undefined,
+    options.throwIfNoEntry
+  );
+
+  if (stats === undefined) {
+    return;
+  }
+  return getStatsFromBinding(stats);
+}
+
+/**
+ * Synchronously retrieves the `fs.Stats`
+ * for the `path`.
+ * @param {string | Buffer | URL} path
+ * @param {{
+ *   bigint?: boolean;
+ *   throwIfNoEntry?: boolean;
+ *   }} [options]
+ * @returns {Stats}
+ */
+function statSync(path, options = { bigint: false, throwIfNoEntry: true }) {
+  const stats = binding.stat(
+    getValidatedPath(path),
+    options.bigint,
+    undefined,
+    options.throwIfNoEntry
+  );
+  if (stats === undefined) {
+    return undefined;
+  }
+  return getStatsFromBinding(stats);
+}
+
+function statfsSync(path, options = { bigint: false }) {
+  const stats = binding.statfs(getValidatedPath(path), options.bigint);
+  return getStatFsFromBinding(stats);
+}
+
+/**
+ * Reads the contents of a symbolic link
+ * referred to by `path`.
+ * @param {string | Buffer | URL} path
+ * @param {{ encoding?: string; } | string} [options]
+ * @param {(
+ *   err?: Error,
+ *   linkString?: string | Buffer
+ *   ) => any} callback
+ * @returns {void}
+ */
+function readlink(path, options, callback) {
+  callback = makeCallback(typeof options === "function" ? options : callback);
+  options = getOptions(options);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.readlink(getValidatedPath(path), options.encoding, req);
+}
+
+/**
+ * Synchronously reads the contents of a symbolic link
+ * referred to by `path`.
+ * @param {string | Buffer | URL} path
+ * @param {{ encoding?: string; } | string} [options]
+ * @returns {string | Buffer}
+ */
+function readlinkSync(path, options) {
+  options = getOptions(options);
+  return binding.readlink(getValidatedPath(path), options.encoding);
+}
+
+/**
+ * Creates the link called `path` pointing to `target`.
+ * @param {string | Buffer | URL} target
+ * @param {string | Buffer | URL} path
+ * @param {string | null} [type]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function symlink(target, path, type, callback) {
+  if (callback === undefined) {
+    callback = makeCallback(type);
+    type = undefined;
+  } else {
+    validateOneOf(type, "type", ["dir", "file", "junction", null, undefined]);
+  }
+
+  // Due to the nature of Node.js runtime, symlinks has different edge cases that can bypass
+  // the permission model security guarantees. Thus, this API is disabled unless fs.read
+  // and fs.write permission has been given.
+  if (permission.isEnabled() && !permission.has("fs")) {
+    callback(
+      new ERR_ACCESS_DENIED(
+        "fs.symlink API requires full fs.read and fs.write permissions."
+      )
+    );
+    return;
+  }
+
+  target = getValidatedPath(target, "target");
+  path = getValidatedPath(path);
+
+  if (isWindows && type == null) {
+    let absoluteTarget;
+    try {
+      // Symlinks targets can be relative to the newly created path.
+      // Calculate absolute file name of the symlink target, and check
+      // if it is a directory. Ignore resolve error to keep symlink
+      // errors consistent between platforms if invalid path is
+      // provided.
+      absoluteTarget = pathModule.resolve(path, "..", target);
+    } catch {
+      // Continue regardless of error.
+    }
+    if (absoluteTarget !== undefined) {
+      stat(absoluteTarget, (err, stat) => {
+        const resolvedType = !err && stat.isDirectory() ? "dir" : "file";
+        const resolvedFlags = stringToSymlinkType(resolvedType);
+        const destination = preprocessSymlinkDestination(
+          target,
+          resolvedType,
+          path
+        );
+
+        const req = new FSReqCallback();
+        req.oncomplete = callback;
+        binding.symlink(destination, path, resolvedFlags, req);
+      });
+      return;
+    }
+  }
+
+  const destination = preprocessSymlinkDestination(target, type, path);
+
+  const flags = stringToSymlinkType(type);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.symlink(destination, path, flags, req);
+}
+
+/**
+ * Synchronously creates the link called `path`
+ * pointing to `target`.
+ * @param {string | Buffer | URL} target
+ * @param {string | Buffer | URL} path
+ * @param {string | null} [type]
+ * @returns {void}
+ */
+function symlinkSync(target, path, type) {
+  validateOneOf(type, "type", ["dir", "file", "junction", null, undefined]);
+  if (isWindows && type == null) {
+    const absoluteTarget = pathModule.resolve(`${path}`, "..", `${target}`);
+    if (statSync(absoluteTarget, { throwIfNoEntry: false })?.isDirectory()) {
+      type = "dir";
+    }
+  }
+
+  // Due to the nature of Node.js runtime, symlinks has different edge cases that can bypass
+  // the permission model security guarantees. Thus, this API is disabled unless fs.read
+  // and fs.write permission has been given.
+  if (permission.isEnabled() && !permission.has("fs")) {
+    throw new ERR_ACCESS_DENIED(
+      "fs.symlink API requires full fs.read and fs.write permissions."
+    );
+  }
+
+  target = getValidatedPath(target, "target");
+  path = getValidatedPath(path);
+
+  binding.symlink(
+    preprocessSymlinkDestination(target, type, path),
+    path,
+    stringToSymlinkType(type)
+  );
+}
+
+/**
+ * Creates a new link from the `existingPath`
+ * to the `newPath`.
+ * @param {string | Buffer | URL} existingPath
+ * @param {string | Buffer | URL} newPath
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function link(existingPath, newPath, callback) {
+  callback = makeCallback(callback);
+
+  existingPath = getValidatedPath(existingPath, "existingPath");
+  newPath = getValidatedPath(newPath, "newPath");
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+
+  binding.link(existingPath, newPath, req);
+}
+
+/**
+ * Synchronously creates a new link from the `existingPath`
+ * to the `newPath`.
+ * @param {string | Buffer | URL} existingPath
+ * @param {string | Buffer | URL} newPath
+ * @returns {void}
+ */
+function linkSync(existingPath, newPath) {
+  existingPath = getValidatedPath(existingPath, "existingPath");
+  newPath = getValidatedPath(newPath, "newPath");
+
+  binding.link(existingPath, newPath);
+}
+
+/**
+ * Asynchronously removes a file or symbolic link.
+ * @param {string | Buffer | URL} path
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function unlink(path, callback) {
+  callback = makeCallback(callback);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.unlink(getValidatedPath(path), req);
+}
+
+/**
+ * Synchronously removes a file or symbolic link.
+ * @param {string | Buffer | URL} path
+ * @returns {void}
+ */
+function unlinkSync(path) {
+  binding.unlink(getValidatedPath(path));
+}
+
+/**
+ * Sets the permissions on the file.
+ * @param {number} fd
+ * @param {string | number} mode
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function fchmod(fd, mode, callback) {
+  mode = parseFileMode(mode, "mode");
+  callback = makeCallback(callback);
+
+  if (permission.isEnabled()) {
+    callback(
+      new ERR_ACCESS_DENIED(
+        "fchmod API is disabled when Permission Model is enabled."
+      )
+    );
+    return;
+  }
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.fchmod(fd, mode, req);
+}
+
+/**
+ * Synchronously sets the permissions on the file.
+ * @param {number} fd
+ * @param {string | number} mode
+ * @returns {void}
+ */
+function fchmodSync(fd, mode) {
+  if (permission.isEnabled()) {
+    throw new ERR_ACCESS_DENIED(
+      "fchmod API is disabled when Permission Model is enabled."
+    );
+  }
+  binding.fchmod(fd, parseFileMode(mode, "mode"));
+}
+
+/**
+ * Changes the permissions on a symbolic link.
+ * @param {string | Buffer | URL} path
+ * @param {number} mode
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function lchmod(path, mode, callback) {
+  validateFunction(callback, "cb");
+  mode = parseFileMode(mode, "mode");
+  fs.open(path, O_WRONLY | O_SYMLINK, (err, fd) => {
+    if (err) {
+      callback(err);
+      return;
+    }
+    // Prefer to return the chmod error, if one occurs,
+    // but still try to close, and report closing errors if they occur.
+    fs.fchmod(fd, mode, (err) => {
+      fs.close(fd, (err2) => {
+        callback(aggregateTwoErrors(err2, err));
+      });
+    });
+  });
+}
+
+/**
+ * Synchronously changes the permissions on a symbolic link.
+ * @param {string | Buffer | URL} path
+ * @param {number} mode
+ * @returns {void}
+ */
+function lchmodSync(path, mode) {
+  const fd = fs.openSync(path, O_WRONLY | O_SYMLINK);
+
+  // Prefer to return the chmod error, if one occurs,
+  // but still try to close, and report closing errors if they occur.
+  try {
+    fs.fchmodSync(fd, mode);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+/**
+ * Asynchronously changes the permissions of a file.
+ * @param {string | Buffer | URL} path
+ * @param {string | number} mode
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function chmod(path, mode, callback) {
+  path = getValidatedPath(path);
+  mode = parseFileMode(mode, "mode");
+  callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.chmod(path, mode, req);
+}
+
+/**
+ * Synchronously changes the permissions of a file.
+ * @param {string | Buffer | URL} path
+ * @param {string | number} mode
+ * @returns {void}
+ */
+function chmodSync(path, mode) {
+  path = getValidatedPath(path);
+  mode = parseFileMode(mode, "mode");
+
+  binding.chmod(path, mode);
+}
+
+/**
+ * Sets the owner of the symbolic link.
+ * @param {string | Buffer | URL} path
+ * @param {number} uid
+ * @param {number} gid
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function lchown(path, uid, gid, callback) {
+  callback = makeCallback(callback);
+  path = getValidatedPath(path);
+  validateInteger(uid, "uid", -1, kMaxUserId);
+  validateInteger(gid, "gid", -1, kMaxUserId);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.lchown(path, uid, gid, req);
+}
+
+/**
+ * Synchronously sets the owner of the symbolic link.
+ * @param {string | Buffer | URL} path
+ * @param {number} uid
+ * @param {number} gid
+ * @returns {void}
+ */
+function lchownSync(path, uid, gid) {
+  path = getValidatedPath(path);
+  validateInteger(uid, "uid", -1, kMaxUserId);
+  validateInteger(gid, "gid", -1, kMaxUserId);
+  binding.lchown(path, uid, gid);
+}
+
+/**
+ * Sets the owner of the file.
+ * @param {number} fd
+ * @param {number} uid
+ * @param {number} gid
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function fchown(fd, uid, gid, callback) {
+  validateInteger(uid, "uid", -1, kMaxUserId);
+  validateInteger(gid, "gid", -1, kMaxUserId);
+  callback = makeCallback(callback);
+  if (permission.isEnabled()) {
+    callback(
+      new ERR_ACCESS_DENIED(
+        "fchown API is disabled when Permission Model is enabled."
+      )
+    );
+    return;
+  }
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.fchown(fd, uid, gid, req);
+}
+
+/**
+ * Synchronously sets the owner of the file.
+ * @param {number} fd
+ * @param {number} uid
+ * @param {number} gid
+ * @returns {void}
+ */
+function fchownSync(fd, uid, gid) {
+  validateInteger(uid, "uid", -1, kMaxUserId);
+  validateInteger(gid, "gid", -1, kMaxUserId);
+  if (permission.isEnabled()) {
+    throw new ERR_ACCESS_DENIED(
+      "fchown API is disabled when Permission Model is enabled."
+    );
+  }
+
+  binding.fchown(fd, uid, gid);
+}
+
+/**
+ * Asynchronously changes the owner and group
+ * of a file.
+ * @param {string | Buffer | URL} path
+ * @param {number} uid
+ * @param {number} gid
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function chown(path, uid, gid, callback) {
+  callback = makeCallback(callback);
+  path = getValidatedPath(path);
+  validateInteger(uid, "uid", -1, kMaxUserId);
+  validateInteger(gid, "gid", -1, kMaxUserId);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.chown(path, uid, gid, req);
+}
+
+/**
+ * Synchronously changes the owner and group
+ * of a file.
+ * @param {string | Buffer | URL} path
+ * @param {number} uid
+ * @param {number} gid
+ * @returns {void}
+ */
+function chownSync(path, uid, gid) {
+  path = getValidatedPath(path);
+  validateInteger(uid, "uid", -1, kMaxUserId);
+  validateInteger(gid, "gid", -1, kMaxUserId);
+  binding.chown(path, uid, gid);
+}
+
+/**
+ * Changes the file system timestamps of the object
+ * referenced by `path`.
+ * @param {string | Buffer | URL} path
+ * @param {number | string | Date} atime
+ * @param {number | string | Date} mtime
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function utimes(path, atime, mtime, callback) {
+  callback = makeCallback(callback);
+  path = getValidatedPath(path);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.utimes(path, toUnixTimestamp(atime), toUnixTimestamp(mtime), req);
+}
+
+/**
+ * Synchronously changes the file system timestamps
+ * of the object referenced by `path`.
+ * @param {string | Buffer | URL} path
+ * @param {number | string | Date} atime
+ * @param {number | string | Date} mtime
+ * @returns {void}
+ */
+function utimesSync(path, atime, mtime) {
+  binding.utimes(
+    getValidatedPath(path),
+    toUnixTimestamp(atime),
+    toUnixTimestamp(mtime)
+  );
+}
+
+/**
+ * Changes the file system timestamps of the object
+ * referenced by the supplied `fd` (file descriptor).
+ * @param {number} fd
+ * @param {number | string | Date} atime
+ * @param {number | string | Date} mtime
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function futimes(fd, atime, mtime, callback) {
+  atime = toUnixTimestamp(atime, "atime");
+  mtime = toUnixTimestamp(mtime, "mtime");
+  callback = makeCallback(callback);
+
+  if (permission.isEnabled()) {
+    callback(
+      new ERR_ACCESS_DENIED(
+        "futimes API is disabled when Permission Model is enabled."
+      )
+    );
+    return;
+  }
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.futimes(fd, atime, mtime, req);
+}
+
+/**
+ * Synchronously changes the file system timestamps
+ * of the object referenced by the
+ * supplied `fd` (file descriptor).
+ * @param {number} fd
+ * @param {number | string | Date} atime
+ * @param {number | string | Date} mtime
+ * @returns {void}
+ */
+function futimesSync(fd, atime, mtime) {
+  if (permission.isEnabled()) {
+    throw new ERR_ACCESS_DENIED(
+      "futimes API is disabled when Permission Model is enabled."
+    );
+  }
+
+  binding.futimes(
+    fd,
+    toUnixTimestamp(atime, "atime"),
+    toUnixTimestamp(mtime, "mtime")
+  );
+}
+
+/**
+ * Changes the access and modification times of
+ * a file in the same way as `fs.utimes()`.
+ * @param {string | Buffer | URL} path
+ * @param {number | string | Date} atime
+ * @param {number | string | Date} mtime
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function lutimes(path, atime, mtime, callback) {
+  callback = makeCallback(callback);
+  path = getValidatedPath(path);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.lutimes(path, toUnixTimestamp(atime), toUnixTimestamp(mtime), req);
+}
+
+/**
+ * Synchronously changes the access and modification
+ * times of a file in the same way as `fs.utimesSync()`.
+ * @param {string | Buffer | URL} path
+ * @param {number | string | Date} atime
+ * @param {number | string | Date} mtime
+ * @returns {void}
+ */
+function lutimesSync(path, atime, mtime) {
+  binding.lutimes(
+    getValidatedPath(path),
+    toUnixTimestamp(atime),
+    toUnixTimestamp(mtime)
+  );
+}
+
+function writeAll(
+  fd,
+  isUserFd,
+  buffer,
+  offset,
+  length,
+  signal,
+  flush,
+  callback
+) {
+  if (signal?.aborted) {
+    const abortError = new AbortError(undefined, { cause: signal.reason });
+    if (isUserFd) {
+      callback(abortError);
+    } else {
+      fs.close(fd, (err) => {
+        callback(aggregateTwoErrors(err, abortError));
+      });
+    }
+    return;
+  }
+  // write(fd, buffer, offset, length, position, callback)
+  fs.write(fd, buffer, offset, length, null, (writeErr, written) => {
+    if (writeErr) {
+      if (isUserFd) {
+        callback(writeErr);
+      } else {
+        fs.close(fd, (err) => {
+          callback(aggregateTwoErrors(err, writeErr));
+        });
+      }
+    } else if (written === length) {
+      if (!flush) {
+        if (isUserFd) {
+          callback(null);
+        } else {
+          fs.close(fd, callback);
+        }
+      } else {
+        fs.fsync(fd, (syncErr) => {
+          if (syncErr) {
+            if (isUserFd) {
+              callback(syncErr);
+            } else {
+              fs.close(fd, (err) => {
+                callback(aggregateTwoErrors(err, syncErr));
+              });
+            }
+          } else if (isUserFd) {
+            callback(null);
+          } else {
+            fs.close(fd, callback);
+          }
+        });
+      }
+    } else {
+      offset += written;
+      length -= written;
+      writeAll(fd, isUserFd, buffer, offset, length, signal, flush, callback);
+    }
+  });
+}
+
+/**
+ * Asynchronously writes data to the file.
+ * @param {string | Buffer | URL | number} path
+ * @param {string | Buffer | TypedArray | DataView} data
+ * @param {{
+ *   encoding?: string | null;
+ *   mode?: number;
+ *   flag?: string;
+ *   signal?: AbortSignal;
+ *   flush?: boolean;
+ *   } | string} [options]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function writeFile(path, data, options, callback) {
+  callback ||= options;
+  validateFunction(callback, "cb");
+  options = getOptions(options, {
+    encoding: "utf8",
+    mode: 0o666,
+    flag: "w",
+    flush: false,
+  });
+  const flag = options.flag || "w";
+  const flush = options.flush ?? false;
+
+  validateBoolean(flush, "options.flush");
+
+  if (!isArrayBufferView(data)) {
+    validateStringAfterArrayBufferView(data, "data");
+    data = Buffer.from(data, options.encoding || "utf8");
+  }
+
+  if (isFd(path)) {
+    const isUserFd = true;
+    const signal = options.signal;
+    writeAll(path, isUserFd, data, 0, data.byteLength, signal, flush, callback);
+    return;
+  }
+
+  if (checkAborted(options.signal, callback)) return;
+
+  fs.open(path, flag, options.mode, (openErr, fd) => {
+    if (openErr) {
+      callback(openErr);
+    } else {
+      const isUserFd = false;
+      const signal = options.signal;
+      writeAll(fd, isUserFd, data, 0, data.byteLength, signal, flush, callback);
+    }
+  });
+}
+
+/**
+ * Synchronously writes data to the file.
+ * @param {string | Buffer | URL | number} path
+ * @param {string | Buffer | TypedArray | DataView} data
+ * @param {{
+ *   encoding?: string | null;
+ *   mode?: number;
+ *   flag?: string;
+ *   flush?: boolean;
+ *   } | string} [options]
+ * @returns {void}
+ */
+function writeFileSync(path, data, options) {
+  options = getOptions(options, {
+    encoding: "utf8",
+    mode: 0o666,
+    flag: "w",
+    flush: false,
+  });
+
+  const flush = options.flush ?? false;
+
+  validateBoolean(flush, "options.flush");
+
+  const flag = options.flag || "w";
+
+  // C++ fast path for string data and UTF8 encoding
+  if (
+    typeof data === "string" &&
+    (options.encoding === "utf8" || options.encoding === "utf-8")
+  ) {
+    if (!isInt32(path)) {
+      path = getValidatedPath(path);
+    }
+
+    return binding.writeFileUtf8(
+      path,
+      data,
+      stringToFlags(flag),
+      parseFileMode(options.mode, "mode", 0o666)
+    );
+  }
+
+  if (!isArrayBufferView(data)) {
+    validateStringAfterArrayBufferView(data, "data");
+    data = Buffer.from(data, options.encoding || "utf8");
+  }
+
+  const isUserFd = isFd(path); // File descriptor ownership
+  const fd = isUserFd ? path : fs.openSync(path, flag, options.mode);
+
+  let offset = 0;
+  let length = data.byteLength;
+  try {
+    while (length > 0) {
+      const written = fs.writeSync(fd, data, offset, length);
+      offset += written;
+      length -= written;
+    }
+
+    if (flush) {
+      fs.fsyncSync(fd);
+    }
+  } finally {
+    if (!isUserFd) fs.closeSync(fd);
+  }
+}
+
+/**
+ * Asynchronously appends data to a file.
+ * @param {string | Buffer | URL | number} path
+ * @param {string | Buffer} data
+ * @param {{
+ *   encoding?: string | null;
+ *   mode?: number;
+ *   flag?: string;
+ *   flush?: boolean;
+ *   } | string} [options]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function appendFile(path, data, options, callback) {
+  callback ||= options;
+  validateFunction(callback, "cb");
+  options = getOptions(options, { encoding: "utf8", mode: 0o666, flag: "a" });
+
+  // Don't make changes directly on options object
+  options = copyObject(options);
+
+  // Force append behavior when using a supplied file descriptor
+  if (!options.flag || isFd(path)) options.flag = "a";
+
+  fs.writeFile(path, data, options, callback);
+}
+
+/**
+ * Synchronously appends data to a file.
+ * @param {string | Buffer | URL | number} path
+ * @param {string | Buffer} data
+ * @param {{
+ *   encoding?: string | null;
+ *   mode?: number;
+ *   flag?: string;
+ *   } | string} [options]
+ * @returns {void}
+ */
+function appendFileSync(path, data, options) {
+  options = getOptions(options, { encoding: "utf8", mode: 0o666, flag: "a" });
+
+  // Don't make changes directly on options object
+  options = copyObject(options);
+
+  // Force append behavior when using a supplied file descriptor
+  if (!options.flag || isFd(path)) options.flag = "a";
+
+  fs.writeFileSync(path, data, options);
+}
+
+/**
+ * Watches for the changes on `filename`.
+ * @param {string | Buffer | URL} filename
+ * @param {string | {
+ *   persistent?: boolean;
+ *   recursive?: boolean;
+ *   encoding?: string;
+ *   signal?: AbortSignal;
+ *   }} [options]
+ * @param {(
+ *   eventType?: string,
+ *   filename?: string | Buffer
+ *   ) => any} [listener]
+ * @returns {watchers.FSWatcher}
+ */
+function watch(filename, options, listener) {
+  if (typeof options === "function") {
+    listener = options;
+  }
+  options = getOptions(options);
+
+  // Don't make changes directly on options object
+  options = copyObject(options);
+
+  if (options.persistent === undefined) options.persistent = true;
+  if (options.recursive === undefined) options.recursive = false;
+
+  let watcher;
+  const watchers = require("internal/fs/watchers");
+  const path = getValidatedPath(filename);
+  // TODO(anonrig): Remove non-native watcher when/if libuv supports recursive.
+  // As of November 2022, libuv does not support recursive file watch on all platforms,
+  // e.g. Linux due to the limitations of inotify.
+  if (options.recursive && !isMacOS && !isWindows) {
+    const nonNativeWatcher = require("internal/fs/recursive_watch");
+    watcher = new nonNativeWatcher.FSWatcher(options);
+    watcher[watchers.kFSWatchStart](path);
+  } else {
+    watcher = new watchers.FSWatcher();
+    watcher[watchers.kFSWatchStart](
+      path,
+      options.persistent,
+      options.recursive,
+      options.encoding
+    );
+  }
+
+  if (listener) {
+    watcher.addListener("change", listener);
+  }
+  if (options.signal) {
+    if (options.signal.aborted) {
+      process.nextTick(() => watcher.close());
+    } else {
+      const listener = () => watcher.close();
+      kResistStopPropagation ??=
+        require("internal/event_target").kResistStopPropagation;
+      options.signal.addEventListener("abort", listener, {
+        __proto__: null,
+        [kResistStopPropagation]: true,
+      });
+      watcher.once("close", () => {
+        options.signal.removeEventListener("abort", listener);
+      });
+    }
+  }
+
+  return watcher;
+}
+
+const statWatchers = new SafeMap();
+
+/**
+ * Watches for changes on `filename`.
+ * @param {string | Buffer | URL} filename
+ * @param {{
+ *   bigint?: boolean;
+ *   persistent?: boolean;
+ *   interval?: number;
+ *   }} [options]
+ * @param {(
+ *   current?: Stats,
+ *   previous?: Stats
+ *   ) => any} listener
+ * @returns {watchers.StatWatcher}
+ */
+function watchFile(filename, options, listener) {
+  filename = getValidatedPath(filename);
+  filename = pathModule.resolve(filename);
+  let stat;
+
+  if (options === null || typeof options !== "object") {
+    listener = options;
+    options = null;
+  }
+
+  options = {
+    // Poll interval in milliseconds. 5007 is what libev used to use. It's
+    // a little on the slow side but let's stick with it for now to keep
+    // behavioral changes to a minimum.
+    interval: 5007,
+    persistent: true,
+    ...options,
+  };
+
+  validateFunction(listener, "listener");
+
+  stat = statWatchers.get(filename);
+  const watchers = require("internal/fs/watchers");
+  if (stat === undefined) {
+    stat = new watchers.StatWatcher(options.bigint);
+    stat[watchers.kFSStatWatcherStart](
+      filename,
+      options.persistent,
+      options.interval
+    );
+    statWatchers.set(filename, stat);
+  } else {
+    stat[watchers.kFSStatWatcherAddOrCleanRef]("add");
+  }
+
+  stat.addListener("change", listener);
+  return stat;
+}
+
+/**
+ * Stops watching for changes on `filename`.
+ * @param {string | Buffer | URL} filename
+ * @param {() => any} [listener]
+ * @returns {void}
+ */
+function unwatchFile(filename, listener) {
+  filename = getValidatedPath(filename);
+  filename = pathModule.resolve(filename);
+  const stat = statWatchers.get(filename);
+
+  if (stat === undefined) return;
+  const watchers = require("internal/fs/watchers");
+  if (typeof listener === "function") {
+    const beforeListenerCount = stat.listenerCount("change");
+    stat.removeListener("change", listener);
+    if (stat.listenerCount("change") < beforeListenerCount)
+      stat[watchers.kFSStatWatcherAddOrCleanRef]("clean");
+  } else {
+    stat.removeAllListeners("change");
+    stat[watchers.kFSStatWatcherAddOrCleanRef]("cleanAll");
+  }
+
+  if (stat.listenerCount("change") === 0) {
+    stat.stop();
+    statWatchers.delete(filename);
+  }
+}
+
+let splitRoot;
+if (isWindows) {
+  // Regex to find the device root on Windows (e.g. 'c:\\'), including trailing
+  // slash.
+  const splitRootRe = /^(?:[a-zA-Z]:|[\\/]{2}[^\\/]+[\\/][^\\/]+)?[\\/]*/;
+  splitRoot = function splitRoot(str) {
+    return SideEffectFreeRegExpPrototypeExec(splitRootRe, str)[0];
+  };
+} else {
+  splitRoot = function splitRoot(str) {
+    for (let i = 0; i < str.length; ++i) {
+      if (StringPrototypeCharCodeAt(str, i) !== CHAR_FORWARD_SLASH)
+        return StringPrototypeSlice(str, 0, i);
+    }
+    return str;
+  };
+}
+
+function encodeRealpathResult(result, options) {
+  if (!options || !options.encoding || options.encoding === "utf8")
+    return result;
+  const asBuffer = Buffer.from(result);
+  if (options.encoding === "buffer") {
+    return asBuffer;
+  }
+  return asBuffer.toString(options.encoding);
+}
+
+// Finds the next portion of a (partial) path, up to the next path delimiter
+let nextPart;
+if (isWindows) {
+  nextPart = function nextPart(p, i) {
+    for (; i < p.length; ++i) {
+      const ch = StringPrototypeCharCodeAt(p, i);
+
+      // Check for a separator character
+      if (ch === CHAR_BACKWARD_SLASH || ch === CHAR_FORWARD_SLASH) return i;
+    }
+    return -1;
+  };
+} else {
+  nextPart = function nextPart(p, i) {
+    return StringPrototypeIndexOf(p, "/", i);
+  };
+}
+
+/**
+ * Returns the resolved pathname.
+ * @param {string | Buffer | URL} p
+ * @param {string | { encoding?: string | null; }} [options]
+ * @returns {string | Buffer}
+ */
+function realpathSync(p, options) {
+  options = getOptions(options);
+  p = toPathIfFileURL(p);
+  if (typeof p !== "string") {
+    p += "";
+  }
+  validatePath(p);
+  p = pathModule.resolve(p);
+
+  const cache = options[realpathCacheKey];
+  const maybeCachedResult = cache?.get(p);
+  if (maybeCachedResult) {
+    return maybeCachedResult;
+  }
+
+  const seenLinks = new SafeMap();
+  const knownHard = new SafeSet();
+  const original = p;
+
+  // Current character position in p
+  let pos;
+  // The partial path so far, including a trailing slash if any
+  let current;
+  // The partial path without a trailing slash (except when pointing at a root)
+  let base;
+  // The partial path scanned in the previous round, with slash
+  let previous;
+
+  // Skip over roots
+  current = base = splitRoot(p);
+  pos = current.length;
+
+  // On windows, check that the root exists. On unix there is no need.
+  if (isWindows) {
+    const out = binding.lstat(
+      base,
+      false,
+      undefined,
+      true /* throwIfNoEntry */
+    );
+    if (out === undefined) {
+      return;
+    }
+    knownHard.add(base);
+  }
+
+  // Walk down the path, swapping out linked path parts for their real
+  // values
+  // NB: p.length changes.
+  while (pos < p.length) {
+    // find the next part
+    const result = nextPart(p, pos);
+    previous = current;
+    if (result === -1) {
+      const last = StringPrototypeSlice(p, pos);
+      current += last;
+      base = previous + last;
+      pos = p.length;
+    } else {
+      current += StringPrototypeSlice(p, pos, result + 1);
+      base = previous + StringPrototypeSlice(p, pos, result);
+      pos = result + 1;
+    }
+
+    // Continue if not a symlink, break if a pipe/socket
+    if (knownHard.has(base) || cache?.get(base) === base) {
+      if (isFileType(statValues, S_IFIFO) || isFileType(statValues, S_IFSOCK)) {
+        break;
+      }
+      continue;
+    }
+
+    let resolvedLink;
+    const maybeCachedResolved = cache?.get(base);
+    if (maybeCachedResolved) {
+      resolvedLink = maybeCachedResolved;
+    } else {
+      // Use stats array directly to avoid creating an fs.Stats instance just
+      // for our internal use.
+
+      const stats = binding.lstat(
+        base,
+        true,
+        undefined,
+        true /* throwIfNoEntry */
+      );
+      if (stats === undefined) {
+        return;
+      }
+
+      if (!isFileType(stats, S_IFLNK)) {
+        knownHard.add(base);
+        cache?.set(base, base);
+        continue;
+      }
+
+      // Read the link if it wasn't read before
+      // dev/ino always return 0 on windows, so skip the check.
+      let linkTarget = null;
+      let id;
+      if (!isWindows) {
+        const dev = BigIntPrototypeToString(stats[0], 32);
+        const ino = BigIntPrototypeToString(stats[7], 32);
+        id = `${dev}:${ino}`;
+        if (seenLinks.has(id)) {
+          linkTarget = seenLinks.get(id);
+        }
+      }
+      if (linkTarget === null) {
+        binding.stat(base, false, undefined, true);
+        linkTarget = binding.readlink(base, undefined);
+      }
+      resolvedLink = pathModule.resolve(previous, linkTarget);
+
+      cache?.set(base, resolvedLink);
+      if (!isWindows) seenLinks.set(id, linkTarget);
+    }
+
+    // Resolve the link, then start over
+    p = pathModule.resolve(resolvedLink, StringPrototypeSlice(p, pos));
+
+    // Skip over roots
+    current = base = splitRoot(p);
+    pos = current.length;
+
+    // On windows, check that the root exists. On unix there is no need.
+    if (isWindows && !knownHard.has(base)) {
+      const out = binding.lstat(
+        base,
+        false,
+        undefined,
+        true /* throwIfNoEntry */
+      );
+      if (out === undefined) {
+        return;
+      }
+      knownHard.add(base);
+    }
+  }
+
+  cache?.set(original, p);
+  return encodeRealpathResult(p, options);
+}
+
+/**
+ * Returns the resolved pathname.
+ * @param {string | Buffer | URL} path
+ * @param {string | { encoding?: string; }} [options]
+ * @returns {string | Buffer}
+ */
+realpathSync.native = (path, options) => {
+  options = getOptions(options);
+  return binding.realpath(getValidatedPath(path), options.encoding);
+};
+
+/**
+ * Asynchronously computes the canonical pathname by
+ * resolving `.`, `..` and symbolic links.
+ * @param {string | Buffer | URL} p
+ * @param {string | { encoding?: string; }} [options]
+ * @param {(
+ *   err?: Error,
+ *   resolvedPath?: string | Buffer
+ *   ) => any} callback
+ * @returns {void}
+ */
+function realpath(p, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+  } else {
+    validateFunction(callback, "cb");
+  }
+  options = getOptions(options);
+  p = toPathIfFileURL(p);
+
+  if (typeof p !== "string") {
+    p += "";
+  }
+  validatePath(p);
+  p = pathModule.resolve(p);
+
+  const seenLinks = new SafeMap();
+  const knownHard = new SafeSet();
+
+  // Current character position in p
+  let pos;
+  // The partial path so far, including a trailing slash if any
+  let current;
+  // The partial path without a trailing slash (except when pointing at a root)
+  let base;
+  // The partial path scanned in the previous round, with slash
+  let previous;
+
+  current = base = splitRoot(p);
+  pos = current.length;
+
+  // On windows, check that the root exists. On unix there is no need.
+  if (isWindows && !knownHard.has(base)) {
+    fs.lstat(base, (err) => {
+      if (err) return callback(err);
+      knownHard.add(base);
+      LOOP();
+    });
+  } else {
+    process.nextTick(LOOP);
+  }
+
+  // Walk down the path, swapping out linked path parts for their real
+  // values
+  function LOOP() {
+    // Stop if scanned past end of path
+    if (pos >= p.length) {
+      return callback(null, encodeRealpathResult(p, options));
+    }
+
+    // find the next part
+    const result = nextPart(p, pos);
+    previous = current;
+    if (result === -1) {
+      const last = StringPrototypeSlice(p, pos);
+      current += last;
+      base = previous + last;
+      pos = p.length;
+    } else {
+      current += StringPrototypeSlice(p, pos, result + 1);
+      base = previous + StringPrototypeSlice(p, pos, result);
+      pos = result + 1;
+    }
+
+    // Continue if not a symlink, break if a pipe/socket
+    if (knownHard.has(base)) {
+      if (isFileType(statValues, S_IFIFO) || isFileType(statValues, S_IFSOCK)) {
+        return callback(null, encodeRealpathResult(p, options));
+      }
+      return process.nextTick(LOOP);
+    }
+
+    return fs.lstat(base, { bigint: true }, gotStat);
+  }
+
+  function gotStat(err, stats) {
+    if (err) return callback(err);
+
+    // If not a symlink, skip to the next path part
+    if (!stats.isSymbolicLink()) {
+      knownHard.add(base);
+      return process.nextTick(LOOP);
+    }
+
+    // Stat & read the link if not read before.
+    // Call `gotTarget()` as soon as the link target is known.
+    // `dev`/`ino` always return 0 on windows, so skip the check.
+    let id;
+    if (!isWindows) {
+      const dev = BigIntPrototypeToString(stats.dev, 32);
+      const ino = BigIntPrototypeToString(stats.ino, 32);
+      id = `${dev}:${ino}`;
+      if (seenLinks.has(id)) {
+        return gotTarget(null, seenLinks.get(id));
+      }
+    }
+    fs.stat(base, (err) => {
+      if (err) return callback(err);
+
+      fs.readlink(base, (err, target) => {
+        if (!isWindows) seenLinks.set(id, target);
+        gotTarget(err, target);
+      });
+    });
+  }
+
+  function gotTarget(err, target) {
+    if (err) return callback(err);
+
+    gotResolvedLink(pathModule.resolve(previous, target));
+  }
+
+  function gotResolvedLink(resolvedLink) {
+    // Resolve the link, then start over
+    p = pathModule.resolve(resolvedLink, StringPrototypeSlice(p, pos));
+    current = base = splitRoot(p);
+    pos = current.length;
+
+    // On windows, check that the root exists. On unix there is no need.
+    if (isWindows && !knownHard.has(base)) {
+      fs.lstat(base, (err) => {
+        if (err) return callback(err);
+        knownHard.add(base);
+        LOOP();
+      });
+    } else {
+      process.nextTick(LOOP);
+    }
+  }
+}
+
+/**
+ * Asynchronously computes the canonical pathname by
+ * resolving `.`, `..` and symbolic links.
+ * @param {string | Buffer | URL} path
+ * @param {string | { encoding?: string; }} [options]
+ * @param {(
+ *   err?: Error,
+ *   resolvedPath?: string | Buffer
+ *   ) => any} callback
+ * @returns {void}
+ */
+realpath.native = (path, options, callback) => {
+  callback = makeCallback(callback || options);
+  options = getOptions(options);
+  path = getValidatedPath(path);
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.realpath(path, options.encoding, req);
+};
+
+/**
+ * Creates a unique temporary directory.
+ * @param {string | Buffer | URL} prefix
+ * @param {string | { encoding?: string; }} [options]
+ * @param {(
+ *   err?: Error,
+ *   directory?: string
+ *   ) => any} callback
+ * @returns {void}
+ */
+function mkdtemp(prefix, options, callback) {
+  callback = makeCallback(typeof options === "function" ? options : callback);
+  options = getOptions(options);
+
+  prefix = getValidatedPath(prefix, "prefix");
+  warnOnNonPortableTemplate(prefix);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.mkdtemp(prefix, options.encoding, req);
+}
+
+/**
+ * Synchronously creates a unique temporary directory.
+ * @param {string | Buffer | URL} prefix
+ * @param {string | { encoding?: string; }} [options]
+ * @returns {string}
+ */
+function mkdtempSync(prefix, options) {
+  options = getOptions(options);
+
+  prefix = getValidatedPath(prefix, "prefix");
+  warnOnNonPortableTemplate(prefix);
+  return binding.mkdtemp(prefix, options.encoding);
+}
+
+/**
+ * Synchronously creates a unique temporary directory.
+ * The returned value is a disposable object which removes the
+ * directory and its contents when disposed.
+ * @param {string | Buffer | URL} prefix
+ * @param {string | { encoding?: string; }} [options]
+ * @returns {object} A disposable object with a "path" property.
+ */
+function mkdtempDisposableSync(prefix, options) {
+  options = getOptions(options);
+
+  prefix = getValidatedPath(prefix, "prefix");
+  warnOnNonPortableTemplate(prefix);
+
+  const path = binding.mkdtemp(prefix, options.encoding);
+  // Stash the full path in case of process.chdir()
+  const fullPath = pathModule.resolve(process.cwd(), path);
+
+  const remove = () => {
+    binding.rmSync(
+      fullPath,
+      0 /* maxRetries */,
+      true /* recursive */,
+      100 /* retryDelay */
+    );
+  };
+  return {
+    path,
+    remove,
+    [SymbolDispose]() {
+      remove();
+    },
+  };
+}
+
+/**
+ * Asynchronously copies `src` to `dest`. By
+ * default, `dest` is overwritten if it already exists.
+ * @param {string | Buffer | URL} src
+ * @param {string | Buffer | URL} dest
+ * @param {number} [mode]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function copyFile(src, dest, mode, callback) {
+  if (typeof mode === "function") {
+    callback = mode;
+    mode = 0;
+  }
+
+  src = getValidatedPath(src, "src");
+  dest = getValidatedPath(dest, "dest");
+  callback = makeCallback(callback);
+
+  const req = new FSReqCallback();
+  req.oncomplete = callback;
+  binding.copyFile(src, dest, mode, req);
+}
+
+/**
+ * Synchronously copies `src` to `dest`. By
+ * default, `dest` is overwritten if it already exists.
+ * @param {string | Buffer | URL} src
+ * @param {string | Buffer | URL} dest
+ * @param {number} [mode]
+ * @returns {void}
+ */
+function copyFileSync(src, dest, mode) {
+  binding.copyFile(
+    getValidatedPath(src, "src"),
+    getValidatedPath(dest, "dest"),
+    mode
+  );
+}
+
+/**
+ * Asynchronously copies `src` to `dest`. `src` can be a file, directory, or
+ * symlink. The contents of directories will be copied recursively.
+ * @param {string | URL} src
+ * @param {string | URL} dest
+ * @param {object} [options]
+ * @param {(err?: Error) => any} callback
+ * @returns {void}
+ */
+function cp(src, dest, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = undefined;
+  }
+  callback = makeCallback(callback);
+  options = validateCpOptions(options);
+  src = getValidatedPath(src, "src");
+  dest = getValidatedPath(dest, "dest");
+  lazyLoadCp();
+  cpFn(src, dest, options, callback);
+}
+
+/**
+ * Synchronously copies `src` to `dest`. `src` can be a file, directory, or
+ * symlink. The contents of directories will be copied recursively.
+ * @param {string | URL} src
+ * @param {string | URL} dest
+ * @param {object} [options]
+ * @returns {void}
+ */
+function cpSync(src, dest, options) {
+  options = validateCpOptions(options);
+  src = getValidatedPath(src, "src");
+  dest = getValidatedPath(dest, "dest");
+  lazyLoadCp();
+  cpSyncFn(src, dest, options);
+}
+
+function lazyLoadStreams() {
+  if (!ReadStream) {
+    ({ ReadStream, WriteStream } = require("internal/fs/streams"));
+    FileReadStream = ReadStream;
+    FileWriteStream = WriteStream;
+  }
+}
+
+/**
+ * Creates a readable stream with a default `highWaterMark`
+ * of 64 KiB.
+ * @param {string | Buffer | URL} path
+ * @param {string | {
+ *   flags?: string;
+ *   encoding?: string;
+ *   fd?: number | FileHandle;
+ *   mode?: number;
+ *   autoClose?: boolean;
+ *   emitClose?: boolean;
+ *   start: number;
+ *   end?: number;
+ *   highWaterMark?: number;
+ *   fs?: object | null;
+ *   signal?: AbortSignal | null;
+ *   }} [options]
+ * @returns {ReadStream}
+ */
+function createReadStream(path, options) {
+  lazyLoadStreams();
+  return new ReadStream(path, options);
+}
+
+/**
+ * Creates a write stream.
+ * @param {string | Buffer | URL} path
+ * @param {string | {
+ *   flags?: string;
+ *   encoding?: string;
+ *   fd?: number | FileHandle;
+ *   mode?: number;
+ *   autoClose?: boolean;
+ *   emitClose?: boolean;
+ *   start: number;
+ *   fs?: object | null;
+ *   signal?: AbortSignal | null;
+ *   highWaterMark?: number;
+ *   flush?: boolean;
+ *   }} [options]
+ * @returns {WriteStream}
+ */
+function createWriteStream(path, options) {
+  lazyLoadStreams();
+  return new WriteStream(path, options);
+}
+
+const lazyGlob = getLazy(() => require("internal/fs/glob").Glob);
+
+function glob(pattern, options, callback) {
+  if (typeof options === "function") {
+    callback = options;
+    options = undefined;
+  }
+  callback = makeCallback(callback);
+
+  const Glob = lazyGlob();
+  PromisePrototypeThen(
+    ArrayFromAsync(new Glob(pattern, options).glob()),
+    (res) => callback(null, res),
+    callback
+  );
+}
+
+function globSync(pattern, options) {
+  const Glob = lazyGlob();
+  return new Glob(pattern, options).globSync();
+}
+
+module.exports = fs = {
+  appendFile,
+  appendFileSync,
+  access,
+  accessSync,
+  chown,
+  chownSync,
+  chmod,
+  chmodSync,
+  close,
+  closeSync,
+  copyFile,
+  copyFileSync,
+  cp,
+  cpSync,
+  createReadStream,
+  createWriteStream,
+  exists,
+  existsSync,
+  fchown,
+  fchownSync,
+  fchmod,
+  fchmodSync,
+  fdatasync,
+  fdatasyncSync,
+  fstat,
+  fstatSync,
+  fsync,
+  fsyncSync,
+  ftruncate,
+  ftruncateSync,
+  futimes,
+  futimesSync,
+  glob,
+  globSync,
+  lchown,
+  lchownSync,
+  lchmod: constants.O_SYMLINK !== undefined ? lchmod : undefined,
+  lchmodSync: constants.O_SYMLINK !== undefined ? lchmodSync : undefined,
+  link,
+  linkSync,
+  lstat,
+  lstatSync,
+  lutimes,
+  lutimesSync,
+  mkdir,
+  mkdirSync,
+  mkdtemp,
+  mkdtempSync,
+  mkdtempDisposableSync,
+  open,
+  openSync,
+  openAsBlob,
+  readdir,
+  readdirSync,
+  read,
+  readSync,
+  readv,
+  readvSync,
+  readFile,
+  readFileSync,
+  readlink,
+  readlinkSync,
+  realpath,
+  realpathSync,
+  rename,
+  renameSync,
+  rm,
+  rmSync,
+  rmdir,
+  rmdirSync,
+  stat,
+  statfs,
+  statSync,
+  statfsSync,
+  symlink,
+  symlinkSync,
+  truncate,
+  truncateSync,
+  unwatchFile,
+  unlink,
+  unlinkSync,
+  utimes,
+  utimesSync,
+  watch,
+  watchFile,
+  writeFile,
+  writeFileSync,
+  write,
+  writeSync,
+  writev,
+  writevSync,
+  Dirent,
+  Stats,
+
+  get ReadStream() {
+    lazyLoadStreams();
+    return ReadStream;
+  },
+
+  set ReadStream(val) {
+    ReadStream = val;
+  },
+
+  get WriteStream() {
+    lazyLoadStreams();
+    return WriteStream;
+  },
+
+  set WriteStream(val) {
+    WriteStream = val;
+  },
+
+  // Legacy names... these have to be separate because of how graceful-fs
+  // (and possibly other) modules monkey patch the values.
+  get FileReadStream() {
+    lazyLoadStreams();
+    return FileReadStream;
+  },
+
+  set FileReadStream(val) {
+    FileReadStream = val;
+  },
+
+  get FileWriteStream() {
+    lazyLoadStreams();
+    return FileWriteStream;
+  },
+
+  set FileWriteStream(val) {
+    FileWriteStream = val;
+  },
+
+  get Utf8Stream() {
+    lazyLoadUtf8Stream();
+    return Utf8Stream;
+  },
+
+  // For tests
+  _toUnixTimestamp: toUnixTimestamp,
+};
+
+defineLazyProperties(fs, "internal/fs/dir", ["Dir", "opendir", "opendirSync"]);
+
+ObjectDefineProperties(fs, {
+  constants: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: constants,
+  },
+  promises: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      promises ??= require("internal/fs/promises").exports;
+      return promises;
+    },
+  },
+});
diff --git a/.codesandbox/node/hello-world.js b/.codesandbox/node/hello-world.js
new file mode 100644
index 0000000000..857229108d
--- /dev/null
+++ b/.codesandbox/node/hello-world.js
@@ -0,0 +1,14 @@
+const http = require('node:http');
+
+const hostname = '127.0.0.1';
+const port = 3000;
+
+const server = http.createServer((req, res) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/plain');
+  res.end('Hello, World!\n');
+});
+
+server.listen(port, hostname, () => {
+  console.log(`Server running at http://${hostname}:${port}/`);
+});
\ No newline at end of file
diff --git a/.codesandbox/node/https.js b/.codesandbox/node/https.js
new file mode 100644
index 0000000000..05fb02fe4f
--- /dev/null
+++ b/.codesandbox/node/https.js
@@ -0,0 +1,660 @@
+'use strict';
+
+const {
+  ArrayPrototypeIndexOf,
+  ArrayPrototypePush,
+  ArrayPrototypeShift,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
+  FunctionPrototypeCall,
+  JSONStringify,
+  NumberParseInt,
+  ObjectAssign,
+  ObjectSetPrototypeOf,
+  ReflectApply,
+  ReflectConstruct,
+  SymbolAsyncDispose,
+} = primordials;
+
+const {
+  assertCrypto,
+  kEmptyObject,
+  promisify,
+  once,
+} = require('internal/util');
+const { ERR_PROXY_TUNNEL } = require('internal/errors').codes;
+assertCrypto();
+
+const tls = require('tls');
+const {
+  kProxyConfig,
+  checkShouldUseProxy,
+  filterEnvForProxies,
+  kWaitForProxyTunnel,
+} = require('internal/http');
+const { Agent: HttpAgent } = require('_http_agent');
+const {
+  httpServerPreClose,
+  Server: HttpServer,
+  setupConnectionsTracking,
+  storeHTTPOptions,
+  _connectionListener,
+} = require('_http_server');
+const { ClientRequest } = require('_http_client');
+let debug = require('internal/util/debuglog').debuglog('https', (fn) => {
+  debug = fn;
+});
+const net = require('net');
+const { URL, urlToHttpOptions, isURL } = require('internal/url');
+const { validateObject } = require('internal/validators');
+const { isIP } = require('internal/net');
+const assert = require('internal/assert');
+const { getOptionValue } = require('internal/options');
+
+function Server(opts, requestListener) {
+  if (!(this instanceof Server)) return new Server(opts, requestListener);
+
+  let ALPNProtocols = ['http/1.1'];
+  if (typeof opts === 'function') {
+    requestListener = opts;
+    opts = kEmptyObject;
+  } else if (opts == null) {
+    opts = kEmptyObject;
+  } else {
+    validateObject(opts, 'options');
+    // Only one of ALPNProtocols and ALPNCallback can be set, so make sure we
+    // only set a default ALPNProtocols if the caller has not set either of them
+    if (opts.ALPNProtocols || opts.ALPNCallback)
+      ALPNProtocols = undefined;
+  }
+
+  FunctionPrototypeCall(storeHTTPOptions, this, opts);
+  FunctionPrototypeCall(tls.Server, this,
+                        {
+                          noDelay: true,
+                          ALPNProtocols,
+                          ...opts,
+                        },
+                        _connectionListener);
+
+  this.httpAllowHalfOpen = false;
+
+  if (requestListener) {
+    this.addListener('request', requestListener);
+  }
+
+  this.addListener('tlsClientError', function addListener(err, conn) {
+    if (!this.emit('clientError', err, conn))
+      conn.destroy(err);
+  });
+
+  this.timeout = 0;
+  this.maxHeadersCount = null;
+  this.on('listening', setupConnectionsTracking);
+}
+
+ObjectSetPrototypeOf(Server.prototype, tls.Server.prototype);
+ObjectSetPrototypeOf(Server, tls.Server);
+
+Server.prototype.closeAllConnections = HttpServer.prototype.closeAllConnections;
+
+Server.prototype.closeIdleConnections = HttpServer.prototype.closeIdleConnections;
+
+Server.prototype.setTimeout = HttpServer.prototype.setTimeout;
+
+Server.prototype.close = function close() {
+  httpServerPreClose(this);
+  ReflectApply(tls.Server.prototype.close, this, arguments);
+  return this;
+};
+
+Server.prototype[SymbolAsyncDispose] = async function() {
+  await FunctionPrototypeCall(promisify(this.close), this);
+};
+
+/**
+ * Creates a new `https.Server` instance.
+ * @param {{
+ *   IncomingMessage?: IncomingMessage;
+ *   ServerResponse?: ServerResponse;
+ *   insecureHTTPParser?: boolean;
+ *   maxHeaderSize?: number;
+ *   }} [opts]
+ * @param {Function} [requestListener]
+ * @returns {Server}
+ */
+function createServer(opts, requestListener) {
+  return new Server(opts, requestListener);
+}
+
+// When proxying a HTTPS request, the following needs to be done:
+// https://datatracker.ietf.org/doc/html/rfc9110#CONNECT
+// 1. Send a CONNECT request to the proxy server.
+// 2. Wait for 200 connection established response to establish the tunnel.
+// 3. Perform TLS handshake with the endpoint over the socket.
+// 4. Tunnel the request using the established connection.
+//
+// This function computes the tunnel configuration for HTTPS requests.
+// The handling of the tunnel connection is done in createConnection.
+function getTunnelConfigForProxiedHttps(agent, reqOptions) {
+  if (!agent[kProxyConfig]) {
+    return null;
+  }
+  if ((reqOptions.protocol || agent.protocol) !== 'https:') {
+    return null;
+  }
+  const shouldUseProxy = checkShouldUseProxy(agent[kProxyConfig], reqOptions);
+  debug(`getTunnelConfigForProxiedHttps should use proxy for ${reqOptions.host}:${reqOptions.port}:`, shouldUseProxy);
+  if (!shouldUseProxy) {
+    return null;
+  }
+  const { auth, href } = agent[kProxyConfig];
+  // The request is a HTTPS request, assemble the payload for establishing the tunnel.
+  const ipType = isIP(reqOptions.host);
+  // The request target must put IPv6 address in square brackets.
+  // Here reqOptions is already processed by urlToHttpOptions so we'll add them back if necessary.
+  // See https://www.rfc-editor.org/rfc/rfc3986#section-3.2.2
+  const requestHost = ipType === 6 ? `[${reqOptions.host}]` : reqOptions.host;
+  const requestPort = reqOptions.port || agent.defaultPort;
+  const endpoint = `${requestHost}:${requestPort}`;
+  // The ClientRequest constructor should already have validated the host and the port.
+  // When the request options come from a string invalid characters would be stripped away,
+  // when it's an object ERR_INVALID_CHAR would be thrown. Here we just assert in case
+  // agent.createConnection() is called with invalid options.
+  assert(!endpoint.includes('\r'));
+  assert(!endpoint.includes('\n'));
+
+  let payload = `CONNECT ${endpoint} HTTP/1.1\r\n`;
+  // The parseProxyConfigFromEnv() method should have already validated the authorization header
+  // value.
+  if (auth) {
+    payload += `proxy-authorization: ${auth}\r\n`;
+  }
+  if (agent.keepAlive || agent.maxSockets !== Infinity) {
+    payload += 'proxy-connection: keep-alive\r\n';
+  }
+  payload += `host: ${endpoint}`;
+  payload += '\r\n\r\n';
+
+  const result = {
+    __proto__: null,
+    proxyTunnelPayload: payload,
+    requestOptions: {  // Options used for the request sent after the tunnel is established.
+      __proto__: null,
+      servername: reqOptions.servername || ipType ? undefined : reqOptions.host,
+      ...reqOptions,
+    },
+  };
+  debug(`updated request for HTTPS proxy ${href} with`, result);
+  return result;
+};
+
+function establishTunnel(agent, socket, options, tunnelConfig, afterSocket) {
+  const { proxyTunnelPayload } = tunnelConfig;
+  // By default, the socket is in paused mode. Read to look for the 200
+  // connection established response.
+  function read() {
+    let chunk;
+    while ((chunk = socket.read()) !== null) {
+      if (onProxyData(chunk) !== -1) {
+        break;
+      }
+    }
+    socket.on('readable', read);
+  }
+
+  function cleanup() {
+    socket.removeListener('end', onProxyEnd);
+    socket.removeListener('error', onProxyError);
+    socket.removeListener('readable', read);
+    socket.setTimeout(0);  // Clear the timeout for the tunnel establishment.
+  }
+
+  function onProxyError(err) {
+    debug('onProxyError', err);
+    cleanup();
+    afterSocket(err, socket);
+  }
+
+  // Read the headers from the chunks and check for the status code. If it fails we
+  // clean up the socket and return an error. Otherwise we establish the tunnel.
+  let buffer = '';
+  function onProxyData(chunk) {
+    const str = chunk.toString();
+    debug('onProxyData', str);
+    buffer += str;
+    const headerEndIndex = buffer.indexOf('\r\n\r\n');
+    if (headerEndIndex === -1) return headerEndIndex;
+    const statusLine = buffer.substring(0, buffer.indexOf('\r\n'));
+    const statusCode = statusLine.split(' ')[1];
+    if (statusCode !== '200') {
+      debug(`onProxyData receives ${statusCode}, cleaning up`);
+      cleanup();
+      const targetHost = proxyTunnelPayload.split('\r')[0].split(' ')[1];
+      const message = `Failed to establish tunnel to ${targetHost} via ${agent[kProxyConfig].href}: ${statusLine}`;
+      const err = new ERR_PROXY_TUNNEL(message);
+      err.statusCode = NumberParseInt(statusCode);
+      afterSocket(err, socket);
+    } else {
+      // https://datatracker.ietf.org/doc/html/rfc9110#CONNECT
+      // RFC 9110 says that it can be 2xx but in the real world, proxy clients generally only
+      // accepts 200.
+      // Proxy servers are not supposed to send anything after the headers - the payload must be
+      // be empty. So after this point we will proceed with the tunnel e.g. starting TLS handshake.
+      debug('onProxyData receives 200, establishing tunnel');
+      cleanup();
+
+      // Reuse the tunneled socket to perform the TLS handshake with the endpoint,
+      // then send the request.
+      const { requestOptions } = tunnelConfig;
+      tunnelConfig.requestOptions = null;
+      requestOptions.socket = socket;
+      let tunneldSocket;
+      const onTLSHandshakeError = (err) => {
+        debug('Propagate error event from tunneled socket to tunnel socket');
+        afterSocket(err, tunneldSocket);
+      };
+      tunneldSocket = tls.connect(requestOptions, () => {
+        debug('TLS handshake over tunnel succeeded');
+        tunneldSocket.removeListener('error', onTLSHandshakeError);
+        afterSocket(null, tunneldSocket);
+      });
+      tunneldSocket.on('free', () => {
+        debug('Propagate free event from tunneled socket to tunnel socket');
+        socket.emit('free');
+      });
+      tunneldSocket.on('error', onTLSHandshakeError);
+    }
+    return headerEndIndex;
+  }
+
+  function onProxyEnd() {
+    cleanup();
+    const err = new ERR_PROXY_TUNNEL('Connection to establish proxy tunnel ended unexpectedly');
+    afterSocket(err, socket);
+  }
+
+  const proxyTunnelTimeout = tunnelConfig.requestOptions.timeout;
+  debug('proxyTunnelTimeout', proxyTunnelTimeout, options.timeout);
+  // It may be worth a separate timeout error/event.
+  // But it also makes sense to treat the tunnel establishment timeout as
+  // a normal timeout for the request.
+  function onProxyTimeout() {
+    debug('onProxyTimeout', proxyTunnelTimeout);
+    cleanup();
+    const err = new ERR_PROXY_TUNNEL(`Connection to establish proxy tunnel timed out after ${proxyTunnelTimeout}ms`);
+    err.proxyTunnelTimeout = proxyTunnelTimeout;
+    afterSocket(err, socket);
+  }
+
+  if (proxyTunnelTimeout && proxyTunnelTimeout > 0) {
+    debug('proxy tunnel setTimeout', proxyTunnelTimeout);
+    socket.setTimeout(proxyTunnelTimeout, onProxyTimeout);
+  }
+
+  socket.on('error', onProxyError);
+  socket.on('end', onProxyEnd);
+  socket.write(proxyTunnelPayload);
+
+  read();
+}
+
+// HTTPS agents.
+// See ProxyConfig in internal/http.js for how the connection should be handled
+// when the agent is configured to use a proxy server.
+function createConnection(...args) {
+  // XXX: This signature (port, host, options) is different from all the other
+  // createConnection() methods.
+  let options, cb;
+  if (args[0] !== null && typeof args[0] === 'object') {
+    options = args[0];
+  } else if (args[1] !== null && typeof args[1] === 'object') {
+    options = { ...args[1] };
+  } else if (args[2] === null || typeof args[2] !== 'object') {
+    options = {};
+  } else {
+    options = { ...args[2] };
+  }
+  if (typeof args[0] === 'number') {
+    options.port = args[0];
+  }
+  if (typeof args[1] === 'string') {
+    options.host = args[1];
+  }
+  if (typeof args[args.length - 1] === 'function') {
+    cb = args[args.length - 1];
+  }
+
+  debug('createConnection', options);
+
+  if (options._agentKey) {
+    const session = this._getSession(options._agentKey);
+    if (session) {
+      debug('reuse session for %j', options._agentKey);
+      options = {
+        session,
+        ...options,
+      };
+    }
+  }
+
+  let socket;
+  const tunnelConfig = getTunnelConfigForProxiedHttps(this, options);
+  debug(`https createConnection should use proxy for ${options.host}:${options.port}:`, tunnelConfig);
+
+  if (!tunnelConfig) {
+    socket = tls.connect(options);
+  } else {
+    const connectOptions = {
+      ...this[kProxyConfig].proxyConnectionOptions,
+    };
+    debug('Create proxy socket', connectOptions);
+    const onError = (err) => {
+      cleanupAndPropagate(err, socket);
+    };
+    const proxyTunnelTimeout = tunnelConfig.requestOptions.timeout;
+    const onTimeout = () => {
+      const err = new ERR_PROXY_TUNNEL(`Connection to establish proxy tunnel timed out after ${proxyTunnelTimeout}ms`);
+      err.proxyTunnelTimeout = proxyTunnelTimeout;
+      cleanupAndPropagate(err, socket);
+    };
+    const cleanupAndPropagate = once((err, currentSocket) => {
+      debug('cleanupAndPropagate', err);
+      socket.removeListener('error', onError);
+      socket.removeListener('timeout', onTimeout);
+      // An error occurred during tunnel establishment, in that case just destroy the socket.
+      // and propagate the error to the callback.
+
+      // When the error comes from unexpected status code, the stream is still in good shape,
+      // in that case let req.onSocket handle the destruction instead.
+      if (err && err.code === 'ERR_PROXY_TUNNEL' && !err.statusCode) {
+        socket.destroy();
+      }
+      // This error should go to:
+      // -> oncreate in Agent.prototype.createSocket
+      // -> closure in Agent.prototype.addRequest or Agent.prototype.removeSocket
+      if (cb) {
+        cb(err, currentSocket);
+      }
+    });
+    const onProxyConnection = () => {
+      socket.removeListener('error', onError);
+      establishTunnel(this, socket, options, tunnelConfig, cleanupAndPropagate);
+    };
+    if (this[kProxyConfig].protocol === 'http:') {
+      socket = net.connect(connectOptions, onProxyConnection);
+    } else {
+      socket = tls.connect(connectOptions, onProxyConnection);
+    }
+
+    socket.on('error', onError);
+    if (proxyTunnelTimeout) {
+      socket.setTimeout(proxyTunnelTimeout, onTimeout);
+    }
+    socket[kWaitForProxyTunnel] = true;
+  }
+
+  if (options._agentKey) {
+    // Cache new session for reuse
+    socket.on('session', (session) => {
+      this._cacheSession(options._agentKey, session);
+    });
+
+    // Evict session on error
+    socket.once('close', (err) => {
+      if (err)
+        this._evictSession(options._agentKey);
+    });
+  }
+
+  return socket;
+}
+
+/**
+ * Creates a new `HttpAgent` instance.
+ * @param {{
+ *   keepAlive?: boolean;
+ *   keepAliveMsecs?: number;
+ *   maxSockets?: number;
+ *   maxTotalSockets?: number;
+ *   maxFreeSockets?: number;
+ *   scheduling?: string;
+ *   timeout?: number;
+ *   maxCachedSessions?: number;
+ *   servername?: string;
+ *   defaultPort?: number;
+ *   protocol?: string;
+ *   proxyEnv?: object;
+ *   }} [options]
+ * @class
+ */
+function Agent(options) {
+  if (!(this instanceof Agent))
+    return new Agent(options);
+
+  options = { __proto__: null, ...options };
+  options.defaultPort ??= 443;
+  options.protocol ??= 'https:';
+  FunctionPrototypeCall(HttpAgent, this, options);
+
+  this.maxCachedSessions = this.options.maxCachedSessions;
+  if (this.maxCachedSessions === undefined)
+    this.maxCachedSessions = 100;
+
+  this._sessionCache = {
+    map: {},
+    list: [],
+  };
+}
+ObjectSetPrototypeOf(Agent.prototype, HttpAgent.prototype);
+ObjectSetPrototypeOf(Agent, HttpAgent);
+Agent.prototype.createConnection = createConnection;
+
+/**
+ * Gets a unique name for a set of options.
+ * @param {{
+ *   host: string;
+ *   port: number;
+ *   localAddress: string;
+ *   family: number;
+ *   }} [options]
+ * @returns {string}
+ */
+Agent.prototype.getName = function getName(options = kEmptyObject) {
+  let name = FunctionPrototypeCall(HttpAgent.prototype.getName, this, options);
+
+  name += ':';
+  if (options.ca)
+    name += options.ca;
+
+  name += ':';
+  if (options.cert)
+    name += options.cert;
+
+  name += ':';
+  if (options.clientCertEngine)
+    name += options.clientCertEngine;
+
+  name += ':';
+  if (options.ciphers)
+    name += options.ciphers;
+
+  name += ':';
+  if (options.key)
+    name += options.key;
+
+  name += ':';
+  if (options.pfx)
+    name += options.pfx;
+
+  name += ':';
+  if (options.rejectUnauthorized !== undefined)
+    name += options.rejectUnauthorized;
+
+  name += ':';
+  if (options.servername && options.servername !== options.host)
+    name += options.servername;
+
+  name += ':';
+  if (options.minVersion)
+    name += options.minVersion;
+
+  name += ':';
+  if (options.maxVersion)
+    name += options.maxVersion;
+
+  name += ':';
+  if (options.secureProtocol)
+    name += options.secureProtocol;
+
+  name += ':';
+  if (options.crl)
+    name += options.crl;
+
+  name += ':';
+  if (options.honorCipherOrder !== undefined)
+    name += options.honorCipherOrder;
+
+  name += ':';
+  if (options.ecdhCurve)
+    name += options.ecdhCurve;
+
+  name += ':';
+  if (options.dhparam)
+    name += options.dhparam;
+
+  name += ':';
+  if (options.secureOptions !== undefined)
+    name += options.secureOptions;
+
+  name += ':';
+  if (options.sessionIdContext)
+    name += options.sessionIdContext;
+
+  name += ':';
+  if (options.sigalgs)
+    name += JSONStringify(options.sigalgs);
+
+  name += ':';
+  if (options.privateKeyIdentifier)
+    name += options.privateKeyIdentifier;
+
+  name += ':';
+  if (options.privateKeyEngine)
+    name += options.privateKeyEngine;
+
+  return name;
+};
+
+Agent.prototype._getSession = function _getSession(key) {
+  return this._sessionCache.map[key];
+};
+
+Agent.prototype._cacheSession = function _cacheSession(key, session) {
+  // Cache is disabled
+  if (this.maxCachedSessions === 0)
+    return;
+
+  // Fast case - update existing entry
+  if (this._sessionCache.map[key]) {
+    this._sessionCache.map[key] = session;
+    return;
+  }
+
+  // Put new entry
+  if (this._sessionCache.list.length >= this.maxCachedSessions) {
+    const oldKey = ArrayPrototypeShift(this._sessionCache.list);
+    debug('evicting %j', oldKey);
+    delete this._sessionCache.map[oldKey];
+  }
+
+  ArrayPrototypePush(this._sessionCache.list, key);
+  this._sessionCache.map[key] = session;
+};
+
+Agent.prototype._evictSession = function _evictSession(key) {
+  const index = ArrayPrototypeIndexOf(this._sessionCache.list, key);
+  if (index === -1)
+    return;
+
+  ArrayPrototypeSplice(this._sessionCache.list, index, 1);
+  delete this._sessionCache.map[key];
+};
+
+const globalAgent = new Agent({
+  keepAlive: true, scheduling: 'lifo', timeout: 5000,
+  // This normalized from both --use-env-proxy and NODE_USE_ENV_PROXY settings.
+  proxyEnv: getOptionValue('--use-env-proxy') ? filterEnvForProxies(process.env) : undefined,
+});
+
+/**
+ * Makes a request to a secure web server.
+ * @param {...any} args
+ * @returns {ClientRequest}
+ */
+function request(...args) {
+  let options = {};
+
+  if (typeof args[0] === 'string') {
+    const urlStr = ArrayPrototypeShift(args);
+    options = urlToHttpOptions(new URL(urlStr));
+  } else if (isURL(args[0])) {
+    options = urlToHttpOptions(ArrayPrototypeShift(args));
+  }
+
+  if (args[0] && typeof args[0] !== 'function') {
+    ObjectAssign(options, ArrayPrototypeShift(args));
+  }
+
+  options._defaultAgent = module.exports.globalAgent;
+  ArrayPrototypeUnshift(args, options);
+
+  return ReflectConstruct(ClientRequest, args);
+}
+
+/**
+ * Makes a GET request to a secure web server.
+ * @param {string | URL} input
+ * @param {{
+ *   agent?: Agent | boolean;
+ *   auth?: string;
+ *   createConnection?: Function;
+ *   defaultPort?: number;
+ *   family?: number;
+ *   headers?: object;
+ *   hints?: number;
+ *   host?: string;
+ *   hostname?: string;
+ *   insecureHTTPParser?: boolean;
+ *   joinDuplicateHeaders?: boolean;
+ *   localAddress?: string;
+ *   localPort?: number;
+ *   lookup?: Function;
+ *   maxHeaderSize?: number;
+ *   method?: string;
+ *   path?: string;
+ *   port?: number;
+ *   protocol?: string;
+ *   setHost?: boolean;
+ *   socketPath?: string;
+ *   timeout?: number;
+ *   signal?: AbortSignal;
+ *   uniqueHeaders?: Array;
+ *   } | string | URL} [options]
+ * @param {Function} [cb]
+ * @returns {ClientRequest}
+ */
+function get(input, options, cb) {
+  const req = request(input, options, cb);
+  req.end();
+  return req;
+}
+
+module.exports = {
+  Agent,
+  globalAgent,
+  Server,
+  createServer,
+  get,
+  request,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/path.js b/.codesandbox/node/path.js
new file mode 100644
index 0000000000..08ee62f347
--- /dev/null
+++ b/.codesandbox/node/path.js
@@ -0,0 +1,1790 @@
+"use strict";
+
+const {
+  ArrayPrototypeIncludes,
+  ArrayPrototypeJoin,
+  ArrayPrototypePush,
+  ArrayPrototypeSlice,
+  FunctionPrototypeBind,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIncludes,
+  StringPrototypeIndexOf,
+  StringPrototypeLastIndexOf,
+  StringPrototypeRepeat,
+  StringPrototypeReplace,
+  StringPrototypeSlice,
+  StringPrototypeSplit,
+  StringPrototypeToLowerCase,
+  StringPrototypeToUpperCase,
+} = primordials;
+
+const {
+  CHAR_UPPERCASE_A,
+  CHAR_LOWERCASE_A,
+  CHAR_UPPERCASE_Z,
+  CHAR_LOWERCASE_Z,
+  CHAR_DOT,
+  CHAR_FORWARD_SLASH,
+  CHAR_BACKWARD_SLASH,
+  CHAR_COLON,
+  CHAR_QUESTION_MARK,
+} = require("internal/constants");
+const { validateObject, validateString } = require("internal/validators");
+
+const { isWindows, getLazy } = require("internal/util");
+
+const lazyMatchGlobPattern = getLazy(
+  () => require("internal/fs/glob").matchGlobPattern
+);
+
+function isPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+}
+
+function isPosixPathSeparator(code) {
+  return code === CHAR_FORWARD_SLASH;
+}
+
+const WINDOWS_RESERVED_NAMES = [
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9",
+  "COM\xb9",
+  "COM\xb2",
+  "COM\xb3",
+  "LPT\xb9",
+  "LPT\xb2",
+  "LPT\xb3",
+];
+
+function isWindowsReservedName(path, colonIndex) {
+  const devicePart = StringPrototypeToUpperCase(
+    StringPrototypeSlice(path, 0, colonIndex)
+  );
+  return ArrayPrototypeIncludes(WINDOWS_RESERVED_NAMES, devicePart);
+}
+
+function isWindowsDeviceRoot(code) {
+  return (
+    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z) ||
+    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z)
+  );
+}
+
+// Resolves . and .. elements in a path with directory names
+function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let code = 0;
+  for (let i = 0; i <= path.length; ++i) {
+    if (i < path.length) code = StringPrototypeCharCodeAt(path, i);
+    else if (isPathSeparator(code)) break;
+    else code = CHAR_FORWARD_SLASH;
+
+    if (isPathSeparator(code)) {
+      if (lastSlash === i - 1 || dots === 1) {
+        // NOOP
+      } else if (dots === 2) {
+        if (
+          res.length < 2 ||
+          lastSegmentLength !== 2 ||
+          StringPrototypeCharCodeAt(res, res.length - 1) !== CHAR_DOT ||
+          StringPrototypeCharCodeAt(res, res.length - 2) !== CHAR_DOT
+        ) {
+          if (res.length > 2) {
+            const lastSlashIndex = res.length - lastSegmentLength - 1;
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = StringPrototypeSlice(res, 0, lastSlashIndex);
+              lastSegmentLength =
+                res.length - 1 - StringPrototypeLastIndexOf(res, separator);
+            }
+            lastSlash = i;
+            dots = 0;
+            continue;
+          } else if (res.length !== 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = i;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? `${separator}..` : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += `${separator}${StringPrototypeSlice(path, lastSlash + 1, i)}`;
+        else res = StringPrototypeSlice(path, lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i;
+      dots = 0;
+    } else if (code === CHAR_DOT && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+
+function formatExt(ext) {
+  return ext ? `${ext[0] === "." ? "" : "."}${ext}` : "";
+}
+
+/**
+ * @param {string} sep
+ * @param {{
+ *  dir?: string;
+ *  root?: string;
+ *  base?: string;
+ *  name?: string;
+ *  ext?: string;
+ *  }} pathObject
+ * @returns {string}
+ */
+function _format(sep, pathObject) {
+  validateObject(pathObject, "pathObject");
+  const dir = pathObject.dir || pathObject.root;
+  const base =
+    pathObject.base || `${pathObject.name || ""}${formatExt(pathObject.ext)}`;
+  if (!dir) {
+    return base;
+  }
+  return dir === pathObject.root ? `${dir}${base}` : `${dir}${sep}${base}`;
+}
+
+const forwardSlashRegExp = /\//g;
+
+const win32 = {
+  /**
+   * path.resolve([from ...], to)
+   * @param {...string} args
+   * @returns {string}
+   */
+  resolve(...args) {
+    let resolvedDevice = "";
+    let resolvedTail = "";
+    let resolvedAbsolute = false;
+
+    for (let i = args.length - 1; i >= -1; i--) {
+      let path;
+      if (i >= 0) {
+        path = args[i];
+        validateString(path, `paths[${i}]`);
+
+        // Skip empty entries
+        if (path.length === 0) {
+          continue;
+        }
+      } else if (resolvedDevice.length === 0) {
+        path = process.cwd();
+        // Fast path for current directory
+        if (
+          args.length === 0 ||
+          (args.length === 1 &&
+            (args[0] === "" || args[0] === ".") &&
+            isPathSeparator(StringPrototypeCharCodeAt(path, 0)))
+        ) {
+          if (!isWindows) {
+            path = StringPrototypeReplace(path, forwardSlashRegExp, "\\");
+          }
+          return path;
+        }
+      } else {
+        // Windows has the concept of drive-specific current working
+        // directories. If we've resolved a drive letter but not yet an
+        // absolute path, get cwd for that drive, or the process cwd if
+        // the drive cwd is not available. We're sure the device is not
+        // a UNC path at this points, because UNC paths are always absolute.
+        path = process.env[`=${resolvedDevice}`] || process.cwd();
+
+        // Verify that a cwd was found and that it actually points
+        // to our drive. If not, default to the drive's root.
+        if (
+          path === undefined ||
+          (StringPrototypeToLowerCase(StringPrototypeSlice(path, 0, 2)) !==
+            StringPrototypeToLowerCase(resolvedDevice) &&
+            StringPrototypeCharCodeAt(path, 2) === CHAR_BACKWARD_SLASH)
+        ) {
+          path = `${resolvedDevice}\\`;
+        }
+      }
+
+      const len = path.length;
+      let rootEnd = 0;
+      let device = "";
+      let isAbsolute = false;
+      const code = StringPrototypeCharCodeAt(path, 0);
+
+      // Try to match a root
+      if (len === 1) {
+        if (isPathSeparator(code)) {
+          // `path` contains just a path separator
+          rootEnd = 1;
+          isAbsolute = true;
+        }
+      } else if (isPathSeparator(code)) {
+        // Possible UNC root
+
+        // If we started with a separator, we know we at least have an
+        // absolute path of some kind (UNC or otherwise)
+        isAbsolute = true;
+
+        if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
+          // Matched double path separator at beginning
+          let j = 2;
+          let last = j;
+          // Match 1 or more non-path separators
+          while (
+            j < len &&
+            !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+          ) {
+            j++;
+          }
+          if (j < len && j !== last) {
+            const firstPart = StringPrototypeSlice(path, last, j);
+            // Matched!
+            last = j;
+            // Match 1 or more path separators
+            while (
+              j < len &&
+              isPathSeparator(StringPrototypeCharCodeAt(path, j))
+            ) {
+              j++;
+            }
+            if (j < len && j !== last) {
+              // Matched!
+              last = j;
+              // Match 1 or more non-path separators
+              while (
+                j < len &&
+                !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+              ) {
+                j++;
+              }
+              if (j === len || j !== last) {
+                if (firstPart !== "." && firstPart !== "?") {
+                  // We matched a UNC root
+                  device = `\\\\${firstPart}\\${StringPrototypeSlice(
+                    path,
+                    last,
+                    j
+                  )}`;
+                  rootEnd = j;
+                } else {
+                  // We matched a device root (e.g. \\\\.\\PHYSICALDRIVE0)
+                  device = `\\\\${firstPart}`;
+                  rootEnd = 4;
+                }
+              }
+            }
+          }
+        } else {
+          rootEnd = 1;
+        }
+      } else if (
+        isWindowsDeviceRoot(code) &&
+        StringPrototypeCharCodeAt(path, 1) === CHAR_COLON
+      ) {
+        // Possible device root
+        device = StringPrototypeSlice(path, 0, 2);
+        rootEnd = 2;
+        if (len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
+          // Treat separator following drive name as an absolute path
+          // indicator
+          isAbsolute = true;
+          rootEnd = 3;
+        }
+      }
+
+      if (device.length > 0) {
+        if (resolvedDevice.length > 0) {
+          if (
+            StringPrototypeToLowerCase(device) !==
+            StringPrototypeToLowerCase(resolvedDevice)
+          )
+            // This path points to another device so it is not applicable
+            continue;
+        } else {
+          resolvedDevice = device;
+        }
+      }
+
+      if (resolvedAbsolute) {
+        if (resolvedDevice.length > 0) break;
+      } else {
+        resolvedTail = `${StringPrototypeSlice(
+          path,
+          rootEnd
+        )}\\${resolvedTail}`;
+        resolvedAbsolute = isAbsolute;
+        if (isAbsolute && resolvedDevice.length > 0) {
+          break;
+        }
+      }
+    }
+
+    // At this point the path should be resolved to a full absolute path,
+    // but handle relative paths to be safe (might happen when process.cwd()
+    // fails)
+
+    // Normalize the tail path
+    resolvedTail = normalizeString(
+      resolvedTail,
+      !resolvedAbsolute,
+      "\\",
+      isPathSeparator
+    );
+
+    return resolvedAbsolute
+      ? `${resolvedDevice}\\${resolvedTail}`
+      : `${resolvedDevice}${resolvedTail}` || ".";
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  normalize(path) {
+    validateString(path, "path");
+    const len = path.length;
+    if (len === 0) return ".";
+    let rootEnd = 0;
+    let device;
+    let isAbsolute = false;
+    const code = StringPrototypeCharCodeAt(path, 0);
+
+    // Try to match a root
+    if (len === 1) {
+      // `path` contains just a single char, exit early to avoid
+      // unnecessary work
+      return isPosixPathSeparator(code) ? "\\" : path;
+    }
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      // If we started with a separator, we know we at least have an absolute
+      // path of some kind (UNC or otherwise)
+      isAbsolute = true;
+
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        while (
+          j < len &&
+          !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+        ) {
+          j++;
+        }
+        if (j < len && j !== last) {
+          const firstPart = StringPrototypeSlice(path, last, j);
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          while (
+            j < len &&
+            isPathSeparator(StringPrototypeCharCodeAt(path, j))
+          ) {
+            j++;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            while (
+              j < len &&
+              !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+            ) {
+              j++;
+            }
+            if (j === len || j !== last) {
+              if (firstPart === "." || firstPart === "?") {
+                // We matched a device root (e.g. \\\\.\\PHYSICALDRIVE0)
+                device = `\\\\${firstPart}`;
+                rootEnd = 4;
+                const colonIndex = StringPrototypeIndexOf(path, ":");
+                // Special case: handle \\?\COM1: or similar reserved device paths
+                const possibleDevice = StringPrototypeSlice(
+                  path,
+                  4,
+                  colonIndex + 1
+                );
+                if (
+                  isWindowsReservedName(
+                    possibleDevice,
+                    possibleDevice.length - 1
+                  )
+                ) {
+                  device = `\\\\?\\${possibleDevice}`;
+                  rootEnd = 4 + possibleDevice.length;
+                }
+              } else if (j === len) {
+                // We matched a UNC root only
+                // Return the normalized version of the UNC root since there
+                // is nothing left to process
+                return `\\\\${firstPart}\\${StringPrototypeSlice(
+                  path,
+                  last
+                )}\\`;
+              } else {
+                // We matched a UNC root with leftovers
+                device = `\\\\${firstPart}\\${StringPrototypeSlice(
+                  path,
+                  last,
+                  j
+                )}`;
+                rootEnd = j;
+              }
+            }
+          }
+        }
+      } else {
+        rootEnd = 1;
+      }
+    } else {
+      const colonIndex = StringPrototypeIndexOf(path, ":");
+      if (colonIndex > 0) {
+        if (isWindowsDeviceRoot(code) && colonIndex === 1) {
+          device = StringPrototypeSlice(path, 0, 2);
+          rootEnd = 2;
+          if (len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
+            isAbsolute = true;
+            rootEnd = 3;
+          }
+        } else if (isWindowsReservedName(path, colonIndex)) {
+          device = StringPrototypeSlice(path, 0, colonIndex + 1);
+          rootEnd = colonIndex + 1;
+        }
+      }
+    }
+
+    let tail =
+      rootEnd < len
+        ? normalizeString(
+            StringPrototypeSlice(path, rootEnd),
+            !isAbsolute,
+            "\\",
+            isPathSeparator
+          )
+        : "";
+    if (tail.length === 0 && !isAbsolute) tail = ".";
+    if (
+      tail.length > 0 &&
+      isPathSeparator(StringPrototypeCharCodeAt(path, len - 1))
+    )
+      tail += "\\";
+    if (
+      !isAbsolute &&
+      device === undefined &&
+      StringPrototypeIncludes(path, ":")
+    ) {
+      // If the original path was not absolute and if we have not been able to
+      // resolve it relative to a particular device, we need to ensure that the
+      // `tail` has not become something that Windows might interpret as an
+      // absolute path. See CVE-2024-36139.
+      if (
+        tail.length >= 2 &&
+        isWindowsDeviceRoot(StringPrototypeCharCodeAt(tail, 0)) &&
+        StringPrototypeCharCodeAt(tail, 1) === CHAR_COLON
+      ) {
+        return `.\\${tail}`;
+      }
+      let index = StringPrototypeIndexOf(path, ":");
+
+      do {
+        if (
+          index === len - 1 ||
+          isPathSeparator(StringPrototypeCharCodeAt(path, index + 1))
+        ) {
+          return `.\\${tail}`;
+        }
+      } while ((index = StringPrototypeIndexOf(path, ":", index + 1)) !== -1);
+    }
+    const colonIndex = StringPrototypeIndexOf(path, ":");
+    if (isWindowsReservedName(path, colonIndex)) {
+      return `.\\${device ?? ""}${tail}`;
+    }
+    if (device === undefined) {
+      return isAbsolute ? `\\${tail}` : tail;
+    }
+    return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;
+  },
+
+  /**
+   * @param {string} path
+   * @returns {boolean}
+   */
+  isAbsolute(path) {
+    validateString(path, "path");
+    const len = path.length;
+    if (len === 0) return false;
+
+    const code = StringPrototypeCharCodeAt(path, 0);
+    return (
+      isPathSeparator(code) ||
+      // Possible device root
+      (len > 2 &&
+        isWindowsDeviceRoot(code) &&
+        StringPrototypeCharCodeAt(path, 1) === CHAR_COLON &&
+        isPathSeparator(StringPrototypeCharCodeAt(path, 2)))
+    );
+  },
+
+  /**
+   * @param {...string} args
+   * @returns {string}
+   */
+  join(...args) {
+    if (args.length === 0) return ".";
+
+    const path = [];
+    for (let i = 0; i < args.length; ++i) {
+      const arg = args[i];
+      validateString(arg, "path");
+      if (arg.length > 0) {
+        ArrayPrototypePush(path, arg);
+      }
+    }
+
+    if (path.length === 0) return ".";
+
+    const firstPart = path[0];
+    let joined = ArrayPrototypeJoin(path, "\\");
+
+    // Make sure that the joined path doesn't start with two slashes, because
+    // normalize() will mistake it for a UNC path then.
+    //
+    // This step is skipped when it is very clear that the user actually
+    // intended to point at a UNC path. This is assumed when the first
+    // non-empty string arguments starts with exactly two slashes followed by
+    // at least one more non-slash character.
+    //
+    // Note that for normalize() to treat a path as a UNC path it needs to
+    // have at least 2 components, so we don't filter for that here.
+    // This means that the user can use join to construct UNC paths from
+    // a server name and a share name; for example:
+    //   path.join('//server', 'share') -> '\\\\server\\share\\')
+    let needsReplace = true;
+    let slashCount = 0;
+    if (isPathSeparator(StringPrototypeCharCodeAt(firstPart, 0))) {
+      ++slashCount;
+      const firstLen = firstPart.length;
+      if (
+        firstLen > 1 &&
+        isPathSeparator(StringPrototypeCharCodeAt(firstPart, 1))
+      ) {
+        ++slashCount;
+        if (firstLen > 2) {
+          if (isPathSeparator(StringPrototypeCharCodeAt(firstPart, 2)))
+            ++slashCount;
+          else {
+            // We matched a UNC path in the first part
+            needsReplace = false;
+          }
+        }
+      }
+    }
+    if (needsReplace) {
+      // Find any more consecutive slashes we need to replace
+      while (
+        slashCount < joined.length &&
+        isPathSeparator(StringPrototypeCharCodeAt(joined, slashCount))
+      ) {
+        slashCount++;
+      }
+
+      // Replace the slashes if needed
+      if (slashCount >= 2)
+        joined = `\\${StringPrototypeSlice(joined, slashCount)}`;
+    }
+
+    // Skip normalization when reserved device names are present
+    const parts = [];
+    let part = "";
+
+    for (let i = 0; i < joined.length; i++) {
+      if (joined[i] === "\\") {
+        if (part) parts.push(part);
+        part = "";
+        // Skip consecutive backslashes
+        while (i + 1 < joined.length && joined[i + 1] === "\\") i++;
+      } else {
+        part += joined[i];
+      }
+    }
+    // Add the final part if any
+    if (part) parts.push(part);
+
+    // Check if any part has a Windows reserved name
+    if (
+      parts.some((p) => {
+        const colonIndex = StringPrototypeIndexOf(p, ":");
+        return colonIndex !== -1 && isWindowsReservedName(p, colonIndex);
+      })
+    ) {
+      // Replace forward slashes with backslashes
+      let result = "";
+      for (let i = 0; i < joined.length; i++) {
+        result += joined[i] === "/" ? "\\" : joined[i];
+      }
+      return result;
+    }
+
+    return win32.normalize(joined);
+  },
+
+  /**
+   * It will solve the relative path from `from` to `to`, for instance
+   * from = 'C:\\orandea\\test\\aaa'
+   * to = 'C:\\orandea\\impl\\bbb'
+   * The output of the function should be: '..\\..\\impl\\bbb'
+   * @param {string} from
+   * @param {string} to
+   * @returns {string}
+   */
+  relative(from, to) {
+    validateString(from, "from");
+    validateString(to, "to");
+
+    if (from === to) return "";
+
+    const fromOrig = win32.resolve(from);
+    const toOrig = win32.resolve(to);
+
+    if (fromOrig === toOrig) return "";
+
+    from = StringPrototypeToLowerCase(fromOrig);
+    to = StringPrototypeToLowerCase(toOrig);
+
+    if (from === to) return "";
+
+    if (fromOrig.length !== from.length || toOrig.length !== to.length) {
+      const fromSplit = StringPrototypeSplit(fromOrig, "\\");
+      const toSplit = StringPrototypeSplit(toOrig, "\\");
+      if (fromSplit[fromSplit.length - 1] === "") {
+        fromSplit.pop();
+      }
+      if (toSplit[toSplit.length - 1] === "") {
+        toSplit.pop();
+      }
+
+      const fromLen = fromSplit.length;
+      const toLen = toSplit.length;
+      const length = fromLen < toLen ? fromLen : toLen;
+
+      let i;
+      for (i = 0; i < length; i++) {
+        if (
+          StringPrototypeToLowerCase(fromSplit[i]) !==
+          StringPrototypeToLowerCase(toSplit[i])
+        ) {
+          break;
+        }
+      }
+
+      if (i === 0) {
+        return toOrig;
+      } else if (i === length) {
+        if (toLen > length) {
+          return ArrayPrototypeJoin(ArrayPrototypeSlice(toSplit, i), "\\");
+        }
+        if (fromLen > length) {
+          return StringPrototypeRepeat("..\\", fromLen - 1 - i) + "..";
+        }
+        return "";
+      }
+
+      return (
+        StringPrototypeRepeat("..\\", fromLen - i) +
+        ArrayPrototypeJoin(ArrayPrototypeSlice(toSplit, i), "\\")
+      );
+    }
+
+    // Trim any leading backslashes
+    let fromStart = 0;
+    while (
+      fromStart < from.length &&
+      StringPrototypeCharCodeAt(from, fromStart) === CHAR_BACKWARD_SLASH
+    ) {
+      fromStart++;
+    }
+    // Trim trailing backslashes (applicable to UNC paths only)
+    let fromEnd = from.length;
+    while (
+      fromEnd - 1 > fromStart &&
+      StringPrototypeCharCodeAt(from, fromEnd - 1) === CHAR_BACKWARD_SLASH
+    ) {
+      fromEnd--;
+    }
+    const fromLen = fromEnd - fromStart;
+
+    // Trim any leading backslashes
+    let toStart = 0;
+    while (
+      toStart < to.length &&
+      StringPrototypeCharCodeAt(to, toStart) === CHAR_BACKWARD_SLASH
+    ) {
+      toStart++;
+    }
+    // Trim trailing backslashes (applicable to UNC paths only)
+    let toEnd = to.length;
+    while (
+      toEnd - 1 > toStart &&
+      StringPrototypeCharCodeAt(to, toEnd - 1) === CHAR_BACKWARD_SLASH
+    ) {
+      toEnd--;
+    }
+    const toLen = toEnd - toStart;
+
+    // Compare paths to find the longest common path from root
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+      const fromCode = StringPrototypeCharCodeAt(from, fromStart + i);
+      if (fromCode !== StringPrototypeCharCodeAt(to, toStart + i)) break;
+      else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;
+    }
+
+    // We found a mismatch before the first common path separator was seen, so
+    // return the original `to`.
+    if (i !== length) {
+      if (lastCommonSep === -1) return toOrig;
+    } else {
+      if (toLen > length) {
+        if (
+          StringPrototypeCharCodeAt(to, toStart + i) === CHAR_BACKWARD_SLASH
+        ) {
+          // We get here if `from` is the exact base path for `to`.
+          // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz'
+          return StringPrototypeSlice(toOrig, toStart + i + 1);
+        }
+        if (i === 2) {
+          // We get here if `from` is the device root.
+          // For example: from='C:\\'; to='C:\\foo'
+          return StringPrototypeSlice(toOrig, toStart + i);
+        }
+      }
+      if (fromLen > length) {
+        if (
+          StringPrototypeCharCodeAt(from, fromStart + i) === CHAR_BACKWARD_SLASH
+        ) {
+          // We get here if `to` is the exact base path for `from`.
+          // For example: from='C:\\foo\\bar'; to='C:\\foo'
+          lastCommonSep = i;
+        } else if (i === 2) {
+          // We get here if `to` is the device root.
+          // For example: from='C:\\foo\\bar'; to='C:\\'
+          lastCommonSep = 3;
+        }
+      }
+      if (lastCommonSep === -1) lastCommonSep = 0;
+    }
+
+    let out = "";
+    // Generate the relative path based on the path difference between `to` and
+    // `from`
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (
+        i === fromEnd ||
+        StringPrototypeCharCodeAt(from, i) === CHAR_BACKWARD_SLASH
+      ) {
+        out += out.length === 0 ? ".." : "\\..";
+      }
+    }
+
+    toStart += lastCommonSep;
+
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts
+    if (out.length > 0)
+      return `${out}${StringPrototypeSlice(toOrig, toStart, toEnd)}`;
+
+    if (StringPrototypeCharCodeAt(toOrig, toStart) === CHAR_BACKWARD_SLASH)
+      ++toStart;
+    return StringPrototypeSlice(toOrig, toStart, toEnd);
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string" || path.length === 0) return path;
+
+    const resolvedPath = win32.resolve(path);
+
+    if (resolvedPath.length <= 2) return path;
+
+    if (StringPrototypeCharCodeAt(resolvedPath, 0) === CHAR_BACKWARD_SLASH) {
+      // Possible UNC root
+      if (StringPrototypeCharCodeAt(resolvedPath, 1) === CHAR_BACKWARD_SLASH) {
+        const code = StringPrototypeCharCodeAt(resolvedPath, 2);
+        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+          // Matched non-long UNC root, convert the path to a long UNC path
+          return `\\\\?\\UNC\\${StringPrototypeSlice(resolvedPath, 2)}`;
+        }
+      }
+    } else if (
+      isWindowsDeviceRoot(StringPrototypeCharCodeAt(resolvedPath, 0)) &&
+      StringPrototypeCharCodeAt(resolvedPath, 1) === CHAR_COLON &&
+      StringPrototypeCharCodeAt(resolvedPath, 2) === CHAR_BACKWARD_SLASH
+    ) {
+      // Matched device root, convert the path to a long UNC path
+      return `\\\\?\\${resolvedPath}`;
+    }
+
+    return resolvedPath;
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  dirname(path) {
+    validateString(path, "path");
+    const len = path.length;
+    if (len === 0) return ".";
+    let rootEnd = -1;
+    let offset = 0;
+    const code = StringPrototypeCharCodeAt(path, 0);
+
+    if (len === 1) {
+      // `path` contains just a path separator, exit early to avoid
+      // unnecessary work or a dot.
+      return isPathSeparator(code) ? path : ".";
+    }
+
+    // Try to match a root
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      rootEnd = offset = 1;
+
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        while (
+          j < len &&
+          !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+        ) {
+          j++;
+        }
+        if (j < len && j !== last) {
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          while (
+            j < len &&
+            isPathSeparator(StringPrototypeCharCodeAt(path, j))
+          ) {
+            j++;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            while (
+              j < len &&
+              !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+            ) {
+              j++;
+            }
+            if (j === len) {
+              // We matched a UNC root only
+              return path;
+            }
+            if (j !== last) {
+              // We matched a UNC root with leftovers
+
+              // Offset by 1 to include the separator after the UNC root to
+              // treat it as a "normal root" on top of a (UNC) root
+              rootEnd = offset = j + 1;
+            }
+          }
+        }
+      }
+      // Possible device root
+    } else if (
+      isWindowsDeviceRoot(code) &&
+      StringPrototypeCharCodeAt(path, 1) === CHAR_COLON
+    ) {
+      rootEnd =
+        len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2)) ? 3 : 2;
+      offset = rootEnd;
+    }
+
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = len - 1; i >= offset; --i) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, i))) {
+        if (!matchedSlash) {
+          end = i;
+          break;
+        }
+      } else {
+        // We saw the first non-path separator
+        matchedSlash = false;
+      }
+    }
+
+    if (end === -1) {
+      if (rootEnd === -1) return ".";
+
+      end = rootEnd;
+    }
+    return StringPrototypeSlice(path, 0, end);
+  },
+
+  /**
+   * @param {string} path
+   * @param {string} [suffix]
+   * @returns {string}
+   */
+  basename(path, suffix) {
+    if (suffix !== undefined) validateString(suffix, "suffix");
+    validateString(path, "path");
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+
+    // Check for a drive letter prefix so as not to mistake the following
+    // path separator as an extra separator at the end of the path that can be
+    // disregarded
+    if (
+      path.length >= 2 &&
+      isWindowsDeviceRoot(StringPrototypeCharCodeAt(path, 0)) &&
+      StringPrototypeCharCodeAt(path, 1) === CHAR_COLON
+    ) {
+      start = 2;
+    }
+
+    if (
+      suffix !== undefined &&
+      suffix.length > 0 &&
+      suffix.length <= path.length
+    ) {
+      if (suffix === path) return "";
+      let extIdx = suffix.length - 1;
+      let firstNonSlashEnd = -1;
+      for (let i = path.length - 1; i >= start; --i) {
+        const code = StringPrototypeCharCodeAt(path, i);
+        if (isPathSeparator(code)) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else {
+          if (firstNonSlashEnd === -1) {
+            // We saw the first non-path separator, remember this index in case
+            // we need it if the extension ends up not matching
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            // Try to match the explicit extension
+            if (code === StringPrototypeCharCodeAt(suffix, extIdx)) {
+              if (--extIdx === -1) {
+                // We matched the extension, so mark this as the end of our path
+                // component
+                end = i;
+              }
+            } else {
+              // Extension does not match, so our result is the entire path
+              // component
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+
+      if (start === end) end = firstNonSlashEnd;
+      else if (end === -1) end = path.length;
+      return StringPrototypeSlice(path, start, end);
+    }
+    for (let i = path.length - 1; i >= start; --i) {
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, i))) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // path component
+        matchedSlash = false;
+        end = i + 1;
+      }
+    }
+
+    if (end === -1) return "";
+    return StringPrototypeSlice(path, start, end);
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  extname(path) {
+    validateString(path, "path");
+    let start = 0;
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+
+    // Check for a drive letter prefix so as not to mistake the following
+    // path separator as an extra separator at the end of the path that can be
+    // disregarded
+
+    if (
+      path.length >= 2 &&
+      StringPrototypeCharCodeAt(path, 1) === CHAR_COLON &&
+      isWindowsDeviceRoot(StringPrototypeCharCodeAt(path, 0))
+    ) {
+      start = startPart = 2;
+    }
+
+    for (let i = path.length - 1; i >= start; --i) {
+      const code = StringPrototypeCharCodeAt(path, i);
+      if (isPathSeparator(code)) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === CHAR_DOT) {
+        // If this is our first dot, mark it as the start of our extension
+        if (startDot === -1) startDot = i;
+        else if (preDotState !== 1) preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (
+      startDot === -1 ||
+      end === -1 ||
+      // We saw a non-dot character immediately before the dot
+      preDotState === 0 ||
+      // The (right-most) trimmed path component is exactly '..'
+      (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    ) {
+      return "";
+    }
+    return StringPrototypeSlice(path, startDot, end);
+  },
+
+  format: FunctionPrototypeBind(_format, null, "\\"),
+
+  /**
+   * @param {string} path
+   * @returns {{
+   *  dir: string;
+   *  root: string;
+   *  base: string;
+   *  name: string;
+   *  ext: string;
+   *  }}
+   */
+  parse(path) {
+    validateString(path, "path");
+
+    const ret = { root: "", dir: "", base: "", ext: "", name: "" };
+    if (path.length === 0) return ret;
+
+    const len = path.length;
+    let rootEnd = 0;
+    let code = StringPrototypeCharCodeAt(path, 0);
+
+    if (len === 1) {
+      if (isPathSeparator(code)) {
+        // `path` contains just a path separator, exit early to avoid
+        // unnecessary work
+        ret.root = ret.dir = path;
+        return ret;
+      }
+      ret.base = ret.name = path;
+      return ret;
+    }
+    // Try to match a root
+    if (isPathSeparator(code)) {
+      // Possible UNC root
+
+      rootEnd = 1;
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
+        // Matched double path separator at beginning
+        let j = 2;
+        let last = j;
+        // Match 1 or more non-path separators
+        while (
+          j < len &&
+          !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+        ) {
+          j++;
+        }
+        if (j < len && j !== last) {
+          // Matched!
+          last = j;
+          // Match 1 or more path separators
+          while (
+            j < len &&
+            isPathSeparator(StringPrototypeCharCodeAt(path, j))
+          ) {
+            j++;
+          }
+          if (j < len && j !== last) {
+            // Matched!
+            last = j;
+            // Match 1 or more non-path separators
+            while (
+              j < len &&
+              !isPathSeparator(StringPrototypeCharCodeAt(path, j))
+            ) {
+              j++;
+            }
+            if (j === len) {
+              // We matched a UNC root only
+              rootEnd = j;
+            } else if (j !== last) {
+              // We matched a UNC root with leftovers
+              rootEnd = j + 1;
+            }
+          }
+        }
+      }
+    } else if (
+      isWindowsDeviceRoot(code) &&
+      StringPrototypeCharCodeAt(path, 1) === CHAR_COLON
+    ) {
+      // Possible device root
+      if (len <= 2) {
+        // `path` contains just a drive root, exit early to avoid
+        // unnecessary work
+        ret.root = ret.dir = path;
+        return ret;
+      }
+      rootEnd = 2;
+      if (isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
+        if (len === 3) {
+          // `path` contains just a drive root, exit early to avoid
+          // unnecessary work
+          ret.root = ret.dir = path;
+          return ret;
+        }
+        rootEnd = 3;
+      }
+    }
+    if (rootEnd > 0) ret.root = StringPrototypeSlice(path, 0, rootEnd);
+
+    let startDot = -1;
+    let startPart = rootEnd;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+
+    // Get non-dir info
+    for (; i >= rootEnd; --i) {
+      code = StringPrototypeCharCodeAt(path, i);
+      if (isPathSeparator(code)) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === CHAR_DOT) {
+        // If this is our first dot, mark it as the start of our extension
+        if (startDot === -1) startDot = i;
+        else if (preDotState !== 1) preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (end !== -1) {
+      if (
+        startDot === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 &&
+          startDot === end - 1 &&
+          startDot === startPart + 1)
+      ) {
+        ret.base = ret.name = StringPrototypeSlice(path, startPart, end);
+      } else {
+        ret.name = StringPrototypeSlice(path, startPart, startDot);
+        ret.base = StringPrototypeSlice(path, startPart, end);
+        ret.ext = StringPrototypeSlice(path, startDot, end);
+      }
+    }
+
+    // If the directory is the root, use the entire root as the `dir` including
+    // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the
+    // trailing slash (`C:\abc\def` -> `C:\abc`).
+    if (startPart > 0 && startPart !== rootEnd)
+      ret.dir = StringPrototypeSlice(path, 0, startPart - 1);
+    else ret.dir = ret.root;
+
+    return ret;
+  },
+
+  matchesGlob(path, pattern) {
+    return lazyMatchGlobPattern()(path, pattern, true);
+  },
+
+  sep: "\\",
+  delimiter: ";",
+  win32: null,
+  posix: null,
+};
+
+const posixCwd = (() => {
+  if (isWindows) {
+    // Converts Windows' backslash path separators to POSIX forward slashes
+    // and truncates any drive indicator
+    const regexp = /\\/g;
+    return () => {
+      const cwd = StringPrototypeReplace(process.cwd(), regexp, "/");
+      return StringPrototypeSlice(cwd, StringPrototypeIndexOf(cwd, "/"));
+    };
+  }
+
+  // We're already on POSIX, no need for any transformations
+  return () => process.cwd();
+})();
+
+const posix = {
+  /**
+   * path.resolve([from ...], to)
+   * @param {...string} args
+   * @returns {string}
+   */
+  resolve(...args) {
+    if (
+      args.length === 0 ||
+      (args.length === 1 && (args[0] === "" || args[0] === "."))
+    ) {
+      const cwd = posixCwd();
+      if (StringPrototypeCharCodeAt(cwd, 0) === CHAR_FORWARD_SLASH) {
+        return cwd;
+      }
+    }
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+
+    for (let i = args.length - 1; i >= 0 && !resolvedAbsolute; i--) {
+      const path = args[i];
+      validateString(path, `paths[${i}]`);
+
+      // Skip empty entries
+      if (path.length === 0) {
+        continue;
+      }
+
+      resolvedPath = `${path}/${resolvedPath}`;
+      resolvedAbsolute =
+        StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
+    }
+
+    if (!resolvedAbsolute) {
+      const cwd = posixCwd();
+      resolvedPath = `${cwd}/${resolvedPath}`;
+      resolvedAbsolute =
+        StringPrototypeCharCodeAt(cwd, 0) === CHAR_FORWARD_SLASH;
+    }
+
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+
+    // Normalize the path
+    resolvedPath = normalizeString(
+      resolvedPath,
+      !resolvedAbsolute,
+      "/",
+      isPosixPathSeparator
+    );
+
+    if (resolvedAbsolute) {
+      return `/${resolvedPath}`;
+    }
+    return resolvedPath.length > 0 ? resolvedPath : ".";
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  normalize(path) {
+    validateString(path, "path");
+
+    if (path.length === 0) return ".";
+
+    const isAbsolute =
+      StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
+    const trailingSeparator =
+      StringPrototypeCharCodeAt(path, path.length - 1) === CHAR_FORWARD_SLASH;
+
+    // Normalize the path
+    path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
+
+    if (path.length === 0) {
+      if (isAbsolute) return "/";
+      return trailingSeparator ? "./" : ".";
+    }
+    if (trailingSeparator) path += "/";
+
+    return isAbsolute ? `/${path}` : path;
+  },
+
+  /**
+   * @param {string} path
+   * @returns {boolean}
+   */
+  isAbsolute(path) {
+    validateString(path, "path");
+    return (
+      path.length > 0 &&
+      StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH
+    );
+  },
+
+  /**
+   * @param {...string} args
+   * @returns {string}
+   */
+  join(...args) {
+    if (args.length === 0) return ".";
+
+    const path = [];
+    for (let i = 0; i < args.length; ++i) {
+      const arg = args[i];
+      validateString(arg, "path");
+      if (arg.length > 0) {
+        path.push(arg);
+      }
+    }
+
+    if (path.length === 0) return ".";
+
+    return posix.normalize(ArrayPrototypeJoin(path, "/"));
+  },
+
+  /**
+   * @param {string} from
+   * @param {string} to
+   * @returns {string}
+   */
+  relative(from, to) {
+    validateString(from, "from");
+    validateString(to, "to");
+
+    if (from === to) return "";
+
+    // Trim leading forward slashes.
+    from = posix.resolve(from);
+    to = posix.resolve(to);
+
+    if (from === to) return "";
+
+    const fromStart = 1;
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    const toStart = 1;
+    const toLen = to.length - toStart;
+
+    // Compare paths to find the longest common path from root
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+      const fromCode = StringPrototypeCharCodeAt(from, fromStart + i);
+      if (fromCode !== StringPrototypeCharCodeAt(to, toStart + i)) break;
+      else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;
+    }
+    if (i === length) {
+      if (toLen > length) {
+        if (StringPrototypeCharCodeAt(to, toStart + i) === CHAR_FORWARD_SLASH) {
+          // We get here if `from` is the exact base path for `to`.
+          // For example: from='/foo/bar'; to='/foo/bar/baz'
+          return StringPrototypeSlice(to, toStart + i + 1);
+        }
+        if (i === 0) {
+          // We get here if `from` is the root
+          // For example: from='/'; to='/foo'
+          return StringPrototypeSlice(to, toStart + i);
+        }
+      } else if (fromLen > length) {
+        if (
+          StringPrototypeCharCodeAt(from, fromStart + i) === CHAR_FORWARD_SLASH
+        ) {
+          // We get here if `to` is the exact base path for `from`.
+          // For example: from='/foo/bar/baz'; to='/foo/bar'
+          lastCommonSep = i;
+        } else if (i === 0) {
+          // We get here if `to` is the root.
+          // For example: from='/foo/bar'; to='/'
+          lastCommonSep = 0;
+        }
+      }
+    }
+
+    let out = "";
+    // Generate the relative path based on the path difference between `to`
+    // and `from`.
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+      if (
+        i === fromEnd ||
+        StringPrototypeCharCodeAt(from, i) === CHAR_FORWARD_SLASH
+      ) {
+        out += out.length === 0 ? ".." : "/..";
+      }
+    }
+
+    // Lastly, append the rest of the destination (`to`) path that comes after
+    // the common path parts.
+    return `${out}${StringPrototypeSlice(to, toStart + lastCommonSep)}`;
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  toNamespacedPath(path) {
+    // Non-op on posix systems
+    return path;
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  dirname(path) {
+    validateString(path, "path");
+    if (path.length === 0) return ".";
+    const hasRoot = StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+      if (StringPrototypeCharCodeAt(path, i) === CHAR_FORWARD_SLASH) {
+        if (!matchedSlash) {
+          end = i;
+          break;
+        }
+      } else {
+        // We saw the first non-path separator
+        matchedSlash = false;
+      }
+    }
+
+    if (end === -1) return hasRoot ? "/" : ".";
+    if (hasRoot && end === 1) return "//";
+    return StringPrototypeSlice(path, 0, end);
+  },
+
+  /**
+   * @param {string} path
+   * @param {string} [suffix]
+   * @returns {string}
+   */
+  basename(path, suffix) {
+    if (suffix !== undefined) validateString(suffix, "suffix");
+    validateString(path, "path");
+
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+
+    if (
+      suffix !== undefined &&
+      suffix.length > 0 &&
+      suffix.length <= path.length
+    ) {
+      if (suffix === path) return "";
+      let extIdx = suffix.length - 1;
+      let firstNonSlashEnd = -1;
+      for (let i = path.length - 1; i >= 0; --i) {
+        const code = StringPrototypeCharCodeAt(path, i);
+        if (code === CHAR_FORWARD_SLASH) {
+          // If we reached a path separator that was not part of a set of path
+          // separators at the end of the string, stop now
+          if (!matchedSlash) {
+            start = i + 1;
+            break;
+          }
+        } else {
+          if (firstNonSlashEnd === -1) {
+            // We saw the first non-path separator, remember this index in case
+            // we need it if the extension ends up not matching
+            matchedSlash = false;
+            firstNonSlashEnd = i + 1;
+          }
+          if (extIdx >= 0) {
+            // Try to match the explicit extension
+            if (code === StringPrototypeCharCodeAt(suffix, extIdx)) {
+              if (--extIdx === -1) {
+                // We matched the extension, so mark this as the end of our path
+                // component
+                end = i;
+              }
+            } else {
+              // Extension does not match, so our result is the entire path
+              // component
+              extIdx = -1;
+              end = firstNonSlashEnd;
+            }
+          }
+        }
+      }
+
+      if (start === end) end = firstNonSlashEnd;
+      else if (end === -1) end = path.length;
+      return StringPrototypeSlice(path, start, end);
+    }
+    for (let i = path.length - 1; i >= 0; --i) {
+      if (StringPrototypeCharCodeAt(path, i) === CHAR_FORWARD_SLASH) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // path component
+        matchedSlash = false;
+        end = i + 1;
+      }
+    }
+
+    if (end === -1) return "";
+    return StringPrototypeSlice(path, start, end);
+  },
+
+  /**
+   * @param {string} path
+   * @returns {string}
+   */
+  extname(path) {
+    validateString(path, "path");
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+    for (let i = path.length - 1; i >= 0; --i) {
+      const char = path[i];
+      if (char === "/") {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (char === ".") {
+        // If this is our first dot, mark it as the start of our extension
+        if (startDot === -1) startDot = i;
+        else if (preDotState !== 1) preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (
+      startDot === -1 ||
+      end === -1 ||
+      // We saw a non-dot character immediately before the dot
+      preDotState === 0 ||
+      // The (right-most) trimmed path component is exactly '..'
+      (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    ) {
+      return "";
+    }
+    return StringPrototypeSlice(path, startDot, end);
+  },
+
+  format: FunctionPrototypeBind(_format, null, "/"),
+
+  /**
+   * @param {string} path
+   * @returns {{
+   *   dir: string;
+   *   root: string;
+   *   base: string;
+   *   name: string;
+   *   ext: string;
+   *   }}
+   */
+  parse(path) {
+    validateString(path, "path");
+
+    const ret = { root: "", dir: "", base: "", ext: "", name: "" };
+    if (path.length === 0) return ret;
+    const isAbsolute =
+      StringPrototypeCharCodeAt(path, 0) === CHAR_FORWARD_SLASH;
+    let start;
+    if (isAbsolute) {
+      ret.root = "/";
+      start = 1;
+    } else {
+      start = 0;
+    }
+    let startDot = -1;
+    let startPart = 0;
+    let end = -1;
+    let matchedSlash = true;
+    let i = path.length - 1;
+
+    // Track the state of characters (if any) we see before our first dot and
+    // after any path separator we find
+    let preDotState = 0;
+
+    // Get non-dir info
+    for (; i >= start; --i) {
+      const code = StringPrototypeCharCodeAt(path, i);
+      if (code === CHAR_FORWARD_SLASH) {
+        // If we reached a path separator that was not part of a set of path
+        // separators at the end of the string, stop now
+        if (!matchedSlash) {
+          startPart = i + 1;
+          break;
+        }
+        continue;
+      }
+      if (end === -1) {
+        // We saw the first non-path separator, mark this as the end of our
+        // extension
+        matchedSlash = false;
+        end = i + 1;
+      }
+      if (code === CHAR_DOT) {
+        // If this is our first dot, mark it as the start of our extension
+        if (startDot === -1) startDot = i;
+        else if (preDotState !== 1) preDotState = 1;
+      } else if (startDot !== -1) {
+        // We saw a non-dot and non-path separator before our dot, so we should
+        // have a good chance at having a non-empty extension
+        preDotState = -1;
+      }
+    }
+
+    if (end !== -1) {
+      const start = startPart === 0 && isAbsolute ? 1 : startPart;
+      if (
+        startDot === -1 ||
+        // We saw a non-dot character immediately before the dot
+        preDotState === 0 ||
+        // The (right-most) trimmed path component is exactly '..'
+        (preDotState === 1 &&
+          startDot === end - 1 &&
+          startDot === startPart + 1)
+      ) {
+        ret.base = ret.name = StringPrototypeSlice(path, start, end);
+      } else {
+        ret.name = StringPrototypeSlice(path, start, startDot);
+        ret.base = StringPrototypeSlice(path, start, end);
+        ret.ext = StringPrototypeSlice(path, startDot, end);
+      }
+    }
+
+    if (startPart > 0) ret.dir = StringPrototypeSlice(path, 0, startPart - 1);
+    else if (isAbsolute) ret.dir = "/";
+
+    return ret;
+  },
+
+  matchesGlob(path, pattern) {
+    return lazyMatchGlobPattern()(path, pattern, false);
+  },
+
+  sep: "/",
+  delimiter: ":",
+  win32: null,
+  posix: null,
+};
+
+posix.win32 = win32.win32 = win32;
+posix.posix = win32.posix = posix;
+
+// Legacy internal API, docs-only deprecated: DEP0080
+win32._makeLong = win32.toNamespacedPath;
+posix._makeLong = posix.toNamespacedPath;
+
+module.exports = isWindows ? win32 : posix;
diff --git a/.codesandbox/node/perf_hooks.js b/.codesandbox/node/perf_hooks.js
new file mode 100644
index 0000000000..3abbec8469
--- /dev/null
+++ b/.codesandbox/node/perf_hooks.js
@@ -0,0 +1,47 @@
+"use strict";
+
+const { ObjectDefineProperty } = primordials;
+
+const { constants } = internalBinding("performance");
+
+const { PerformanceEntry } = require("internal/perf/performance_entry");
+const { PerformanceResourceTiming } = require("internal/perf/resource_timing");
+const {
+  PerformanceObserver,
+  PerformanceObserverEntryList,
+} = require("internal/perf/observe");
+const {
+  PerformanceMark,
+  PerformanceMeasure,
+} = require("internal/perf/usertiming");
+const { Performance, performance } = require("internal/perf/performance");
+
+const { createHistogram } = require("internal/histogram");
+
+const monitorEventLoopDelay = require("internal/perf/event_loop_delay");
+const {
+  eventLoopUtilization,
+} = require("internal/perf/event_loop_utilization");
+const timerify = require("internal/perf/timerify");
+
+module.exports = {
+  Performance,
+  PerformanceEntry,
+  PerformanceMark,
+  PerformanceMeasure,
+  PerformanceObserver,
+  PerformanceObserverEntryList,
+  PerformanceResourceTiming,
+  monitorEventLoopDelay,
+  eventLoopUtilization,
+  timerify,
+  createHistogram,
+  performance,
+};
+
+ObjectDefineProperty(module.exports, "constants", {
+  __proto__: null,
+  configurable: false,
+  enumerable: true,
+  value: constants,
+});
diff --git a/.codesandbox/node/section-links.js b/.codesandbox/node/section-links.js
new file mode 100644
index 0000000000..e3a25655b1
--- /dev/null
+++ b/.codesandbox/node/section-links.js
@@ -0,0 +1,21 @@
+document.addEventListener('DOMContentLoaded', function(event) {
+    function f(n) {
+      if (n.nodeType == 1 && n.tagName.match(/^H[1-6]$/)) {
+        var span = document.createElement('span');
+        span.className = 'section-link';
+        span.textContent = '\xa0';
+        var a = document.createElement('a');
+        a.href = '#' + n.parentNode.id;
+        a.textContent = '\xb6';
+        span.appendChild(a);
+        n.appendChild(span);
+      } else {
+        n = n.firstChild;
+        while (n) {
+          f(n);
+          n = n.nextSibling;
+        }
+      }
+    }
+    f(document.getElementById('sections'));
+  }, false);
\ No newline at end of file
diff --git a/.codesandbox/node/string_decoder.js b/.codesandbox/node/string_decoder.js
new file mode 100644
index 0000000000..b774af1b40
--- /dev/null
+++ b/.codesandbox/node/string_decoder.js
@@ -0,0 +1,125 @@
+'use strict';
+
+const {
+  ArrayBufferIsView,
+  ObjectDefineProperties,
+  Symbol,
+  TypedArrayPrototypeSubarray,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const {
+  kIncompleteCharactersStart,
+  kIncompleteCharactersEnd,
+  kMissingBytes,
+  kBufferedBytes,
+  kEncodingField,
+  kSize,
+  decode,
+  flush,
+} = internalBinding('string_decoder');
+const {
+  encodingsMap,
+  normalizeEncoding,
+} = require('internal/util');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_THIS,
+  ERR_UNKNOWN_ENCODING,
+} = require('internal/errors').codes;
+
+const kNativeDecoder = Symbol('kNativeDecoder');
+
+/**
+ * StringDecoder provides an interface for efficiently splitting a series of
+ * buffers into a series of JS strings without breaking apart multibyte
+ * characters.
+ * @param {string} [encoding]
+ */
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  if (this.encoding === undefined) {
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+  }
+  this[kNativeDecoder] = Buffer.alloc(kSize);
+  this[kNativeDecoder][kEncodingField] = encodingsMap[this.encoding];
+}
+
+/**
+ * Returns a decoded string, omitting any incomplete multi-bytes
+ * characters at the end of the Buffer, or TypedArray, or DataView
+ * @param {string | Buffer | TypedArray | DataView} buf
+ * @returns {string}
+ * @throws {TypeError} Throws when buf is not in one of supported types
+ */
+StringDecoder.prototype.write = function write(buf) {
+  if (typeof buf === 'string')
+    return buf;
+  if (!ArrayBufferIsView(buf))
+    throw new ERR_INVALID_ARG_TYPE('buf',
+                                   ['Buffer', 'TypedArray', 'DataView'],
+                                   buf);
+  if (!this[kNativeDecoder]) {
+    throw new ERR_INVALID_THIS('StringDecoder');
+  }
+  return decode(this[kNativeDecoder], buf);
+};
+
+/**
+ * Returns any remaining input stored in the internal buffer as a string.
+ * After end() is called, the stringDecoder object can be reused for new
+ * input.
+ * @param {string | Buffer | TypedArray | DataView} [buf]
+ * @returns {string}
+ */
+StringDecoder.prototype.end = function end(buf) {
+  const ret = buf === undefined ? '' : this.write(buf);
+  if (this[kNativeDecoder][kBufferedBytes] > 0)
+    return ret + flush(this[kNativeDecoder]);
+  return ret;
+};
+
+/* Everything below this line is undocumented legacy stuff. */
+/**
+ *
+ * @param {string | Buffer | TypedArray | DataView} buf
+ * @param {number} offset
+ * @returns {string}
+ */
+StringDecoder.prototype.text = function text(buf, offset) {
+  this[kNativeDecoder][kMissingBytes] = 0;
+  this[kNativeDecoder][kBufferedBytes] = 0;
+  return this.write(buf.slice(offset));
+};
+
+ObjectDefineProperties(StringDecoder.prototype, {
+  lastChar: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return TypedArrayPrototypeSubarray(this[kNativeDecoder],
+                                         kIncompleteCharactersStart,
+                                         kIncompleteCharactersEnd);
+    },
+  },
+  lastNeed: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return this[kNativeDecoder][kMissingBytes];
+    },
+  },
+  lastTotal: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return this[kNativeDecoder][kBufferedBytes] +
+             this[kNativeDecoder][kMissingBytes];
+    },
+  },
+});
+
+exports.StringDecoder = StringDecoder;
\ No newline at end of file
diff --git a/.codesandbox/node/task_processor.js b/.codesandbox/node/task_processor.js
new file mode 100644
index 0000000000..ebb455eee0
--- /dev/null
+++ b/.codesandbox/node/task_processor.js
@@ -0,0 +1,91 @@
+const { parentPort } = require('node:worker_threads');
+parentPort.on('message', (task) => {
+  parentPort.postMessage(task.a + task.b);
+});
+const { AsyncResource } = require('node:async_hooks');
+const { EventEmitter } = require('node:events');
+const path = require('node:path');
+const { Worker } = require('node:worker_threads');
+
+const kTaskInfo = Symbol('kTaskInfo');
+const kWorkerFreedEvent = Symbol('kWorkerFreedEvent');
+
+class WorkerPoolTaskInfo extends AsyncResource {
+  constructor(callback) {
+    super('WorkerPoolTaskInfo');
+    this.callback = callback;
+  }
+
+  done(err, result) {
+    this.runInAsyncScope(this.callback, null, err, result);
+    this.emitDestroy();  // `TaskInfo`s are used only once.
+  }
+}
+
+class WorkerPool extends EventEmitter {
+  constructor(numThreads) {
+    super();
+    this.numThreads = numThreads;
+    this.workers = [];
+    this.freeWorkers = [];
+    this.tasks = [];
+
+    for (let i = 0; i < numThreads; i++)
+      this.addNewWorker();
+
+    // Any time the kWorkerFreedEvent is emitted, dispatch
+    // the next task pending in the queue, if any.
+    this.on(kWorkerFreedEvent, () => {
+      if (this.tasks.length > 0) {
+        const { task, callback } = this.tasks.shift();
+        this.runTask(task, callback);
+      }
+    });
+  }
+
+  addNewWorker() {
+    const worker = new Worker(path.resolve(__dirname, 'task_processor.js'));
+    worker.on('message', (result) => {
+      // In case of success: Call the callback that was passed to `runTask`,
+      // remove the `TaskInfo` associated with the Worker, and mark it as free
+      // again.
+      worker[kTaskInfo].done(null, result);
+      worker[kTaskInfo] = null;
+      this.freeWorkers.push(worker);
+      this.emit(kWorkerFreedEvent);
+    });
+    worker.on('error', (err) => {
+      // In case of an uncaught exception: Call the callback that was passed to
+      // `runTask` with the error.
+      if (worker[kTaskInfo])
+        worker[kTaskInfo].done(err, null);
+      else
+        this.emit('error', err);
+      // Remove the worker from the list and start a new Worker to replace the
+      // current one.
+      this.workers.splice(this.workers.indexOf(worker), 1);
+      this.addNewWorker();
+    });
+    this.workers.push(worker);
+    this.freeWorkers.push(worker);
+    this.emit(kWorkerFreedEvent);
+  }
+
+  runTask(task, callback) {
+    if (this.freeWorkers.length === 0) {
+      // No free threads, wait until a worker thread becomes free.
+      this.tasks.push({ task, callback });
+      return;
+    }
+
+    const worker = this.freeWorkers.pop();
+    worker[kTaskInfo] = new WorkerPoolTaskInfo(callback);
+    worker.postMessage(task);
+  }
+
+  close() {
+    for (const worker of this.workers) worker.terminate();
+  }
+}
+
+module.exports = WorkerPool;
\ No newline at end of file
diff --git a/.codesandbox/node/tls.js b/.codesandbox/node/tls.js
new file mode 100644
index 0000000000..f412d811a3
--- /dev/null
+++ b/.codesandbox/node/tls.js
@@ -0,0 +1,443 @@
+'use strict';
+
+const {
+  Array,
+  ArrayIsArray,
+  // eslint-disable-next-line no-restricted-syntax
+  ArrayPrototypePush,
+  JSONParse,
+  ObjectDefineProperty,
+  ObjectFreeze,
+  StringFromCharCode,
+} = primordials;
+
+const {
+  ERR_TLS_CERT_ALTNAME_FORMAT,
+  ERR_TLS_CERT_ALTNAME_INVALID,
+  ERR_OUT_OF_RANGE,
+  ERR_INVALID_ARG_VALUE,
+  ERR_INVALID_ARG_TYPE,
+} = require('internal/errors').codes;
+
+const {
+  getBundledRootCertificates,
+  getExtraCACertificates,
+  getSystemCACertificates,
+  resetRootCertStore,
+  getUserRootCertificates,
+  getSSLCiphers,
+  startLoadingCertificatesOffThread,
+} = internalBinding('crypto');
+
+// Start loading root certificates in a separate thread as early as possible
+// once the tls module is loaded, so that by the time an actual TLS connection is
+// made, the loading is done.
+startLoadingCertificatesOffThread();
+
+const internalUtil = require('internal/util');
+internalUtil.assertCrypto();
+const {
+  isArrayBufferView,
+  isUint8Array,
+} = require('internal/util/types');
+
+const net = require('net');
+const { getOptionValue } = require('internal/options');
+const { Buffer } = require('buffer');
+const { canonicalizeIP } = internalBinding('cares_wrap');
+const _tls_common = require('_tls_common');
+const _tls_wrap = require('_tls_wrap');
+const { validateString } = require('internal/validators');
+
+const {
+  namespace: {
+    addDeserializeCallback,
+    addSerializeCallback,
+    isBuildingSnapshot,
+  },
+} = require('internal/v8/startup_snapshot');
+
+// Allow {CLIENT_RENEG_LIMIT} client-initiated session renegotiations
+// every {CLIENT_RENEG_WINDOW} seconds. An error event is emitted if more
+// renegotiations are seen. The settings are applied to all remote client
+// connections.
+exports.CLIENT_RENEG_LIMIT = 3;
+exports.CLIENT_RENEG_WINDOW = 600;
+
+exports.DEFAULT_CIPHERS = getOptionValue('--tls-cipher-list');
+
+exports.DEFAULT_ECDH_CURVE = 'auto';
+
+if (getOptionValue('--tls-min-v1.0'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1';
+else if (getOptionValue('--tls-min-v1.1'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.1';
+else if (getOptionValue('--tls-min-v1.2'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.2';
+else if (getOptionValue('--tls-min-v1.3'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.3';
+else
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.2';
+
+if (getOptionValue('--tls-max-v1.3'))
+  exports.DEFAULT_MAX_VERSION = 'TLSv1.3';
+else if (getOptionValue('--tls-max-v1.2'))
+  exports.DEFAULT_MAX_VERSION = 'TLSv1.2';
+else
+  exports.DEFAULT_MAX_VERSION = 'TLSv1.3'; // Will depend on node version.
+
+
+exports.getCiphers = internalUtil.cachedResult(
+  () => internalUtil.filterDuplicateStrings(getSSLCiphers(), true),
+);
+
+let bundledRootCertificates;
+function cacheBundledRootCertificates() {
+  bundledRootCertificates ||= ObjectFreeze(getBundledRootCertificates());
+
+  return bundledRootCertificates;
+}
+
+ObjectDefineProperty(exports, 'rootCertificates', {
+  __proto__: null,
+  configurable: false,
+  enumerable: true,
+  get: cacheBundledRootCertificates,
+});
+
+let extraCACertificates;
+function cacheExtraCACertificates() {
+  extraCACertificates ||= ObjectFreeze(getExtraCACertificates());
+
+  return extraCACertificates;
+}
+
+let systemCACertificates;
+function cacheSystemCACertificates() {
+  systemCACertificates ||= ObjectFreeze(getSystemCACertificates());
+
+  return systemCACertificates;
+}
+
+let defaultCACertificates;
+let hasResetDefaultCACertificates = false;
+
+function cacheDefaultCACertificates() {
+  if (defaultCACertificates) { return defaultCACertificates; }
+
+  if (hasResetDefaultCACertificates) {
+    defaultCACertificates = getUserRootCertificates();
+    ObjectFreeze(defaultCACertificates);
+    return defaultCACertificates;
+  }
+
+  defaultCACertificates = [];
+
+  if (!getOptionValue('--use-openssl-ca')) {
+    const bundled = cacheBundledRootCertificates();
+    for (let i = 0; i < bundled.length; ++i) {
+      ArrayPrototypePush(defaultCACertificates, bundled[i]);
+    }
+    if (getOptionValue('--use-system-ca')) {
+      const system = cacheSystemCACertificates();
+      for (let i = 0; i < system.length; ++i) {
+
+        ArrayPrototypePush(defaultCACertificates, system[i]);
+      }
+    }
+  }
+
+  if (process.env.NODE_EXTRA_CA_CERTS) {
+    const extra = cacheExtraCACertificates();
+    for (let i = 0; i < extra.length; ++i) {
+
+      ArrayPrototypePush(defaultCACertificates, extra[i]);
+    }
+  }
+
+  ObjectFreeze(defaultCACertificates);
+  return defaultCACertificates;
+}
+
+// TODO(joyeecheung): support X509Certificate output?
+function getCACertificates(type = 'default') {
+  validateString(type, 'type');
+
+  switch (type) {
+    case 'default':
+      return cacheDefaultCACertificates();
+    case 'bundled':
+      return cacheBundledRootCertificates();
+    case 'system':
+      return cacheSystemCACertificates();
+    case 'extra':
+      return cacheExtraCACertificates();
+    default:
+      throw new ERR_INVALID_ARG_VALUE('type', type);
+  }
+}
+exports.getCACertificates = getCACertificates;
+
+function setDefaultCACertificates(certs) {
+  if (!ArrayIsArray(certs)) {
+    throw new ERR_INVALID_ARG_TYPE('certs', 'Array', certs);
+  }
+
+  // Verify that all elements in the array are strings
+  for (let i = 0; i < certs.length; i++) {
+    if (typeof certs[i] !== 'string' && !isArrayBufferView(certs[i])) {
+      throw new ERR_INVALID_ARG_TYPE(
+        `certs[${i}]`, ['string', 'ArrayBufferView'], certs[i]);
+    }
+  }
+
+  resetRootCertStore(certs);
+  defaultCACertificates = undefined; // Reset the cached default certificates
+  hasResetDefaultCACertificates = true;
+}
+
+exports.setDefaultCACertificates = setDefaultCACertificates;
+
+if (isBuildingSnapshot()) {
+  addSerializeCallback(() => {
+    // Clear the cached certs so that they are reloaded at runtime.
+    // Bundled certificates are immutable so they are spared.
+    extraCACertificates = undefined;
+    systemCACertificates = undefined;
+    if (hasResetDefaultCACertificates) {
+      defaultCACertificates = undefined;
+    }
+  });
+  addDeserializeCallback(() => {
+    // If the tls module is loaded during snapshotting, load the certificates from
+    // various sources again at runtime so that by the time an actual TLS connection is
+    // made, the loading is done. If the default CA certificates have been overridden, then
+    // the serialized overriding certificates are likely to be used and pre-loading
+    // from the sources would probably not yield any benefit, so skip it.
+    if (!hasResetDefaultCACertificates) {
+      startLoadingCertificatesOffThread();
+    }
+  });
+}
+
+// Convert protocols array into valid OpenSSL protocols list
+// ("\x06spdy/2\x08http/1.1\x08http/1.0")
+function convertProtocols(protocols) {
+  const lens = new Array(protocols.length);
+  const buff = Buffer.allocUnsafe(protocols.reduce((p, c, i) => {
+    const len = Buffer.byteLength(c);
+    if (len > 255) {
+      throw new ERR_OUT_OF_RANGE('The byte length of the protocol at index ' +
+        `${i} exceeds the maximum length.`, '<= 255', len, true);
+    }
+    lens[i] = len;
+    return p + 1 + len;
+  }, 0));
+
+  let offset = 0;
+  for (let i = 0, c = protocols.length; i < c; i++) {
+    buff[offset++] = lens[i];
+    buff.write(protocols[i], offset);
+    offset += lens[i];
+  }
+
+  return buff;
+}
+
+exports.convertALPNProtocols = function convertALPNProtocols(protocols, out) {
+  // If protocols is Array - translate it into buffer
+  if (ArrayIsArray(protocols)) {
+    out.ALPNProtocols = convertProtocols(protocols);
+  } else if (isUint8Array(protocols)) {
+    // Copy new buffer not to be modified by user.
+    out.ALPNProtocols = Buffer.from(protocols);
+  } else if (isArrayBufferView(protocols)) {
+    out.ALPNProtocols = Buffer.from(protocols.buffer.slice(
+      protocols.byteOffset,
+      protocols.byteOffset + protocols.byteLength,
+    ));
+  }
+};
+
+function unfqdn(host) {
+  return host.replace(/[.]$/, '');
+}
+
+// String#toLowerCase() is locale-sensitive so we use
+// a conservative version that only lowercases A-Z.
+function toLowerCase(c) {
+  return StringFromCharCode(32 + c.charCodeAt(0));
+}
+
+function splitHost(host) {
+  return unfqdn(host).replace(/[A-Z]/g, toLowerCase).split('.');
+}
+
+function check(hostParts, pattern, wildcards) {
+  // Empty strings, null, undefined, etc. never match.
+  if (!pattern)
+    return false;
+
+  const patternParts = splitHost(pattern);
+
+  if (hostParts.length !== patternParts.length)
+    return false;
+
+  // Pattern has empty components, e.g. "bad..example.com".
+  if (patternParts.includes(''))
+    return false;
+
+  // RFC 6125 allows IDNA U-labels (Unicode) in names but we have no
+  // good way to detect their encoding or normalize them so we simply
+  // reject them.  Control characters and blanks are rejected as well
+  // because nothing good can come from accepting them.
+  const isBad = (s) => /[^\u0021-\u007F]/u.test(s);
+  if (patternParts.some(isBad))
+    return false;
+
+  // Check host parts from right to left first.
+  for (let i = hostParts.length - 1; i > 0; i -= 1) {
+    if (hostParts[i] !== patternParts[i])
+      return false;
+  }
+
+  const hostSubdomain = hostParts[0];
+  const patternSubdomain = patternParts[0];
+  const patternSubdomainParts = patternSubdomain.split('*', 3);
+
+  // Short-circuit when the subdomain does not contain a wildcard.
+  // RFC 6125 does not allow wildcard substitution for components
+  // containing IDNA A-labels (Punycode) so match those verbatim.
+  if (patternSubdomainParts.length === 1 ||
+      patternSubdomain.includes('xn--'))
+    return hostSubdomain === patternSubdomain;
+
+  if (!wildcards)
+    return false;
+
+  // More than one wildcard is always wrong.
+  if (patternSubdomainParts.length > 2)
+    return false;
+
+  // *.tld wildcards are not allowed.
+  if (patternParts.length <= 2)
+    return false;
+
+  const { 0: prefix, 1: suffix } = patternSubdomainParts;
+
+  if (prefix.length + suffix.length > hostSubdomain.length)
+    return false;
+
+  if (!hostSubdomain.startsWith(prefix))
+    return false;
+
+  if (!hostSubdomain.endsWith(suffix))
+    return false;
+
+  return true;
+}
+
+// This pattern is used to determine the length of escaped sequences within
+// the subject alt names string. It allows any valid JSON string literal.
+// This MUST match the JSON specification (ECMA-404 / RFC8259) exactly.
+const jsonStringPattern =
+  // eslint-disable-next-line no-control-regex
+  /^"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/;
+
+function splitEscapedAltNames(altNames) {
+  const result = [];
+  let currentToken = '';
+  let offset = 0;
+  while (offset !== altNames.length) {
+    const nextSep = altNames.indexOf(',', offset);
+    const nextQuote = altNames.indexOf('"', offset);
+    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {
+      // There is a quote character and there is no separator before the quote.
+      currentToken += altNames.substring(offset, nextQuote);
+      const match = jsonStringPattern.exec(altNames.substring(nextQuote));
+      if (!match) {
+        throw new ERR_TLS_CERT_ALTNAME_FORMAT();
+      }
+      currentToken += JSONParse(match[0]);
+      offset = nextQuote + match[0].length;
+    } else if (nextSep !== -1) {
+      // There is a separator and no quote before it.
+      currentToken += altNames.substring(offset, nextSep);
+      result.push(currentToken);
+      currentToken = '';
+      offset = nextSep + 2;
+    } else {
+      currentToken += altNames.substring(offset);
+      offset = altNames.length;
+    }
+  }
+  result.push(currentToken);
+  return result;
+}
+
+exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
+  const subject = cert.subject;
+  const altNames = cert.subjectaltname;
+  const dnsNames = [];
+  const ips = [];
+
+  hostname = '' + hostname;
+
+  if (altNames) {
+    const splitAltNames = altNames.includes('"') ?
+      splitEscapedAltNames(altNames) :
+      altNames.split(', ');
+    splitAltNames.forEach((name) => {
+      if (name.startsWith('DNS:')) {
+        dnsNames.push(name.slice(4));
+      } else if (name.startsWith('IP Address:')) {
+        ips.push(canonicalizeIP(name.slice(11)));
+      }
+    });
+  }
+
+  let valid = false;
+  let reason = 'Unknown reason';
+
+  hostname = unfqdn(hostname);  // Remove trailing dot for error messages.
+
+  if (net.isIP(hostname)) {
+    valid = ips.includes(canonicalizeIP(hostname));
+    if (!valid)
+      reason = `IP: ${hostname} is not in the cert's list: ` + ips.join(', ');
+  } else if (dnsNames.length > 0 || subject?.CN) {
+    const hostParts = splitHost(hostname);
+    const wildcard = (pattern) => check(hostParts, pattern, true);
+
+    if (dnsNames.length > 0) {
+      valid = dnsNames.some(wildcard);
+      if (!valid)
+        reason =
+          `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;
+    } else {
+      // Match against Common Name only if no supported identifiers exist.
+      const cn = subject.CN;
+
+      if (ArrayIsArray(cn))
+        valid = cn.some(wildcard);
+      else if (cn)
+        valid = wildcard(cn);
+
+      if (!valid)
+        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;
+    }
+  } else {
+    reason = 'Cert does not contain a DNS name';
+  }
+
+  if (!valid) {
+    return new ERR_TLS_CERT_ALTNAME_INVALID(reason, hostname, cert);
+  }
+};
+
+exports.createSecureContext = _tls_common.createSecureContext;
+exports.SecureContext = _tls_common.SecureContext;
+exports.TLSSocket = _tls_wrap.TLSSocket;
+exports.Server = _tls_wrap.Server;
+exports.createServer = _tls_wrap.createServer;
+exports.connect = _tls_wrap.connect;
\ No newline at end of file
diff --git a/.codesandbox/node/trace_events.js b/.codesandbox/node/trace_events.js
new file mode 100644
index 0000000000..0938072289
--- /dev/null
+++ b/.codesandbox/node/trace_events.js
@@ -0,0 +1,96 @@
+'use strict';
+
+const {
+  ArrayPrototypeJoin,
+  SafeSet,
+} = primordials;
+
+const { hasTracing } = internalBinding('config');
+
+const kMaxTracingCount = 10;
+
+const {
+  ERR_TRACE_EVENTS_CATEGORY_REQUIRED,
+  ERR_TRACE_EVENTS_UNAVAILABLE,
+} = require('internal/errors').codes;
+
+const { ownsProcessState } = require('internal/worker');
+if (!hasTracing || !ownsProcessState)
+  throw new ERR_TRACE_EVENTS_UNAVAILABLE();
+
+const { CategorySet, getEnabledCategories } = internalBinding('trace_events');
+const { customInspectSymbol } = require('internal/util');
+const { format } = require('internal/util/inspect');
+const {
+  validateObject,
+  validateStringArray,
+} = require('internal/validators');
+
+const enabledTracingObjects = new SafeSet();
+
+class Tracing {
+  #handle;
+  #categories;
+  #enabled = false;
+
+  constructor(categories) {
+    this.#handle = new CategorySet(categories);
+    this.#categories = categories;
+  }
+
+  enable() {
+    if (!this.#enabled) {
+      this.#enabled = true;
+      this.#handle.enable();
+      enabledTracingObjects.add(this);
+      if (enabledTracingObjects.size > kMaxTracingCount) {
+        process.emitWarning(
+          'Possible trace_events memory leak detected. There are more than ' +
+          `${kMaxTracingCount} enabled Tracing objects.`,
+        );
+      }
+    }
+  }
+
+  disable() {
+    if (this.#enabled) {
+      this.#enabled = false;
+      this.#handle.disable();
+      enabledTracingObjects.delete(this);
+    }
+  }
+
+  get enabled() {
+    return this.#enabled;
+  }
+
+  get categories() {
+    return ArrayPrototypeJoin(this.#categories, ',');
+  }
+
+  [customInspectSymbol](depth, opts) {
+    if (typeof depth === 'number' && depth < 0)
+      return this;
+
+    const obj = {
+      enabled: this.enabled,
+      categories: this.categories,
+    };
+    return `Tracing ${format(obj)}`;
+  }
+}
+
+function createTracing(options) {
+  validateObject(options, 'options');
+  validateStringArray(options.categories, 'options.categories');
+
+  if (options.categories.length <= 0)
+    throw new ERR_TRACE_EVENTS_CATEGORY_REQUIRED();
+
+  return new Tracing(options.categories);
+}
+
+module.exports = {
+  createTracing,
+  getEnabledCategories,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/tty.js b/.codesandbox/node/tty.js
new file mode 100644
index 0000000000..f9275fab29
--- /dev/null
+++ b/.codesandbox/node/tty.js
@@ -0,0 +1,147 @@
+'use strict';
+
+const {
+  NumberIsInteger,
+  ObjectSetPrototypeOf,
+} = primordials;
+
+const net = require('net');
+const { TTY, isTTY } = internalBinding('tty_wrap');
+const {
+  ErrnoException,
+  codes: {
+    ERR_INVALID_FD,
+    ERR_TTY_INIT_FAILED,
+  },
+} = require('internal/errors');
+const {
+  getColorDepth,
+  hasColors,
+} = require('internal/tty');
+
+// Lazy loaded for startup performance.
+let readline;
+
+function isatty(fd) {
+  return NumberIsInteger(fd) && fd >= 0 && fd <= 2147483647 &&
+         isTTY(fd);
+}
+
+function ReadStream(fd, options) {
+  if (!(this instanceof ReadStream))
+    return new ReadStream(fd, options);
+  if (fd >> 0 !== fd || fd < 0)
+    throw new ERR_INVALID_FD(fd);
+
+  const ctx = {};
+  const tty = new TTY(fd, ctx);
+  if (ctx.code !== undefined) {
+    throw new ERR_TTY_INIT_FAILED(ctx);
+  }
+
+  net.Socket.call(this, {
+    readableHighWaterMark: 0,
+    handle: tty,
+    manualStart: true,
+    ...options,
+  });
+
+  this.isRaw = false;
+  this.isTTY = true;
+}
+
+ObjectSetPrototypeOf(ReadStream.prototype, net.Socket.prototype);
+ObjectSetPrototypeOf(ReadStream, net.Socket);
+
+ReadStream.prototype.setRawMode = function(flag) {
+  flag = !!flag;
+  const err = this._handle?.setRawMode(flag);
+  if (err) {
+    this.emit('error', new ErrnoException(err, 'setRawMode'));
+    return this;
+  }
+  this.isRaw = flag;
+  return this;
+};
+
+function WriteStream(fd) {
+  if (!(this instanceof WriteStream))
+    return new WriteStream(fd);
+  if (fd >> 0 !== fd || fd < 0)
+    throw new ERR_INVALID_FD(fd);
+
+  const ctx = {};
+  const tty = new TTY(fd, ctx);
+  if (ctx.code !== undefined) {
+    throw new ERR_TTY_INIT_FAILED(ctx);
+  }
+
+  net.Socket.call(this, {
+    readableHighWaterMark: 0,
+    handle: tty,
+    manualStart: true,
+  });
+
+  // Prevents interleaved or dropped stdout/stderr output for terminals.
+  // As noted in the following reference, local TTYs tend to be quite fast and
+  // this behavior has become expected due historical functionality on OS X,
+  // even though it was originally intended to change in v1.0.2 (Libuv 1.2.1).
+  // Ref: https://github.com/nodejs/node/pull/1771#issuecomment-119351671
+  this._handle.setBlocking(true);
+
+  const winSize = [0, 0];
+  const err = this._handle.getWindowSize(winSize);
+  if (!err) {
+    this.columns = winSize[0];
+    this.rows = winSize[1];
+  }
+}
+
+ObjectSetPrototypeOf(WriteStream.prototype, net.Socket.prototype);
+ObjectSetPrototypeOf(WriteStream, net.Socket);
+
+WriteStream.prototype.isTTY = true;
+
+WriteStream.prototype.getColorDepth = getColorDepth;
+
+WriteStream.prototype.hasColors = hasColors;
+
+WriteStream.prototype._refreshSize = function() {
+  const oldCols = this.columns;
+  const oldRows = this.rows;
+  const winSize = [0, 0];
+  const err = this._handle.getWindowSize(winSize);
+  if (err) {
+    this.emit('error', new ErrnoException(err, 'getWindowSize'));
+    return;
+  }
+  const { 0: newCols, 1: newRows } = winSize;
+  if (oldCols !== newCols || oldRows !== newRows) {
+    this.columns = newCols;
+    this.rows = newRows;
+    this.emit('resize');
+  }
+};
+
+// Backwards-compat
+WriteStream.prototype.cursorTo = function(x, y, callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.cursorTo(this, x, y, callback);
+};
+WriteStream.prototype.moveCursor = function(dx, dy, callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.moveCursor(this, dx, dy, callback);
+};
+WriteStream.prototype.clearLine = function(dir, callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.clearLine(this, dir, callback);
+};
+WriteStream.prototype.clearScreenDown = function(callback) {
+  if (readline === undefined) readline = require('readline');
+  return readline.clearScreenDown(this, callback);
+};
+WriteStream.prototype.getWindowSize = function() {
+  return [this.columns, this.rows];
+};
+
+module.exports = { isatty, ReadStream, WriteStream };
\ No newline at end of file
diff --git a/.codesandbox/node/url.js b/.codesandbox/node/url.js
new file mode 100644
index 0000000000..7e0f36ee6a
--- /dev/null
+++ b/.codesandbox/node/url.js
@@ -0,0 +1,1028 @@
+'use strict';
+
+const {
+  ArrayPrototypeJoin,
+  Boolean,
+  Int8Array,
+  ObjectAssign,
+  ObjectKeys,
+  StringPrototypeAt,
+  StringPrototypeCharCodeAt,
+  StringPrototypeIndexOf,
+  StringPrototypeReplaceAll,
+  StringPrototypeSlice,
+  decodeURIComponent,
+} = primordials;
+
+const { URLPattern } = internalBinding('url_pattern');
+const { toASCII } = internalBinding('encoding_binding');
+const { encodeStr, hexTable } = require('internal/querystring');
+const querystring = require('querystring');
+
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_URL,
+} = require('internal/errors').codes;
+const {
+  validateString,
+  validateObject,
+} = require('internal/validators');
+
+// This ensures setURLConstructor() is called before the native
+// URL::ToObject() method is used.
+const { spliceOne } = require('internal/util');
+const { isInsideNodeModules } = internalBinding('util');
+
+// WHATWG URL implementation provided by internal/url
+const {
+  URL,
+  URLSearchParams,
+  domainToASCII,
+  domainToUnicode,
+  fileURLToPath,
+  fileURLToPathBuffer,
+  pathToFileURL: _pathToFileURL,
+  urlToHttpOptions,
+  unsafeProtocol,
+  hostlessProtocol,
+  slashedProtocol,
+} = require('internal/url');
+
+const bindingUrl = internalBinding('url');
+
+// Original url.parse() API
+
+function Url() {
+  this.protocol = null;
+  this.slashes = null;
+  this.auth = null;
+  this.host = null;
+  this.port = null;
+  this.hostname = null;
+  this.hash = null;
+  this.search = null;
+  this.query = null;
+  this.pathname = null;
+  this.path = null;
+  this.href = null;
+}
+
+// Reference: RFC 3986, RFC 1808, RFC 2396
+
+// define these here so at least they only have to be
+// compiled once on the first module load.
+const protocolPattern = /^[a-z0-9.+-]+:/i;
+const portPattern = /:[0-9]*$/;
+const hostPattern = /^\/\/[^@/]+@[^@/]+/;
+
+// Special case for a simple path URL
+const simplePathPattern = /^(\/\/?(?!\/)[^?\s]*)(\?[^\s]*)?$/;
+
+const hostnameMaxLen = 255;
+const {
+  CHAR_SPACE,
+  CHAR_TAB,
+  CHAR_CARRIAGE_RETURN,
+  CHAR_LINE_FEED,
+  CHAR_NO_BREAK_SPACE,
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE,
+  CHAR_HASH,
+  CHAR_FORWARD_SLASH,
+  CHAR_LEFT_SQUARE_BRACKET,
+  CHAR_RIGHT_SQUARE_BRACKET,
+  CHAR_LEFT_ANGLE_BRACKET,
+  CHAR_RIGHT_ANGLE_BRACKET,
+  CHAR_LEFT_CURLY_BRACKET,
+  CHAR_RIGHT_CURLY_BRACKET,
+  CHAR_QUESTION_MARK,
+  CHAR_DOUBLE_QUOTE,
+  CHAR_SINGLE_QUOTE,
+  CHAR_PERCENT,
+  CHAR_SEMICOLON,
+  CHAR_BACKWARD_SLASH,
+  CHAR_CIRCUMFLEX_ACCENT,
+  CHAR_GRAVE_ACCENT,
+  CHAR_VERTICAL_LINE,
+  CHAR_AT,
+  CHAR_COLON,
+} = require('internal/constants');
+
+let urlParseWarned = false;
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+  if (!urlParseWarned && !isInsideNodeModules(100, true)) {
+    urlParseWarned = true;
+    process.emitWarning(
+      '`url.parse()` behavior is not standardized and prone to ' +
+      'errors that have security implications. Use the WHATWG URL API ' +
+      'instead. CVEs are not issued for `url.parse()` vulnerabilities.',
+      'DeprecationWarning',
+      'DEP0169',
+    );
+  }
+
+  if (url instanceof Url) return url;
+
+  const urlObject = new Url();
+  urlObject.parse(url, parseQueryString, slashesDenoteHost);
+  return urlObject;
+}
+
+function isIpv6Hostname(hostname) {
+  return (
+    StringPrototypeCharCodeAt(hostname, 0) === CHAR_LEFT_SQUARE_BRACKET &&
+    StringPrototypeCharCodeAt(hostname, hostname.length - 1) ===
+    CHAR_RIGHT_SQUARE_BRACKET
+  );
+}
+
+// This prevents some common spoofing bugs due to our use of IDNA toASCII. For
+// compatibility, the set of characters we use here is the *intersection* of
+// "forbidden host code point" in the WHATWG URL Standard [1] and the
+// characters in the host parsing loop in Url.prototype.parse, with the
+// following additions:
+//
+// - ':' since this could cause a "protocol spoofing" bug
+// - '@' since this could cause parts of the hostname to be confused with auth
+// - '[' and ']' since this could cause a non-IPv6 hostname to be interpreted
+//   as IPv6 by isIpv6Hostname above
+//
+// [1]: https://url.spec.whatwg.org/#forbidden-host-code-point
+const forbiddenHostChars = /[\0\t\n\r #%/:<>?@[\\\]^|]/;
+// For IPv6, permit '[', ']', and ':'.
+const forbiddenHostCharsIpv6 = /[\0\t\n\r #%/<>?@\\^|]/;
+
+Url.prototype.parse = function parse(url, parseQueryString, slashesDenoteHost) {
+  validateString(url, 'url');
+
+  // Copy chrome, IE, opera backslash-handling behavior.
+  // Back slashes before the query string get converted to forward slashes
+  // See: https://code.google.com/p/chromium/issues/detail?id=25916
+  let hasHash = false;
+  let hasAt = false;
+  let start = -1;
+  let end = -1;
+  let rest = '';
+  let lastPos = 0;
+  for (let i = 0, inWs = false, split = false; i < url.length; ++i) {
+    const code = url.charCodeAt(i);
+
+    // Find first and last non-whitespace characters for trimming
+    const isWs = code < 33 ||
+                 code === CHAR_NO_BREAK_SPACE ||
+                 code === CHAR_ZERO_WIDTH_NOBREAK_SPACE;
+    if (start === -1) {
+      if (isWs)
+        continue;
+      lastPos = start = i;
+    } else if (inWs) {
+      if (!isWs) {
+        end = -1;
+        inWs = false;
+      }
+    } else if (isWs) {
+      end = i;
+      inWs = true;
+    }
+
+    // Only convert backslashes while we haven't seen a split character
+    if (!split) {
+      switch (code) {
+        case CHAR_AT:
+          hasAt = true;
+          break;
+        case CHAR_HASH:
+          hasHash = true;
+        // Fall through
+        case CHAR_QUESTION_MARK:
+          split = true;
+          break;
+        case CHAR_BACKWARD_SLASH:
+          if (i - lastPos > 0)
+            rest += url.slice(lastPos, i);
+          rest += '/';
+          lastPos = i + 1;
+          break;
+      }
+    } else if (!hasHash && code === CHAR_HASH) {
+      hasHash = true;
+    }
+  }
+
+  // Check if string was non-empty (including strings with only whitespace)
+  if (start !== -1) {
+    if (lastPos === start) {
+      // We didn't convert any backslashes
+
+      if (end === -1) {
+        if (start === 0)
+          rest = url;
+        else
+          rest = url.slice(start);
+      } else {
+        rest = url.slice(start, end);
+      }
+    } else if (end === -1 && lastPos < url.length) {
+      // We converted some backslashes and have only part of the entire string
+      rest += url.slice(lastPos);
+    } else if (end !== -1 && lastPos < end) {
+      // We converted some backslashes and have only part of the entire string
+      rest += url.slice(lastPos, end);
+    }
+  }
+
+  if (!slashesDenoteHost && !hasHash && !hasAt) {
+    // Try fast path regexp
+    const simplePath = simplePathPattern.exec(rest);
+    if (simplePath) {
+      this.path = rest;
+      this.href = rest;
+      this.pathname = simplePath[1];
+      if (simplePath[2]) {
+        this.search = simplePath[2];
+        if (parseQueryString) {
+          this.query = querystring.parse(this.search.slice(1));
+        } else {
+          this.query = this.search.slice(1);
+        }
+      } else if (parseQueryString) {
+        this.search = null;
+        this.query = { __proto__: null };
+      }
+      return this;
+    }
+  }
+
+  let proto = protocolPattern.exec(rest);
+  let lowerProto;
+  if (proto) {
+    proto = proto[0];
+    lowerProto = proto.toLowerCase();
+    this.protocol = lowerProto;
+    rest = rest.slice(proto.length);
+  }
+
+  // Figure out if it's got a host
+  // user@server is *always* interpreted as a hostname, and url
+  // resolution will treat //foo/bar as host=foo,path=bar because that's
+  // how the browser resolves relative URLs.
+  let slashes;
+  if (slashesDenoteHost || proto || hostPattern.test(rest)) {
+    slashes = rest.charCodeAt(0) === CHAR_FORWARD_SLASH &&
+              rest.charCodeAt(1) === CHAR_FORWARD_SLASH;
+    if (slashes && !(proto && hostlessProtocol.has(lowerProto))) {
+      rest = rest.slice(2);
+      this.slashes = true;
+    }
+  }
+
+  if (!hostlessProtocol.has(lowerProto) &&
+      (slashes || (proto && !slashedProtocol.has(proto)))) {
+
+    // there's a hostname.
+    // the first instance of /, ?, ;, or # ends the host.
+    //
+    // If there is an @ in the hostname, then non-host chars *are* allowed
+    // to the left of the last @ sign, unless some host-ending character
+    // comes *before* the @-sign.
+    // URLs are obnoxious.
+    //
+    // ex:
+    // http://a@b@c/ => user:a@b host:c
+    // http://a@b?@c => user:a host:b path:/?@c
+
+    let hostEnd = -1;
+    let atSign = -1;
+    let nonHost = -1;
+    for (let i = 0; i < rest.length; ++i) {
+      switch (rest.charCodeAt(i)) {
+        case CHAR_TAB:
+        case CHAR_LINE_FEED:
+        case CHAR_CARRIAGE_RETURN:
+          // WHATWG URL removes tabs, newlines, and carriage returns. Let's do that too.
+          rest = rest.slice(0, i) + rest.slice(i + 1);
+          i -= 1;
+          break;
+        case CHAR_SPACE:
+        case CHAR_DOUBLE_QUOTE:
+        case CHAR_PERCENT:
+        case CHAR_SINGLE_QUOTE:
+        case CHAR_SEMICOLON:
+        case CHAR_LEFT_ANGLE_BRACKET:
+        case CHAR_RIGHT_ANGLE_BRACKET:
+        case CHAR_BACKWARD_SLASH:
+        case CHAR_CIRCUMFLEX_ACCENT:
+        case CHAR_GRAVE_ACCENT:
+        case CHAR_LEFT_CURLY_BRACKET:
+        case CHAR_VERTICAL_LINE:
+        case CHAR_RIGHT_CURLY_BRACKET:
+          // Characters that are never ever allowed in a hostname from RFC 2396
+          if (nonHost === -1)
+            nonHost = i;
+          break;
+        case CHAR_HASH:
+        case CHAR_FORWARD_SLASH:
+        case CHAR_QUESTION_MARK:
+          // Find the first instance of any host-ending characters
+          if (nonHost === -1)
+            nonHost = i;
+          hostEnd = i;
+          break;
+        case CHAR_AT:
+          // At this point, either we have an explicit point where the
+          // auth portion cannot go past, or the last @ char is the decider.
+          atSign = i;
+          nonHost = -1;
+          break;
+      }
+      if (hostEnd !== -1)
+        break;
+    }
+    start = 0;
+    if (atSign !== -1) {
+      this.auth = decodeURIComponent(rest.slice(0, atSign));
+      start = atSign + 1;
+    }
+    if (nonHost === -1) {
+      this.host = rest.slice(start);
+      rest = '';
+    } else {
+      this.host = rest.slice(start, nonHost);
+      rest = rest.slice(nonHost);
+    }
+
+    // pull out port.
+    this.parseHost();
+
+    // We've indicated that there is a hostname,
+    // so even if it's empty, it has to be present.
+    if (typeof this.hostname !== 'string')
+      this.hostname = '';
+
+    const hostname = this.hostname;
+
+    // If hostname begins with [ and ends with ]
+    // assume that it's an IPv6 address.
+    const ipv6Hostname = isIpv6Hostname(hostname);
+
+    // validate a little.
+    if (!ipv6Hostname) {
+      rest = getHostname(this, rest, hostname, url);
+    }
+
+    if (this.hostname.length > hostnameMaxLen) {
+      this.hostname = '';
+    } else {
+      // Hostnames are always lower case.
+      this.hostname = this.hostname.toLowerCase();
+    }
+
+    if (this.hostname !== '') {
+      if (ipv6Hostname) {
+        if (forbiddenHostCharsIpv6.test(this.hostname)) {
+          throw new ERR_INVALID_URL(url);
+        }
+      } else {
+        // IDNA Support: Returns a punycoded representation of "domain".
+        // It only converts parts of the domain name that
+        // have non-ASCII characters, i.e. it doesn't matter if
+        // you call it with a domain that already is ASCII-only.
+        this.hostname = toASCII(this.hostname);
+
+        // Prevent two potential routes of hostname spoofing.
+        // 1. If this.hostname is empty, it must have become empty due to toASCII
+        //    since we checked this.hostname above.
+        // 2. If any of forbiddenHostChars appears in this.hostname, it must have
+        //    also gotten in due to toASCII. This is since getHostname would have
+        //    filtered them out otherwise.
+        // Rather than trying to correct this by moving the non-host part into
+        // the pathname as we've done in getHostname, throw an exception to
+        // convey the severity of this issue.
+        if (this.hostname === '' || forbiddenHostChars.test(this.hostname)) {
+          throw new ERR_INVALID_URL(url);
+        }
+      }
+    }
+
+    const p = this.port ? ':' + this.port : '';
+    const h = this.hostname || '';
+    this.host = h + p;
+
+    // strip [ and ] from the hostname
+    // the host field still retains them, though
+    if (ipv6Hostname) {
+      this.hostname = this.hostname.slice(1, -1);
+      if (rest[0] !== '/') {
+        rest = '/' + rest;
+      }
+    }
+  }
+
+  // Now rest is set to the post-host stuff.
+  // Chop off any delim chars.
+  if (!unsafeProtocol.has(lowerProto)) {
+    // First, make 100% sure that any "autoEscape" chars get
+    // escaped, even if encodeURIComponent doesn't think they
+    // need to be.
+    rest = autoEscapeStr(rest);
+  }
+
+  let questionIdx = -1;
+  let hashIdx = -1;
+  for (let i = 0; i < rest.length; ++i) {
+    const code = rest.charCodeAt(i);
+    if (code === CHAR_HASH) {
+      this.hash = rest.slice(i);
+      hashIdx = i;
+      break;
+    } else if (code === CHAR_QUESTION_MARK && questionIdx === -1) {
+      questionIdx = i;
+    }
+  }
+
+  if (questionIdx !== -1) {
+    if (hashIdx === -1) {
+      this.search = rest.slice(questionIdx);
+      this.query = rest.slice(questionIdx + 1);
+    } else {
+      this.search = rest.slice(questionIdx, hashIdx);
+      this.query = rest.slice(questionIdx + 1, hashIdx);
+    }
+    if (parseQueryString) {
+      this.query = querystring.parse(this.query);
+    }
+  } else if (parseQueryString) {
+    // No query string, but parseQueryString still requested
+    this.search = null;
+    this.query = { __proto__: null };
+  }
+
+  const useQuestionIdx =
+    questionIdx !== -1 && (hashIdx === -1 || questionIdx < hashIdx);
+  const firstIdx = useQuestionIdx ? questionIdx : hashIdx;
+  if (firstIdx === -1) {
+    if (rest.length > 0)
+      this.pathname = rest;
+  } else if (firstIdx > 0) {
+    this.pathname = rest.slice(0, firstIdx);
+  }
+  if (slashedProtocol.has(lowerProto) &&
+      this.hostname && !this.pathname) {
+    this.pathname = '/';
+  }
+
+  // To support http.request
+  if (this.pathname || this.search) {
+    const p = this.pathname || '';
+    const s = this.search || '';
+    this.path = p + s;
+  }
+
+  // Finally, reconstruct the href based on what has been validated.
+  this.href = this.format();
+  return this;
+};
+
+let warnInvalidPort = true;
+function getHostname(self, rest, hostname, url) {
+  for (let i = 0; i < hostname.length; ++i) {
+    const code = hostname.charCodeAt(i);
+    const isValid = (code !== CHAR_FORWARD_SLASH &&
+                     code !== CHAR_BACKWARD_SLASH &&
+                     code !== CHAR_HASH &&
+                     code !== CHAR_QUESTION_MARK &&
+                     code !== CHAR_COLON);
+
+    if (!isValid) {
+      // If leftover starts with :, then it represents an invalid port.
+      // But url.parse() is lenient about it for now.
+      // Issue a warning and continue.
+      if (warnInvalidPort && code === CHAR_COLON) {
+        const detail = `The URL ${url} is invalid. Future versions of Node.js will throw an error.`;
+        process.emitWarning(detail, 'DeprecationWarning', 'DEP0170');
+        warnInvalidPort = false;
+      }
+      self.hostname = hostname.slice(0, i);
+      return `/${hostname.slice(i)}${rest}`;
+    }
+  }
+  return rest;
+}
+
+// Escaped characters. Use empty strings to fill up unused entries.
+// Using Array is faster than Object/Map
+const escapedCodes = [
+  /* 0 - 9 */ '', '', '', '', '', '', '', '', '', '%09',
+  /* 10 - 19 */ '%0A', '', '', '%0D', '', '', '', '', '', '',
+  /* 20 - 29 */ '', '', '', '', '', '', '', '', '', '',
+  /* 30 - 39 */ '', '', '%20', '', '%22', '', '', '', '', '%27',
+  /* 40 - 49 */ '', '', '', '', '', '', '', '', '', '',
+  /* 50 - 59 */ '', '', '', '', '', '', '', '', '', '',
+  /* 60 - 69 */ '%3C', '', '%3E', '', '', '', '', '', '', '',
+  /* 70 - 79 */ '', '', '', '', '', '', '', '', '', '',
+  /* 80 - 89 */ '', '', '', '', '', '', '', '', '', '',
+  /* 90 - 99 */ '', '', '%5C', '', '%5E', '', '%60', '', '', '',
+  /* 100 - 109 */ '', '', '', '', '', '', '', '', '', '',
+  /* 110 - 119 */ '', '', '', '', '', '', '', '', '', '',
+  /* 120 - 125 */ '', '', '', '%7B', '%7C', '%7D',
+];
+
+// Automatically escape all delimiters and unwise characters from RFC 2396.
+// Also escape single quotes in case of an XSS attack.
+// Return the escaped string.
+function autoEscapeStr(rest) {
+  let escaped = '';
+  let lastEscapedPos = 0;
+  for (let i = 0; i < rest.length; ++i) {
+    // `escaped` contains substring up to the last escaped character.
+    const escapedChar = escapedCodes[rest.charCodeAt(i)];
+    if (escapedChar) {
+      // Concat if there are ordinary characters in the middle.
+      if (i > lastEscapedPos)
+        escaped += rest.slice(lastEscapedPos, i);
+      escaped += escapedChar;
+      lastEscapedPos = i + 1;
+    }
+  }
+  if (lastEscapedPos === 0)  // Nothing has been escaped.
+    return rest;
+
+  // There are ordinary characters at the end.
+  if (lastEscapedPos < rest.length)
+    escaped += rest.slice(lastEscapedPos);
+
+  return escaped;
+}
+
+// Format a parsed object into a url string
+function urlFormat(urlObject, options) {
+  // Ensure it's an object, and not a string url.
+  // If it's an object, this is a no-op.
+  // this way, you can call urlParse() on strings
+  // to clean up potentially wonky urls.
+  if (typeof urlObject === 'string') {
+    urlObject = urlParse(urlObject);
+  } else if (typeof urlObject !== 'object' || urlObject === null) {
+    throw new ERR_INVALID_ARG_TYPE('urlObject',
+                                   ['Object', 'string'], urlObject);
+  } else if (urlObject instanceof URL) {
+    let fragment = true;
+    let unicode = false;
+    let search = true;
+    let auth = true;
+
+    if (options) {
+      validateObject(options, 'options');
+
+      if (options.fragment != null) {
+        fragment = Boolean(options.fragment);
+      }
+
+      if (options.unicode != null) {
+        unicode = Boolean(options.unicode);
+      }
+
+      if (options.search != null) {
+        search = Boolean(options.search);
+      }
+
+      if (options.auth != null) {
+        auth = Boolean(options.auth);
+      }
+    }
+
+    return bindingUrl.format(urlObject.href, fragment, unicode, search, auth);
+  }
+
+  return Url.prototype.format.call(urlObject);
+}
+
+// These characters do not need escaping:
+// ! - . _ ~
+// ' ( ) * :
+// digits
+// alpha (uppercase)
+// alpha (lowercase)
+const noEscapeAuth = new Int8Array([
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00 - 0x0F
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x10 - 0x1F
+  0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 0x20 - 0x2F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, // 0x30 - 0x3F
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 0x4F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 0x50 - 0x5F
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, // 0x70 - 0x7F
+]);
+
+Url.prototype.format = function format() {
+  let auth = this.auth || '';
+  if (auth) {
+    auth = encodeStr(auth, noEscapeAuth, hexTable);
+    auth += '@';
+  }
+
+  let protocol = this.protocol || '';
+  if (protocol && StringPrototypeCharCodeAt(protocol, protocol.length - 1) !== 58 /* : */) {
+    protocol += ':';
+  }
+
+  let pathname = this.pathname || '';
+  let hash = this.hash || '';
+  let host = '';
+  let query = '';
+
+  if (this.host) {
+    host = auth + this.host;
+  } else if (this.hostname) {
+    host = auth + (
+      StringPrototypeIndexOf(this.hostname, ':') !== -1 && !isIpv6Hostname(this.hostname) ?
+        '[' + this.hostname + ']' :
+        this.hostname
+    );
+    if (this.port) {
+      host += ':' + this.port;
+    }
+  }
+
+  if (this.query !== null && typeof this.query === 'object') {
+    query = querystring.stringify(this.query);
+  }
+  let search = this.search || (query && ('?' + query)) || '';
+
+  if (StringPrototypeIndexOf(pathname, '#') !== -1 || StringPrototypeIndexOf(pathname, '?') !== -1) {
+    let newPathname = '';
+    let lastPos = 0;
+    const len = pathname.length;
+    for (let i = 0; i < len; i++) {
+      const code = StringPrototypeCharCodeAt(pathname, i);
+      if (code === CHAR_HASH || code === CHAR_QUESTION_MARK) {
+        if (i > lastPos) {
+          newPathname += StringPrototypeSlice(pathname, lastPos, i);
+        }
+        newPathname += (code === CHAR_HASH ? '%23' : '%3F');
+        lastPos = i + 1;
+      }
+    }
+    if (lastPos < len) {
+      newPathname += StringPrototypeSlice(pathname, lastPos);
+    }
+    pathname = newPathname;
+  }
+
+  // Only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
+  // unless they had them to begin with.
+  if (this.slashes || slashedProtocol.has(protocol)) {
+    if (this.slashes || host) {
+      if (pathname && StringPrototypeCharCodeAt(pathname, 0) !== CHAR_FORWARD_SLASH)
+        pathname = '/' + pathname;
+      host = '//' + host;
+    } else if (protocol.length >= 4 &&
+               StringPrototypeCharCodeAt(protocol, 0) === 102/* f */ &&
+               StringPrototypeCharCodeAt(protocol, 1) === 105/* i */ &&
+               StringPrototypeCharCodeAt(protocol, 2) === 108/* l */ &&
+               StringPrototypeCharCodeAt(protocol, 3) === 101/* e */) {
+      host = '//';
+    }
+  }
+
+  // Escape '#' in search.
+  if (StringPrototypeIndexOf(search, '#') !== -1) {
+    search = StringPrototypeReplaceAll(search, '#', '%23');
+  }
+
+  if (hash && StringPrototypeCharCodeAt(hash, 0) !== CHAR_HASH) {
+    hash = '#' + hash;
+  }
+  if (search && StringPrototypeCharCodeAt(search, 0) !== CHAR_QUESTION_MARK) {
+    search = '?' + search;
+  }
+
+  return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+  return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function resolve(relative) {
+  return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+  if (!source) return relative;
+  return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function resolveObject(relative) {
+  if (typeof relative === 'string') {
+    const rel = new Url();
+    rel.parse(relative, false, true);
+    relative = rel;
+  }
+
+  const result = new Url();
+  ObjectAssign(result, this);
+
+  // Hash is always overridden, no matter what.
+  // even href="" will remove it.
+  result.hash = relative.hash;
+
+  // If the relative url is empty, then there's nothing left to do here.
+  if (relative.href === '') {
+    result.href = result.format();
+    return result;
+  }
+
+  // Hrefs like //foo/bar always cut to the protocol.
+  if (relative.slashes && !relative.protocol) {
+    // Take everything except the protocol from relative
+    const relativeWithoutProtocol = ObjectKeys(relative).reduce((acc, key) => {
+      if (key !== 'protocol') {
+        acc[key] = relative[key];
+      }
+      return acc;
+    }, {});
+    ObjectAssign(result, relativeWithoutProtocol);
+
+    // urlParse appends trailing / to urls like http://www.example.com
+    if (slashedProtocol.has(result.protocol) &&
+        result.hostname && !result.pathname) {
+      result.path = result.pathname = '/';
+    }
+
+    result.href = result.format();
+    return result;
+  }
+
+  if (relative.protocol && relative.protocol !== result.protocol) {
+    // If it's a known url protocol, then changing
+    // the protocol does weird things
+    // first, if it's not file:, then we MUST have a host,
+    // and if there was a path
+    // to begin with, then we MUST have a path.
+    // if it is file:, then the host is dropped,
+    // because that's known to be hostless.
+    // anything else is assumed to be absolute.
+    if (!slashedProtocol.has(relative.protocol)) {
+      ObjectAssign(result, relative);
+      result.href = result.format();
+      return result;
+    }
+
+    result.protocol = relative.protocol;
+    if (!relative.host &&
+        !/^file:?$/.test(relative.protocol) &&
+        !hostlessProtocol.has(relative.protocol)) {
+      const relPath = (relative.pathname || '').split('/');
+      while (relPath.length && !(relative.host = relPath.shift()));
+      relative.host ||= '';
+      relative.hostname ||= '';
+      if (relPath[0] !== '') relPath.unshift('');
+      if (relPath.length < 2) relPath.unshift('');
+      result.pathname = relPath.join('/');
+    } else {
+      result.pathname = relative.pathname;
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    result.host = relative.host || '';
+    result.auth = relative.auth;
+    result.hostname = relative.hostname || relative.host;
+    result.port = relative.port;
+    // To support http.request
+    if (result.pathname || result.search) {
+      const p = result.pathname || '';
+      const s = result.search || '';
+      result.path = p + s;
+    }
+    result.slashes ||= relative.slashes;
+    result.href = result.format();
+    return result;
+  }
+
+  const isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/');
+  const isRelAbs = (
+    relative.host || (relative.pathname && relative.pathname.charAt(0) === '/')
+  );
+  let mustEndAbs = (isRelAbs || isSourceAbs ||
+                    (result.host && relative.pathname));
+  const removeAllDots = mustEndAbs;
+  let srcPath = (result.pathname && result.pathname.split('/')) || [];
+  const relPath = (relative.pathname && relative.pathname.split('/')) || [];
+  const noLeadingSlashes = result.protocol &&
+      !slashedProtocol.has(result.protocol);
+
+  // If the url is a non-slashed url, then relative
+  // links like ../.. should be able
+  // to crawl up to the hostname, as well.  This is strange.
+  // result.protocol has already been set by now.
+  // Later on, put the first path part into the host field.
+  if (noLeadingSlashes) {
+    result.hostname = '';
+    result.port = null;
+    if (result.host) {
+      if (srcPath[0] === '') srcPath[0] = result.host;
+      else srcPath.unshift(result.host);
+    }
+    result.host = '';
+    if (relative.protocol) {
+      relative.hostname = null;
+      relative.port = null;
+      result.auth = null;
+      if (relative.host) {
+        if (relPath[0] === '') relPath[0] = relative.host;
+        else relPath.unshift(relative.host);
+      }
+      relative.host = null;
+    }
+    mustEndAbs &&= (relPath[0] === '' || srcPath[0] === '');
+  }
+
+  if (isRelAbs) {
+    // it's absolute.
+    if (relative.host || relative.host === '') {
+      if (result.host !== relative.host) result.auth = null;
+      result.host = relative.host;
+      result.port = relative.port;
+    }
+    if (relative.hostname || relative.hostname === '') {
+      if (result.hostname !== relative.hostname) result.auth = null;
+      result.hostname = relative.hostname;
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    srcPath = relPath;
+    // Fall through to the dot-handling below.
+  } else if (relPath.length) {
+    // it's relative
+    // throw away the existing file, and take the new path instead.
+    srcPath ||= [];
+    srcPath.pop();
+    srcPath = srcPath.concat(relPath);
+    result.search = relative.search;
+    result.query = relative.query;
+  } else if (relative.search !== null && relative.search !== undefined) {
+    // Just pull out the search.
+    // like href='?foo'.
+    // Put this after the other two cases because it simplifies the booleans
+    if (noLeadingSlashes) {
+      result.hostname = result.host = srcPath.shift();
+      // Occasionally the auth can get stuck only in host.
+      // This especially happens in cases like
+      // url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+      const authInHost =
+        result.host && result.host.indexOf('@') > 0 && result.host.split('@');
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.host = result.hostname = authInHost.shift();
+      }
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    // To support http.request
+    if (result.pathname !== null || result.search !== null) {
+      result.path = (result.pathname ? result.pathname : '') +
+                    (result.search ? result.search : '');
+    }
+    result.href = result.format();
+    return result;
+  }
+
+  if (!srcPath.length) {
+    // No path at all. All other things were already handled above.
+    result.pathname = null;
+    // To support http.request
+    if (result.search) {
+      result.path = '/' + result.search;
+    } else {
+      result.path = null;
+    }
+    result.href = result.format();
+    return result;
+  }
+
+  // If a url ENDs in . or .., then it must get a trailing slash.
+  // however, if it ends in anything else non-slashy,
+  // then it must NOT get a trailing slash.
+  let last = srcPath[srcPath.length - 1];
+  const hasTrailingSlash = (
+    ((result.host || relative.host || srcPath.length > 1) &&
+    (last === '.' || last === '..')) || last === '');
+
+  // Strip single dots, resolve double dots to parent dir
+  // if the path tries to go above the root, `up` ends up > 0
+  let up = 0;
+  for (let i = srcPath.length - 1; i >= 0; i--) {
+    last = srcPath[i];
+    if (last === '.') {
+      spliceOne(srcPath, i);
+    } else if (last === '..') {
+      spliceOne(srcPath, i);
+      up++;
+    } else if (up) {
+      spliceOne(srcPath, i);
+      up--;
+    }
+  }
+
+  // If the path is allowed to go above the root, restore leading ..s
+  if (!mustEndAbs && !removeAllDots) {
+    while (up--) {
+      srcPath.unshift('..');
+    }
+  }
+
+  if (mustEndAbs && srcPath[0] !== '' &&
+      (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+    srcPath.unshift('');
+  }
+
+  if (hasTrailingSlash && StringPrototypeAt(ArrayPrototypeJoin(srcPath, '/'), -1) !== '/') {
+    srcPath.push('');
+  }
+
+  const isAbsolute = srcPath[0] === '' ||
+      (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+  // put the host back
+  if (noLeadingSlashes) {
+    result.hostname =
+      result.host = isAbsolute ? '' : srcPath.length ? srcPath.shift() : '';
+    // Occasionally the auth can get stuck only in host.
+    // This especially happens in cases like
+    // url.resolveObject('mailto:local1@domain1', 'local2@domain2')
+    const authInHost = result.host && result.host.indexOf('@') > 0 ?
+      result.host.split('@') : false;
+    if (authInHost) {
+      result.auth = authInHost.shift();
+      result.host = result.hostname = authInHost.shift();
+    }
+  }
+
+  mustEndAbs ||= (result.host && srcPath.length);
+
+  if (mustEndAbs && !isAbsolute) {
+    srcPath.unshift('');
+  }
+
+  if (!srcPath.length) {
+    result.pathname = null;
+    result.path = null;
+  } else {
+    result.pathname = srcPath.join('/');
+  }
+
+  // To support request.http
+  if (result.pathname !== null || result.search !== null) {
+    result.path = (result.pathname ? result.pathname : '') +
+                  (result.search ? result.search : '');
+  }
+  result.auth = relative.auth || result.auth;
+  result.slashes ||= relative.slashes;
+  result.href = result.format();
+  return result;
+};
+
+Url.prototype.parseHost = function parseHost() {
+  let host = this.host;
+  let port = portPattern.exec(host);
+  if (port) {
+    port = port[0];
+    if (port !== ':') {
+      this.port = port.slice(1);
+    }
+    host = host.slice(0, host.length - port.length);
+  }
+  if (host) this.hostname = host;
+};
+
+// When used internally, we are not obligated to associate TypeError with
+// this function, so non-strings can be rejected by underlying implementation.
+// Public API has to validate input and throw appropriate error.
+function pathToFileURL(path, options) {
+  validateString(path, 'path');
+
+  return _pathToFileURL(path, options);
+}
+
+module.exports = {
+  // Original API
+  Url,
+  parse: urlParse,
+  resolve: urlResolve,
+  resolveObject: urlResolveObject,
+  format: urlFormat,
+
+  // WHATWG API
+  URL,
+  URLPattern,
+  URLSearchParams,
+  domainToASCII,
+  domainToUnicode,
+
+  // Utilities
+  pathToFileURL,
+  fileURLToPath,
+  fileURLToPathBuffer,
+  urlToHttpOptions,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/util.js b/.codesandbox/node/util.js
new file mode 100644
index 0000000000..d458b0a23f
--- /dev/null
+++ b/.codesandbox/node/util.js
@@ -0,0 +1,521 @@
+'use strict';
+
+const {
+  ArrayIsArray,
+  ArrayPrototypePop,
+  ArrayPrototypePush,
+  ArrayPrototypeReduce,
+  Error,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  NumberIsSafeInteger,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectGetOwnPropertyDescriptors,
+  ObjectKeys,
+  ObjectSetPrototypeOf,
+  ObjectValues,
+  ReflectApply,
+  RegExp,
+  RegExpPrototypeSymbolReplace,
+  StringPrototypeToWellFormed,
+} = primordials;
+
+const {
+  ErrnoException,
+  ExceptionWithHostPort,
+  codes: {
+    ERR_FALSY_VALUE_REJECTION,
+    ERR_INVALID_ARG_TYPE,
+    ERR_OUT_OF_RANGE,
+  },
+  isErrorStackTraceLimitWritable,
+} = require('internal/errors');
+const {
+  format,
+  formatWithOptions,
+  inspect,
+  stripVTControlCharacters,
+} = require('internal/util/inspect');
+const { debuglog } = require('internal/util/debuglog');
+const {
+  validateBoolean,
+  validateFunction,
+  validateNumber,
+  validateString,
+  validateOneOf,
+  validateObject,
+} = require('internal/validators');
+const {
+  isReadableStream,
+  isWritableStream,
+  isNodeStream,
+} = require('internal/streams/utils');
+const types = require('internal/util/types');
+
+let utilColors;
+function lazyUtilColors() {
+  utilColors ??= require('internal/util/colors');
+  return utilColors;
+}
+const { getOptionValue } = require('internal/options');
+
+const binding = internalBinding('util');
+
+const {
+  deprecate,
+  getLazy,
+  getSystemErrorMap,
+  getSystemErrorName: internalErrorName,
+  getSystemErrorMessage: internalErrorMessage,
+  promisify,
+  defineLazyProperties,
+} = require('internal/util');
+
+let abortController;
+
+function lazyAbortController() {
+  abortController ??= require('internal/abort_controller');
+  return abortController;
+}
+
+let internalDeepEqual;
+
+/**
+ * @param {string} [code]
+ * @returns {string}
+ */
+function escapeStyleCode(code) {
+  if (code === undefined) return '';
+  return `\u001b[${code}m`;
+}
+
+/**
+ * @param {string | string[]} format
+ * @param {string} text
+ * @param {object} [options]
+ * @param {boolean} [options.validateStream] - Whether to validate the stream.
+ * @param {Stream} [options.stream] - The stream used for validation.
+ * @returns {string}
+ */
+function styleText(format, text, { validateStream = true, stream = process.stdout } = {}) {
+  validateString(text, 'text');
+  validateBoolean(validateStream, 'options.validateStream');
+
+  let skipColorize;
+  if (validateStream) {
+    if (
+      !isReadableStream(stream) &&
+      !isWritableStream(stream) &&
+      !isNodeStream(stream)
+    ) {
+      throw new ERR_INVALID_ARG_TYPE('stream', ['ReadableStream', 'WritableStream', 'Stream'], stream);
+    }
+
+    // If the stream is falsy or should not be colorized, set skipColorize to true
+    skipColorize = !lazyUtilColors().shouldColorize(stream);
+  }
+
+  // If the format is not an array, convert it to an array
+  const formatArray = ArrayIsArray(format) ? format : [format];
+
+  const codes = [];
+  for (const key of formatArray) {
+    if (key === 'none') continue;
+    const formatCodes = inspect.colors[key];
+    // If the format is not a valid style, throw an error
+    if (formatCodes == null) {
+      validateOneOf(key, 'format', ObjectKeys(inspect.colors));
+    }
+    if (skipColorize) continue;
+    ArrayPrototypePush(codes, formatCodes);
+  }
+
+  if (skipColorize) {
+    return text;
+  }
+
+  // Build opening codes
+  let openCodes = '';
+  for (let i = 0; i < codes.length; i++) {
+    openCodes += escapeStyleCode(codes[i][0]);
+  }
+
+  // Process the text to handle nested styles
+  let processedText;
+  if (codes.length > 0) {
+    processedText = ArrayPrototypeReduce(
+      codes,
+      (text, code) => RegExpPrototypeSymbolReplace(
+        // Find the reset code
+        new RegExp(`\\u001b\\[${code[1]}m`, 'g'),
+        text,
+        (match, offset) => {
+          // Check if there's more content after this reset
+          if (offset + match.length < text.length) {
+            if (
+              code[0] === inspect.colors.dim[0] ||
+              code[0] === inspect.colors.bold[0]
+            ) {
+              // Dim and bold are not mutually exclusive, so we need to reapply
+              return `${match}${escapeStyleCode(code[0])}`;
+            }
+            return escapeStyleCode(code[0]);
+          }
+          return match;
+        },
+      ),
+      text,
+    );
+  } else {
+    processedText = text;
+  }
+
+  // Build closing codes in reverse order
+  let closeCodes = '';
+  for (let i = codes.length - 1; i >= 0; i--) {
+    closeCodes += escapeStyleCode(codes[i][1]);
+  }
+
+  return `${openCodes}${processedText}${closeCodes}`;
+}
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ * @param {Function} ctor Constructor function which needs to inherit the
+ *   prototype.
+ * @param {Function} superCtor Constructor function to inherit prototype from.
+ * @throws {TypeError} Will error if either constructor is null, or if
+ * the super constructor lacks a prototype.
+ */
+function inherits(ctor, superCtor) {
+
+  if (ctor === undefined || ctor === null)
+    throw new ERR_INVALID_ARG_TYPE('ctor', 'Function', ctor);
+
+  if (superCtor === undefined || superCtor === null)
+    throw new ERR_INVALID_ARG_TYPE('superCtor', 'Function', superCtor);
+
+  if (superCtor.prototype === undefined) {
+    throw new ERR_INVALID_ARG_TYPE('superCtor.prototype',
+                                   'Object', superCtor.prototype);
+  }
+  ObjectDefineProperty(ctor, 'super_', {
+    __proto__: null,
+    value: superCtor,
+    writable: true,
+    configurable: true,
+  });
+  ObjectSetPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+
+/**
+ * @deprecated since v6.0.0
+ * @template T
+ * @template S
+ * @param {T} target
+ * @param {S} source
+ * @returns {(T & S) | null}
+ */
+function _extend(target, source) {
+  // Don't do anything if source isn't an object
+  if (source === null || typeof source !== 'object') return target;
+
+  const keys = ObjectKeys(source);
+  let i = keys.length;
+  while (i--) {
+    target[keys[i]] = source[keys[i]];
+  }
+  return target;
+}
+
+const callbackifyOnRejected = (reason, cb) => {
+  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
+  // Because `null` is a special error value in callbacks which means "no error
+  // occurred", we error-wrap so the callback consumer can distinguish between
+  // "the promise rejected with null" or "the promise fulfilled with undefined".
+  if (!reason) {
+    reason = new ERR_FALSY_VALUE_REJECTION.HideStackFramesError(reason);
+    ErrorCaptureStackTrace(reason, callbackifyOnRejected);
+  }
+  return cb(reason);
+};
+
+/**
+ * Converts a Promise-returning function to callback style
+ * @param {Function} original
+ * @returns {Function}
+ */
+function callbackify(original) {
+  validateFunction(original, 'original');
+
+  // We DO NOT return the promise as it gives the user a false sense that
+  // the promise is actually somehow related to the callback's execution
+  // and that the callback throwing will reject the promise.
+  function callbackified(...args) {
+    const maybeCb = ArrayPrototypePop(args);
+    validateFunction(maybeCb, 'last argument');
+    const cb = FunctionPrototypeBind(maybeCb, this);
+    // In true node style we process the callback on `nextTick` with all the
+    // implications (stack, `uncaughtException`, `async_hooks`)
+    ReflectApply(original, this, args)
+      .then((ret) => process.nextTick(cb, null, ret),
+            (rej) => process.nextTick(callbackifyOnRejected, rej, cb));
+  }
+
+  const descriptors = ObjectGetOwnPropertyDescriptors(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';
+  }
+  const propertiesValues = ObjectValues(descriptors);
+  for (let i = 0; i < propertiesValues.length; i++) {
+  // We want to use null-prototype objects to not rely on globally mutable
+  // %Object.prototype%.
+    ObjectSetPrototypeOf(propertiesValues[i], null);
+  }
+  ObjectDefineProperties(callbackified, descriptors);
+  return callbackified;
+}
+
+/**
+ * @param {number} err
+ * @returns {string}
+ */
+function getSystemErrorMessage(err) {
+  validateNumber(err, 'err');
+  if (err >= 0 || !NumberIsSafeInteger(err)) {
+    throw new ERR_OUT_OF_RANGE('err', 'a negative integer', err);
+  }
+  return internalErrorMessage(err);
+}
+
+/**
+ * @param {number} err
+ * @returns {string}
+ */
+function getSystemErrorName(err) {
+  validateNumber(err, 'err');
+  if (err >= 0 || !NumberIsSafeInteger(err)) {
+    throw new ERR_OUT_OF_RANGE('err', 'a negative integer', err);
+  }
+  return internalErrorName(err);
+}
+
+function _errnoException(...args) {
+  if (isErrorStackTraceLimitWritable()) {
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const e = new ErrnoException(...args);
+    Error.stackTraceLimit = limit;
+    ErrorCaptureStackTrace(e, _exceptionWithHostPort);
+    return e;
+  }
+  return new ErrnoException(...args);
+}
+
+function _exceptionWithHostPort(...args) {
+  if (isErrorStackTraceLimitWritable()) {
+    const limit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 0;
+    const e = new ExceptionWithHostPort(...args);
+    Error.stackTraceLimit = limit;
+    ErrorCaptureStackTrace(e, _exceptionWithHostPort);
+    return e;
+  }
+  return new ExceptionWithHostPort(...args);
+}
+
+/**
+ * Parses the content of a `.env` file.
+ * @param {string} content
+ * @returns {Record<string, string>}
+ */
+function parseEnv(content) {
+  validateString(content, 'content');
+  return binding.parseEnv(content);
+}
+
+const lazySourceMap = getLazy(() => require('internal/source_map/source_map_cache'));
+
+/**
+ * @typedef {object} CallSite // The call site
+ * @property {string} scriptName // The name of the resource that contains the
+ *   script for the function for this StackFrame
+ * @property {string} functionName // The name of the function associated with this stack frame
+ * @property {number} lineNumber // The number, 1-based, of the line for the associate function call
+ * @property {number} columnNumber // The 1-based column offset on the line for the associated function call
+ */
+
+/**
+ * @param {CallSite} callSite // The call site object to reconstruct from source map
+ * @returns {CallSite | undefined} // The reconstructed call site object
+ */
+function reconstructCallSite(callSite) {
+  const { scriptName, lineNumber, columnNumber } = callSite;
+  const sourceMap = lazySourceMap().findSourceMap(scriptName);
+  if (!sourceMap) return;
+  const entry = sourceMap.findEntry(lineNumber - 1, columnNumber - 1);
+  if (!entry?.originalSource) return;
+  return {
+    __proto__: null,
+    // If the name is not found, it is an empty string to match the behavior of `util.getCallSite()`
+    functionName: entry.name ?? '',
+    scriptName: entry.originalSource,
+    lineNumber: entry.originalLine + 1,
+    column: entry.originalColumn + 1,
+    columnNumber: entry.originalColumn + 1,
+  };
+}
+
+/**
+ *
+ * The call site array to map
+ * @param {CallSite[]} callSites
+ *   Array of objects with the reconstructed call site
+ * @returns {CallSite[]}
+ */
+function mapCallSite(callSites) {
+  const result = [];
+  for (let i = 0; i < callSites.length; ++i) {
+    const callSite = callSites[i];
+    const found = reconstructCallSite(callSite);
+    ArrayPrototypePush(result, found ?? callSite);
+  }
+  return result;
+}
+
+/**
+ * @typedef {object} CallSiteOptions // The call site options
+ * @property {boolean} sourceMap // Enable source map support
+ */
+
+/**
+ * Returns the callSite
+ * @param {number} frameCount
+ * @param {CallSiteOptions} options
+ * @returns {CallSite[]}
+ */
+function getCallSites(frameCount = 10, options) {
+  // If options is not provided check if frameCount is an object
+  if (options === undefined) {
+    if (typeof frameCount === 'object') {
+      // If frameCount is an object, it is the options object
+      options = frameCount;
+      validateObject(options, 'options');
+      if (options.sourceMap !== undefined) {
+        validateBoolean(options.sourceMap, 'options.sourceMap');
+      }
+      frameCount = 10;
+    } else {
+      // If options is not provided, set it to an empty object
+      options = {};
+    };
+  } else {
+    // If options is provided, validate it
+    validateObject(options, 'options');
+    if (options.sourceMap !== undefined) {
+      validateBoolean(options.sourceMap, 'options.sourceMap');
+    }
+  }
+
+  // Using kDefaultMaxCallStackSizeToCapture as reference
+  validateNumber(frameCount, 'frameCount', 1, 200);
+  // If options.sourceMaps is true or if sourceMaps are enabled but the option.sourceMaps is not set explictly to false
+  if (options.sourceMap === true || (getOptionValue('--enable-source-maps') && options.sourceMap !== false)) {
+    return mapCallSite(binding.getCallSites(frameCount));
+  }
+  return binding.getCallSites(frameCount);
+};
+
+// Keep the `exports =` so that various functions can still be monkeypatched
+module.exports = {
+  _errnoException,
+  _exceptionWithHostPort,
+  _extend: deprecate(_extend,
+                     'The `util._extend` API is deprecated. Please use Object.assign() instead.',
+                     'DEP0060'),
+  callbackify,
+  debug: debuglog,
+  debuglog,
+  deprecate,
+  format,
+  styleText,
+  formatWithOptions,
+  // Deprecated getCallSite.
+  // This API can be removed in next semver-minor release.
+  getCallSite: deprecate(getCallSites,
+                         'The `util.getCallSite` API has been renamed to `util.getCallSites()`.',
+                         'ExperimentalWarning'),
+  getCallSites,
+  getSystemErrorMap,
+  getSystemErrorName,
+  getSystemErrorMessage,
+  inherits,
+  inspect,
+  isArray: deprecate(ArrayIsArray,
+                     'The `util.isArray` API is deprecated. Please use `Array.isArray()` instead.',
+                     'DEP0044'),
+  isDeepStrictEqual(a, b, skipPrototype) {
+    if (internalDeepEqual === undefined) {
+      internalDeepEqual = require('internal/util/comparisons').isDeepStrictEqual;
+    }
+    return internalDeepEqual(a, b, skipPrototype);
+  },
+  promisify,
+  stripVTControlCharacters,
+  toUSVString(input) {
+    return StringPrototypeToWellFormed(`${input}`);
+  },
+  get transferableAbortSignal() {
+    return lazyAbortController().transferableAbortSignal;
+  },
+  get transferableAbortController() {
+    return lazyAbortController().transferableAbortController;
+  },
+  get aborted() {
+    return lazyAbortController().aborted;
+  },
+  types,
+  parseEnv,
+};
+
+defineLazyProperties(
+  module.exports,
+  'internal/util/parse_args/parse_args',
+  ['parseArgs'],
+);
+
+defineLazyProperties(
+  module.exports,
+  'internal/encoding',
+  ['TextDecoder', 'TextEncoder'],
+);
+
+defineLazyProperties(
+  module.exports,
+  'internal/mime',
+  ['MIMEType', 'MIMEParams'],
+);
+
+defineLazyProperties(
+  module.exports,
+  'internal/util/diff',
+  ['diff'],
+);
+
+defineLazyProperties(
+  module.exports,
+  'internal/util/trace_sigint',
+  ['setTraceSigInt'],
+);
\ No newline at end of file
diff --git a/.codesandbox/node/v8.js b/.codesandbox/node/v8.js
new file mode 100644
index 0000000000..a28391e83b
--- /dev/null
+++ b/.codesandbox/node/v8.js
@@ -0,0 +1,467 @@
+'use strict';
+
+const {
+  Array,
+  BigInt64Array,
+  BigUint64Array,
+  DataView,
+  Error,
+  Float32Array,
+  Float64Array,
+  Int16Array,
+  Int32Array,
+  Int8Array,
+  JSONParse,
+  ObjectPrototypeToString,
+  Uint16Array,
+  Uint32Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  globalThis: {
+    Float16Array,
+  },
+} = primordials;
+
+const { Buffer } = require('buffer');
+const {
+  validateString,
+  validateUint32,
+  validateOneOf,
+} = require('internal/validators');
+const {
+  Serializer,
+  Deserializer,
+} = internalBinding('serdes');
+const {
+  namespace: startupSnapshot,
+} = require('internal/v8/startup_snapshot');
+
+let profiler = {};
+if (internalBinding('config').hasInspector) {
+  profiler = internalBinding('profiler');
+}
+
+const assert = require('internal/assert');
+const { inspect } = require('internal/util/inspect');
+const { FastBuffer } = require('internal/buffer');
+const { getValidatedPath } = require('internal/fs/utils');
+const {
+  createHeapSnapshotStream,
+  triggerHeapSnapshot,
+} = internalBinding('heap_utils');
+const {
+  HeapSnapshotStream,
+  getHeapSnapshotOptions,
+  queryObjects,
+} = require('internal/heap_utils');
+const promiseHooks = require('internal/promise_hooks');
+const { getOptionValue } = require('internal/options');
+
+/**
+ * Generates a snapshot of the current V8 heap
+ * and writes it to a JSON file.
+ * @param {string} [filename]
+ * @param {{
+ *   exposeInternals?: boolean,
+ *   exposeNumericValues?: boolean
+ * }} [options]
+ * @returns {string}
+ */
+function writeHeapSnapshot(filename, options) {
+  if (filename !== undefined) {
+    filename = getValidatedPath(filename);
+  }
+  const optionArray = getHeapSnapshotOptions(options);
+  return triggerHeapSnapshot(filename, optionArray);
+}
+
+/**
+ * Generates a snapshot of the current V8 heap
+ * and returns a Readable Stream.
+ * @param {{
+ *   exposeInternals?: boolean,
+ *   exposeNumericValues?: boolean
+ * }} [options]
+ * @returns {import('./stream.js').Readable}
+ */
+function getHeapSnapshot(options) {
+  const optionArray = getHeapSnapshotOptions(options);
+  const handle = createHeapSnapshotStream(optionArray);
+  assert(handle);
+  return new HeapSnapshotStream(handle);
+}
+
+// We need to get the buffer from the binding at the callsite since
+// it's re-initialized after deserialization.
+const binding = internalBinding('v8');
+
+const {
+  cachedDataVersionTag,
+  setFlagsFromString: _setFlagsFromString,
+  isStringOneByteRepresentation: _isStringOneByteRepresentation,
+  updateHeapStatisticsBuffer,
+  updateHeapSpaceStatisticsBuffer,
+  updateHeapCodeStatisticsBuffer,
+  setHeapSnapshotNearHeapLimit: _setHeapSnapshotNearHeapLimit,
+
+  // Properties for heap statistics buffer extraction.
+  kTotalHeapSizeIndex,
+  kTotalHeapSizeExecutableIndex,
+  kTotalPhysicalSizeIndex,
+  kTotalAvailableSize,
+  kUsedHeapSizeIndex,
+  kHeapSizeLimitIndex,
+  kDoesZapGarbageIndex,
+  kMallocedMemoryIndex,
+  kPeakMallocedMemoryIndex,
+  kNumberOfNativeContextsIndex,
+  kNumberOfDetachedContextsIndex,
+  kTotalGlobalHandlesSizeIndex,
+  kUsedGlobalHandlesSizeIndex,
+  kExternalMemoryIndex,
+
+  // Properties for heap spaces statistics buffer extraction.
+  kHeapSpaces,
+  kSpaceSizeIndex,
+  kSpaceUsedSizeIndex,
+  kSpaceAvailableSizeIndex,
+  kPhysicalSpaceSizeIndex,
+
+  // Properties for heap code statistics buffer extraction.
+  kCodeAndMetadataSizeIndex,
+  kBytecodeAndMetadataSizeIndex,
+  kExternalScriptSourceSizeIndex,
+  kCPUProfilerMetaDataSizeIndex,
+
+  heapStatisticsBuffer,
+  heapCodeStatisticsBuffer,
+  heapSpaceStatisticsBuffer,
+  getCppHeapStatistics: _getCppHeapStatistics,
+  detailLevel,
+} = binding;
+
+const kNumberOfHeapSpaces = kHeapSpaces.length;
+
+/**
+ * Sets V8 command-line flags.
+ * @param {string} flags
+ * @returns {void}
+ */
+function setFlagsFromString(flags) {
+  validateString(flags, 'flags');
+  _setFlagsFromString(flags);
+}
+
+/**
+ * Return whether this string uses one byte as underlying representation or not.
+ * @param {string} content
+ * @returns {boolean}
+ */
+function isStringOneByteRepresentation(content) {
+  validateString(content, 'content');
+  return _isStringOneByteRepresentation(content);
+}
+
+
+/**
+ * Gets the current V8 heap statistics.
+ * @returns {{
+ *   total_heap_size: number;
+ *   total_heap_size_executable: number;
+ *   total_physical_size: number;
+ *   total_available_size: number;
+ *   used_heap_size: number;
+ *   heap_size_limit: number;
+ *   malloced_memory: number;
+ *   peak_malloced_memory: number;
+ *   does_zap_garbage: number;
+ *   number_of_native_contexts: number;
+ *   number_of_detached_contexts: number;
+ *   }}
+ */
+function getHeapStatistics() {
+  const buffer = heapStatisticsBuffer;
+
+  updateHeapStatisticsBuffer();
+
+  return {
+    total_heap_size: buffer[kTotalHeapSizeIndex],
+    total_heap_size_executable: buffer[kTotalHeapSizeExecutableIndex],
+    total_physical_size: buffer[kTotalPhysicalSizeIndex],
+    total_available_size: buffer[kTotalAvailableSize],
+    used_heap_size: buffer[kUsedHeapSizeIndex],
+    heap_size_limit: buffer[kHeapSizeLimitIndex],
+    malloced_memory: buffer[kMallocedMemoryIndex],
+    peak_malloced_memory: buffer[kPeakMallocedMemoryIndex],
+    does_zap_garbage: buffer[kDoesZapGarbageIndex],
+    number_of_native_contexts: buffer[kNumberOfNativeContextsIndex],
+    number_of_detached_contexts: buffer[kNumberOfDetachedContextsIndex],
+    total_global_handles_size: buffer[kTotalGlobalHandlesSizeIndex],
+    used_global_handles_size: buffer[kUsedGlobalHandlesSizeIndex],
+    external_memory: buffer[kExternalMemoryIndex],
+  };
+}
+
+/**
+ * Gets the current V8 heap space statistics.
+ * @returns {{
+ *   space_name: string;
+ *   space_size: number;
+ *   space_used_size: number;
+ *   space_available_size: number;
+ *   physical_space_size: number;
+ *   }[]}
+ */
+function getHeapSpaceStatistics() {
+  const heapSpaceStatistics = new Array(kNumberOfHeapSpaces);
+  const buffer = heapSpaceStatisticsBuffer;
+
+  for (let i = 0; i < kNumberOfHeapSpaces; i++) {
+    updateHeapSpaceStatisticsBuffer(i);
+    heapSpaceStatistics[i] = {
+      space_name: kHeapSpaces[i],
+      space_size: buffer[kSpaceSizeIndex],
+      space_used_size: buffer[kSpaceUsedSizeIndex],
+      space_available_size: buffer[kSpaceAvailableSizeIndex],
+      physical_space_size: buffer[kPhysicalSpaceSizeIndex],
+    };
+  }
+
+  return heapSpaceStatistics;
+}
+
+/**
+ * Gets the current V8 heap code statistics.
+ * @returns {{
+ *   code_and_metadata_size: number;
+ *   bytecode_and_metadata_size: number;
+ *   external_script_source_size: number;
+ *   cpu_profiler_metadata_size: number;
+ *   }}
+ */
+function getHeapCodeStatistics() {
+  const buffer = heapCodeStatisticsBuffer;
+
+  updateHeapCodeStatisticsBuffer();
+  return {
+    code_and_metadata_size: buffer[kCodeAndMetadataSizeIndex],
+    bytecode_and_metadata_size: buffer[kBytecodeAndMetadataSizeIndex],
+    external_script_source_size: buffer[kExternalScriptSourceSizeIndex],
+    cpu_profiler_metadata_size: buffer[kCPUProfilerMetaDataSizeIndex],
+  };
+}
+
+let heapSnapshotNearHeapLimitCallbackAdded = false;
+function setHeapSnapshotNearHeapLimit(limit) {
+  validateUint32(limit, 'limit', true);
+  if (heapSnapshotNearHeapLimitCallbackAdded ||
+      getOptionValue('--heapsnapshot-near-heap-limit') > 0
+  ) {
+    return;
+  }
+  heapSnapshotNearHeapLimitCallbackAdded = true;
+  _setHeapSnapshotNearHeapLimit(limit);
+}
+
+const detailLevelDict = {
+  __proto__: null,
+  detailed: detailLevel.DETAILED,
+  brief: detailLevel.BRIEF,
+};
+
+function getCppHeapStatistics(type = 'detailed') {
+  validateOneOf(type, 'type', ['brief', 'detailed']);
+  const result = _getCppHeapStatistics(detailLevelDict[type]);
+  result.detail_level = type;
+  return result;
+}
+
+/* V8 serialization API */
+
+/* JS methods for the base objects */
+Serializer.prototype._getDataCloneError = Error;
+
+/**
+ * Reads raw bytes from the deserializer's internal buffer.
+ * @param {number} length
+ * @returns {Buffer}
+ */
+Deserializer.prototype.readRawBytes = function readRawBytes(length) {
+  const offset = this._readRawBytes(length);
+  // `this.buffer` can be a Buffer or a plain Uint8Array, so just calling
+  // `.slice()` doesn't work.
+  return new FastBuffer(this.buffer.buffer,
+                        this.buffer.byteOffset + offset,
+                        length);
+};
+
+function arrayBufferViewTypeToIndex(abView) {
+  const type = ObjectPrototypeToString(abView);
+  if (type === '[object Int8Array]') return 0;
+  if (type === '[object Uint8Array]') return 1;
+  if (type === '[object Uint8ClampedArray]') return 2;
+  if (type === '[object Int16Array]') return 3;
+  if (type === '[object Uint16Array]') return 4;
+  if (type === '[object Int32Array]') return 5;
+  if (type === '[object Uint32Array]') return 6;
+  if (type === '[object Float32Array]') return 7;
+  if (type === '[object Float64Array]') return 8;
+  if (type === '[object DataView]') return 9;
+  // Index 10 is FastBuffer.
+  if (type === '[object BigInt64Array]') return 11;
+  if (type === '[object BigUint64Array]') return 12;
+  if (type === '[object Float16Array]') return 13;
+  return -1;
+}
+
+function arrayBufferViewIndexToType(index) {
+  if (index === 0) return Int8Array;
+  if (index === 1) return Uint8Array;
+  if (index === 2) return Uint8ClampedArray;
+  if (index === 3) return Int16Array;
+  if (index === 4) return Uint16Array;
+  if (index === 5) return Int32Array;
+  if (index === 6) return Uint32Array;
+  if (index === 7) return Float32Array;
+  if (index === 8) return Float64Array;
+  if (index === 9) return DataView;
+  if (index === 10) return FastBuffer;
+  if (index === 11) return BigInt64Array;
+  if (index === 12) return BigUint64Array;
+  if (index === 13) return Float16Array;
+  return undefined;
+}
+
+class DefaultSerializer extends Serializer {
+  constructor() {
+    super();
+
+    this._setTreatArrayBufferViewsAsHostObjects(true);
+  }
+
+  /**
+   * Used to write some kind of host object, i.e. an
+   * object that is created by native C++ bindings.
+   * @param {object} abView
+   * @returns {void}
+   */
+  _writeHostObject(abView) {
+    // Keep track of how to handle different ArrayBufferViews. The default
+    // Serializer for Node does not use the V8 methods for serializing those
+    // objects because Node's `Buffer` objects use pooled allocation in many
+    // cases, and their underlying `ArrayBuffer`s would show up in the
+    // serialization. Because a) those may contain sensitive data and the user
+    // may not be aware of that and b) they are often much larger than the
+    // `Buffer` itself, custom serialization is applied.
+    let i = 10;  // FastBuffer
+    if (abView.constructor !== Buffer) {
+      i = arrayBufferViewTypeToIndex(abView);
+      if (i === -1) {
+        throw new this._getDataCloneError(
+          `Unserializable host object: ${inspect(abView)}`);
+      }
+    }
+    this.writeUint32(i);
+    this.writeUint32(abView.byteLength);
+    this.writeRawBytes(new Uint8Array(abView.buffer,
+                                      abView.byteOffset,
+                                      abView.byteLength));
+  }
+}
+
+class DefaultDeserializer extends Deserializer {
+  /**
+   * Used to read some kind of host object, i.e. an
+   * object that is created by native C++ bindings.
+   * @returns {any}
+   */
+  _readHostObject() {
+    const typeIndex = this.readUint32();
+    const ctor = arrayBufferViewIndexToType(typeIndex);
+    const byteLength = this.readUint32();
+    const byteOffset = this._readRawBytes(byteLength);
+    const BYTES_PER_ELEMENT = ctor.BYTES_PER_ELEMENT || 1;
+
+    const offset = this.buffer.byteOffset + byteOffset;
+    if (offset % BYTES_PER_ELEMENT === 0) {
+      return new ctor(this.buffer.buffer,
+                      offset,
+                      byteLength / BYTES_PER_ELEMENT);
+    }
+    // Copy to an aligned buffer first.
+    const buffer_copy = Buffer.allocUnsafe(byteLength);
+    buffer_copy.set(new Uint8Array(this.buffer.buffer, this.buffer.byteOffset + byteOffset, byteLength));
+    return new ctor(buffer_copy.buffer,
+                    buffer_copy.byteOffset,
+                    byteLength / BYTES_PER_ELEMENT);
+  }
+}
+
+/**
+ * Uses a `DefaultSerializer` to serialize `value`
+ * into a buffer.
+ * @param {any} value
+ * @returns {Buffer}
+ */
+function serialize(value) {
+  const ser = new DefaultSerializer();
+  ser.writeHeader();
+  ser.writeValue(value);
+  return ser.releaseBuffer();
+}
+
+/**
+ * Uses a `DefaultDeserializer` with default options
+ * to read a JavaScript value from a buffer.
+ * @param {Buffer | TypedArray | DataView} buffer
+ * @returns {any}
+ */
+function deserialize(buffer) {
+  const der = new DefaultDeserializer(buffer);
+  der.readHeader();
+  return der.readValue();
+}
+
+class GCProfiler {
+  #profiler = null;
+
+  start() {
+    if (!this.#profiler) {
+      this.#profiler = new binding.GCProfiler();
+      this.#profiler.start();
+    }
+  }
+
+  stop() {
+    if (this.#profiler) {
+      const data = this.#profiler.stop();
+      this.#profiler = null;
+      return JSONParse(data);
+    }
+  }
+}
+
+module.exports = {
+  cachedDataVersionTag,
+  getHeapSnapshot,
+  getHeapStatistics,
+  getHeapSpaceStatistics,
+  getHeapCodeStatistics,
+  getCppHeapStatistics,
+  setFlagsFromString,
+  Serializer,
+  Deserializer,
+  DefaultSerializer,
+  DefaultDeserializer,
+  deserialize,
+  takeCoverage: profiler.takeCoverage,
+  stopCoverage: profiler.stopCoverage,
+  serialize,
+  writeHeapSnapshot,
+  promiseHooks,
+  queryObjects,
+  startupSnapshot,
+  setHeapSnapshotNearHeapLimit,
+  GCProfiler,
+  isStringOneByteRepresentation,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/vm.js b/.codesandbox/node/vm.js
new file mode 100644
index 0000000000..feb9c0a55f
--- /dev/null
+++ b/.codesandbox/node/vm.js
@@ -0,0 +1,398 @@
+'use strict';
+
+const {
+  ArrayPrototypeForEach,
+  ObjectFreeze,
+  PromiseReject,
+  ReflectApply,
+  Symbol,
+} = primordials;
+
+const {
+  ContextifyScript,
+  makeContext,
+  constants,
+  measureMemory: _measureMemory,
+} = internalBinding('contextify');
+const {
+  ERR_CONTEXT_NOT_INITIALIZED,
+  ERR_INVALID_ARG_TYPE,
+} = require('internal/errors').codes;
+const {
+  validateArray,
+  validateBoolean,
+  validateBuffer,
+  validateInt32,
+  validateOneOf,
+  validateObject,
+  validateString,
+  validateStringArray,
+  validateUint32,
+  kValidateObjectAllowArray,
+  kValidateObjectAllowNullable,
+} = require('internal/validators');
+const {
+  emitExperimentalWarning,
+  kEmptyObject,
+  kVmBreakFirstLineSymbol,
+} = require('internal/util');
+const {
+  getHostDefinedOptionId,
+  internalCompileFunction,
+  isContext: _isContext,
+  registerImportModuleDynamically,
+} = require('internal/vm');
+const {
+  vm_dynamic_import_main_context_default,
+  vm_context_no_contextify,
+} = internalBinding('symbols');
+const kParsingContext = Symbol('script parsing context');
+
+/**
+ * Check if object is a context object created by vm.createContext().
+ * @throws {TypeError} If object is not an object in the first place, throws TypeError.
+ * @param {object} object Object to check.
+ * @returns {boolean}
+ */
+function isContext(object) {
+  validateObject(object, 'object', kValidateObjectAllowArray);
+
+  return _isContext(object);
+}
+
+class Script extends ContextifyScript {
+  constructor(code, options = kEmptyObject) {
+    code = `${code}`;
+    if (typeof options === 'string') {
+      options = { filename: options };
+    } else {
+      validateObject(options, 'options');
+    }
+
+    const {
+      filename = 'evalmachine.<anonymous>',
+      lineOffset = 0,
+      columnOffset = 0,
+      cachedData,
+      produceCachedData = false,
+      importModuleDynamically,
+      [kParsingContext]: parsingContext,
+    } = options;
+
+    validateString(filename, 'options.filename');
+    validateInt32(lineOffset, 'options.lineOffset');
+    validateInt32(columnOffset, 'options.columnOffset');
+    if (cachedData !== undefined) {
+      validateBuffer(cachedData, 'options.cachedData');
+    }
+    validateBoolean(produceCachedData, 'options.produceCachedData');
+
+    const hostDefinedOptionId =
+        getHostDefinedOptionId(importModuleDynamically, filename);
+    // Calling `ReThrow()` on a native TryCatch does not generate a new
+    // abort-on-uncaught-exception check. A dummy try/catch in JS land
+    // protects against that.
+    try { // eslint-disable-line no-useless-catch
+      super(code,
+            filename,
+            lineOffset,
+            columnOffset,
+            cachedData,
+            produceCachedData,
+            parsingContext,
+            hostDefinedOptionId);
+    } catch (e) {
+      throw e; /* node-do-not-add-exception-line */
+    }
+
+    registerImportModuleDynamically(this, importModuleDynamically);
+  }
+
+  runInThisContext(options) {
+    const { breakOnSigint, args } = getRunInContextArgs(null, options);
+    if (breakOnSigint && process.listenerCount('SIGINT') > 0) {
+      return sigintHandlersWrap(super.runInContext, this, args);
+    }
+    return ReflectApply(super.runInContext, this, args);
+  }
+
+  runInContext(contextifiedObject, options) {
+    validateContext(contextifiedObject);
+    const { breakOnSigint, args } = getRunInContextArgs(
+      contextifiedObject,
+      options,
+    );
+    if (breakOnSigint && process.listenerCount('SIGINT') > 0) {
+      return sigintHandlersWrap(super.runInContext, this, args);
+    }
+    return ReflectApply(super.runInContext, this, args);
+  }
+
+  runInNewContext(contextObject, options) {
+    const context = createContext(contextObject, getContextOptions(options));
+    return this.runInContext(context, options);
+  }
+}
+
+function validateContext(contextifiedObject) {
+  if (!isContext(contextifiedObject)) {
+    throw new ERR_INVALID_ARG_TYPE('contextifiedObject', 'vm.Context',
+                                   contextifiedObject);
+  }
+}
+
+function getRunInContextArgs(contextifiedObject, options = kEmptyObject) {
+  validateObject(options, 'options');
+
+  let timeout = options.timeout;
+  if (timeout === undefined) {
+    timeout = -1;
+  } else {
+    validateUint32(timeout, 'options.timeout', true);
+  }
+
+  const {
+    displayErrors = true,
+    breakOnSigint = false,
+    [kVmBreakFirstLineSymbol]: breakFirstLine = false,
+  } = options;
+
+  validateBoolean(displayErrors, 'options.displayErrors');
+  validateBoolean(breakOnSigint, 'options.breakOnSigint');
+
+  return {
+    breakOnSigint,
+    args: [
+      contextifiedObject,
+      timeout,
+      displayErrors,
+      breakOnSigint,
+      breakFirstLine,
+    ],
+  };
+}
+
+function getContextOptions(options) {
+  if (!options)
+    return {};
+  const contextOptions = {
+    name: options.contextName,
+    origin: options.contextOrigin,
+    codeGeneration: undefined,
+    microtaskMode: options.microtaskMode,
+  };
+  if (contextOptions.name !== undefined)
+    validateString(contextOptions.name, 'options.contextName');
+  if (contextOptions.origin !== undefined)
+    validateString(contextOptions.origin, 'options.contextOrigin');
+  if (options.contextCodeGeneration !== undefined) {
+    validateObject(options.contextCodeGeneration,
+                   'options.contextCodeGeneration');
+    const { strings, wasm } = options.contextCodeGeneration;
+    if (strings !== undefined)
+      validateBoolean(strings, 'options.contextCodeGeneration.strings');
+    if (wasm !== undefined)
+      validateBoolean(wasm, 'options.contextCodeGeneration.wasm');
+    contextOptions.codeGeneration = { strings, wasm };
+  }
+  if (options.microtaskMode !== undefined)
+    validateString(options.microtaskMode, 'options.microtaskMode');
+  return contextOptions;
+}
+
+let defaultContextNameIndex = 1;
+function createContext(contextObject = {}, options = kEmptyObject) {
+  if (contextObject !== vm_context_no_contextify && isContext(contextObject)) {
+    return contextObject;
+  }
+
+  validateObject(options, 'options');
+
+  const {
+    name = `VM Context ${defaultContextNameIndex++}`,
+    origin,
+    codeGeneration,
+    microtaskMode,
+    importModuleDynamically,
+  } = options;
+
+  validateString(name, 'options.name');
+  if (origin !== undefined)
+    validateString(origin, 'options.origin');
+  if (codeGeneration !== undefined)
+    validateObject(codeGeneration, 'options.codeGeneration');
+
+  let strings = true;
+  let wasm = true;
+  if (codeGeneration !== undefined) {
+    ({ strings = true, wasm = true } = codeGeneration);
+    validateBoolean(strings, 'options.codeGeneration.strings');
+    validateBoolean(wasm, 'options.codeGeneration.wasm');
+  }
+
+  validateOneOf(microtaskMode,
+                'options.microtaskMode',
+                ['afterEvaluate', undefined]);
+  const microtaskQueue = (microtaskMode === 'afterEvaluate');
+
+  const hostDefinedOptionId =
+    getHostDefinedOptionId(importModuleDynamically, name);
+
+  const result = makeContext(contextObject, name, origin, strings, wasm, microtaskQueue, hostDefinedOptionId);
+  // Register the context scope callback after the context was initialized.
+  registerImportModuleDynamically(result, importModuleDynamically);
+  return result;
+}
+
+function createScript(code, options) {
+  return new Script(code, options);
+}
+
+// Remove all SIGINT listeners and re-attach them after the wrapped function
+// has executed, so that caught SIGINT are handled by the listeners again.
+function sigintHandlersWrap(fn, thisArg, argsArray) {
+  const sigintListeners = process.rawListeners('SIGINT');
+
+  process.removeAllListeners('SIGINT');
+
+  try {
+    return ReflectApply(fn, thisArg, argsArray);
+  } finally {
+    // Add using the public methods so that the `newListener` handler of
+    // process can re-attach the listeners.
+    ArrayPrototypeForEach(sigintListeners, (listener) => {
+      process.addListener('SIGINT', listener);
+    });
+  }
+}
+
+function runInContext(code, contextifiedObject, options) {
+  validateContext(contextifiedObject);
+  if (typeof options === 'string') {
+    options = {
+      filename: options,
+      [kParsingContext]: contextifiedObject,
+    };
+  } else {
+    options = { ...options, [kParsingContext]: contextifiedObject };
+  }
+  return createScript(code, options)
+    .runInContext(contextifiedObject, options);
+}
+
+function runInNewContext(code, contextObject, options) {
+  if (typeof options === 'string') {
+    options = { filename: options };
+  }
+  contextObject = createContext(contextObject, getContextOptions(options));
+  options = { ...options, [kParsingContext]: contextObject };
+  return createScript(code, options).runInNewContext(contextObject, options);
+}
+
+function runInThisContext(code, options) {
+  if (typeof options === 'string') {
+    options = { filename: options };
+  }
+  return createScript(code, options).runInThisContext(options);
+}
+
+function compileFunction(code, params, options = kEmptyObject) {
+  validateString(code, 'code');
+  validateObject(options, 'options');
+  if (params !== undefined) {
+    validateStringArray(params, 'params');
+  }
+  const {
+    filename = '',
+    columnOffset = 0,
+    lineOffset = 0,
+    cachedData = undefined,
+    produceCachedData = false,
+    parsingContext = undefined,
+    contextExtensions = [],
+    importModuleDynamically,
+  } = options;
+
+  validateString(filename, 'options.filename');
+  validateInt32(columnOffset, 'options.columnOffset');
+  validateInt32(lineOffset, 'options.lineOffset');
+  if (cachedData !== undefined)
+    validateBuffer(cachedData, 'options.cachedData');
+  validateBoolean(produceCachedData, 'options.produceCachedData');
+  if (parsingContext !== undefined) {
+    if (
+      typeof parsingContext !== 'object' ||
+      parsingContext === null ||
+      !isContext(parsingContext)
+    ) {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.parsingContext',
+        'Context',
+        parsingContext,
+      );
+    }
+  }
+  validateArray(contextExtensions, 'options.contextExtensions');
+  ArrayPrototypeForEach(contextExtensions, (extension, i) => {
+    const name = `options.contextExtensions[${i}]`;
+    validateObject(extension, name, kValidateObjectAllowNullable);
+  });
+
+  const hostDefinedOptionId =
+      getHostDefinedOptionId(importModuleDynamically, filename);
+
+  return internalCompileFunction(
+    code, filename, lineOffset, columnOffset,
+    cachedData, produceCachedData, parsingContext, contextExtensions,
+    params, hostDefinedOptionId, importModuleDynamically,
+  ).function;
+}
+
+const measureMemoryModes = {
+  summary: constants.measureMemory.mode.SUMMARY,
+  detailed: constants.measureMemory.mode.DETAILED,
+};
+
+const measureMemoryExecutions = {
+  default: constants.measureMemory.execution.DEFAULT,
+  eager: constants.measureMemory.execution.EAGER,
+};
+
+function measureMemory(options = kEmptyObject) {
+  emitExperimentalWarning('vm.measureMemory');
+  validateObject(options, 'options');
+  const { mode = 'summary', execution = 'default' } = options;
+  validateOneOf(mode, 'options.mode', ['summary', 'detailed']);
+  validateOneOf(execution, 'options.execution', ['default', 'eager']);
+  const result = _measureMemory(measureMemoryModes[mode],
+                                measureMemoryExecutions[execution]);
+  if (result === undefined) {
+    return PromiseReject(new ERR_CONTEXT_NOT_INITIALIZED());
+  }
+  return result;
+}
+
+const vmConstants = {
+  __proto__: null,
+  USE_MAIN_CONTEXT_DEFAULT_LOADER: vm_dynamic_import_main_context_default,
+  DONT_CONTEXTIFY: vm_context_no_contextify,
+};
+
+ObjectFreeze(vmConstants);
+
+module.exports = {
+  Script,
+  createContext,
+  createScript,
+  runInContext,
+  runInNewContext,
+  runInThisContext,
+  isContext,
+  compileFunction,
+  measureMemory,
+  constants: vmConstants,
+};
+
+// The vm module is patched to include vm.Module, vm.SourceTextModule
+// and vm.SyntheticModule in the pre-execution phase when
+// --experimental-vm-modules is on.
\ No newline at end of file
diff --git a/.codesandbox/node/wasi.js b/.codesandbox/node/wasi.js
new file mode 100644
index 0000000000..71dbc60ac8
--- /dev/null
+++ b/.codesandbox/node/wasi.js
@@ -0,0 +1,176 @@
+'use strict';
+const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  FunctionPrototypeBind,
+  ObjectEntries,
+  String,
+  Symbol,
+} = primordials;
+
+const {
+  ERR_INVALID_ARG_VALUE,
+  ERR_WASI_ALREADY_STARTED,
+} = require('internal/errors').codes;
+const {
+  emitExperimentalWarning,
+  kEmptyObject,
+} = require('internal/util');
+const {
+  validateArray,
+  validateBoolean,
+  validateFunction,
+  validateInt32,
+  validateObject,
+  validateString,
+  validateUndefined,
+} = require('internal/validators');
+const kExitCode = Symbol('kExitCode');
+const kSetMemory = Symbol('kSetMemory');
+const kStarted = Symbol('kStarted');
+const kInstance = Symbol('kInstance');
+const kBindingName = Symbol('kBindingName');
+
+emitExperimentalWarning('WASI');
+
+class WASI {
+  constructor(options = kEmptyObject) {
+    validateObject(options, 'options');
+
+    let _WASI;
+    validateString(options.version, 'options.version');
+    switch (options.version) {
+      case 'unstable':
+        ({ WASI: _WASI } = internalBinding('wasi'));
+        this[kBindingName] = 'wasi_unstable';
+        break;
+      case 'preview1':
+        ({ WASI: _WASI } = internalBinding('wasi'));
+        this[kBindingName] = 'wasi_snapshot_preview1';
+        break;
+      // When adding support for additional wasi versions add case here
+      default:
+        throw new ERR_INVALID_ARG_VALUE('options.version',
+                                        options.version,
+                                        'unsupported WASI version');
+    }
+
+    if (options.args !== undefined)
+      validateArray(options.args, 'options.args');
+    const args = ArrayPrototypeMap(options.args || [], String);
+
+    const env = [];
+    if (options.env !== undefined) {
+      validateObject(options.env, 'options.env');
+      ArrayPrototypeForEach(
+        ObjectEntries(options.env),
+        ({ 0: key, 1: value }) => {
+          if (value !== undefined)
+            ArrayPrototypePush(env, `${key}=${value}`);
+        });
+    }
+
+    const preopens = [];
+    if (options.preopens !== undefined) {
+      validateObject(options.preopens, 'options.preopens');
+      ArrayPrototypeForEach(
+        ObjectEntries(options.preopens),
+        ({ 0: key, 1: value }) =>
+          ArrayPrototypePush(preopens, String(key), String(value)),
+      );
+    }
+
+    const { stdin = 0, stdout = 1, stderr = 2 } = options;
+    validateInt32(stdin, 'options.stdin', 0);
+    validateInt32(stdout, 'options.stdout', 0);
+    validateInt32(stderr, 'options.stderr', 0);
+    const stdio = [stdin, stdout, stderr];
+
+    const wrap = new _WASI(args, env, preopens, stdio);
+
+    for (const prop in wrap) {
+      wrap[prop] = FunctionPrototypeBind(wrap[prop], wrap);
+    }
+
+    let returnOnExit = true;
+    if (options.returnOnExit !== undefined) {
+      validateBoolean(options.returnOnExit, 'options.returnOnExit');
+      returnOnExit = options.returnOnExit;
+    }
+    if (returnOnExit)
+      wrap.proc_exit = FunctionPrototypeBind(wasiReturnOnProcExit, this);
+
+    this[kSetMemory] = wrap._setMemory;
+    delete wrap._setMemory;
+    this.wasiImport = wrap;
+    this[kStarted] = false;
+    this[kExitCode] = 0;
+    this[kInstance] = undefined;
+  }
+
+  finalizeBindings(instance, {
+    memory = instance?.exports?.memory,
+  } = {}) {
+    if (this[kStarted]) {
+      throw new ERR_WASI_ALREADY_STARTED();
+    }
+
+    validateObject(instance, 'instance');
+    validateObject(instance.exports, 'instance.exports');
+
+    this[kSetMemory](memory);
+
+    this[kInstance] = instance;
+    this[kStarted] = true;
+  }
+
+  // Must not export _initialize, must export _start
+  start(instance) {
+    this.finalizeBindings(instance);
+
+    const { _start, _initialize } = this[kInstance].exports;
+
+    validateFunction(_start, 'instance.exports._start');
+    validateUndefined(_initialize, 'instance.exports._initialize');
+
+    try {
+      _start();
+    } catch (err) {
+      if (err !== kExitCode) {
+        throw err;
+      }
+    }
+
+    return this[kExitCode];
+  }
+
+  // Must not export _start, may optionally export _initialize
+  initialize(instance) {
+    this.finalizeBindings(instance);
+
+    const { _start, _initialize } = this[kInstance].exports;
+
+    validateUndefined(_start, 'instance.exports._start');
+    if (_initialize !== undefined) {
+      validateFunction(_initialize, 'instance.exports._initialize');
+      _initialize();
+    }
+  }
+
+  getImportObject() {
+    return { [this[kBindingName]]: this.wasiImport };
+  }
+}
+
+module.exports = { WASI };
+
+
+function wasiReturnOnProcExit(rval) {
+  // If __wasi_proc_exit() does not terminate the process, an assertion is
+  // triggered in the wasm runtime. Node can sidestep the assertion and return
+  // an exit code by recording the exit code, and throwing a JavaScript
+  // exception that WebAssembly cannot catch.
+  this[kExitCode] = rval;
+  throw kExitCode;
+}
\ No newline at end of file
diff --git a/.codesandbox/node/worker_pool.js b/.codesandbox/node/worker_pool.js
new file mode 100644
index 0000000000..bc0e59c7d9
--- /dev/null
+++ b/.codesandbox/node/worker_pool.js
@@ -0,0 +1,13 @@
+const WorkerPool = require('./worker_pool.js');
+const os = require('node:os');
+
+const pool = new WorkerPool(os.availableParallelism());
+
+let finished = 0;
+for (let i = 0; i < 10; i++) {
+  pool.runTask({ a: 42, b: 100 }, (err, result) => {
+    console.log(i, err, result);
+    if (++finished === 10)
+      pool.close();
+  });
+}
\ No newline at end of file
diff --git a/.codesandbox/node/worker_threads.js b/.codesandbox/node/worker_threads.js
new file mode 100644
index 0000000000..7192c8d237
--- /dev/null
+++ b/.codesandbox/node/worker_threads.js
@@ -0,0 +1,57 @@
+'use strict';
+
+const {
+  isInternalThread,
+  isMainThread,
+  SHARE_ENV,
+  resourceLimits,
+  setEnvironmentData,
+  getEnvironmentData,
+  threadId,
+  threadName,
+  Worker,
+} = require('internal/worker');
+
+const {
+  MessagePort,
+  MessageChannel,
+  markAsUncloneable,
+  moveMessagePortToContext,
+  receiveMessageOnPort,
+  BroadcastChannel,
+} = require('internal/worker/io');
+
+const {
+  postMessageToThread,
+} = require('internal/worker/messaging');
+
+const {
+  markAsUntransferable,
+  isMarkedAsUntransferable,
+} = require('internal/buffer');
+
+const { locks } = require('internal/locks');
+
+module.exports = {
+  isInternalThread,
+  isMainThread,
+  MessagePort,
+  MessageChannel,
+  markAsUncloneable,
+  markAsUntransferable,
+  isMarkedAsUntransferable,
+  moveMessagePortToContext,
+  receiveMessageOnPort,
+  resourceLimits,
+  postMessageToThread,
+  threadId,
+  threadName,
+  SHARE_ENV,
+  Worker,
+  parentPort: null,
+  workerData: null,
+  BroadcastChannel,
+  setEnvironmentData,
+  getEnvironmentData,
+  locks,
+};
\ No newline at end of file
diff --git a/.codesandbox/node/zlib.js b/.codesandbox/node/zlib.js
new file mode 100644
index 0000000000..d910795812
--- /dev/null
+++ b/.codesandbox/node/zlib.js
@@ -0,0 +1,1020 @@
+'use strict';
+
+const {
+  ArrayBuffer,
+  MathMax,
+  NumberIsNaN,
+  ObjectDefineProperties,
+  ObjectDefineProperty,
+  ObjectEntries,
+  ObjectFreeze,
+  ObjectKeys,
+  ObjectSetPrototypeOf,
+  ReflectApply,
+  Symbol,
+  Uint32Array,
+} = primordials;
+
+const {
+  codes: {
+    ERR_BROTLI_INVALID_PARAM,
+    ERR_BUFFER_TOO_LARGE,
+    ERR_INVALID_ARG_TYPE,
+    ERR_OUT_OF_RANGE,
+    ERR_TRAILING_JUNK_AFTER_STREAM_END,
+    ERR_ZSTD_INVALID_PARAM,
+  },
+  genericNodeError,
+} = require('internal/errors');
+const { Transform, finished } = require('stream');
+const {
+  deprecateInstantiation,
+} = require('internal/util');
+const {
+  isArrayBufferView,
+  isAnyArrayBuffer,
+  isUint8Array,
+} = require('internal/util/types');
+const binding = internalBinding('zlib');
+const { crc32: crc32Native } = binding;
+const assert = require('internal/assert');
+const {
+  Buffer,
+  kMaxLength,
+} = require('buffer');
+const { owner_symbol } = require('internal/async_hooks').symbols;
+const {
+  checkRangesOrGetDefault,
+  validateFunction,
+  validateUint32,
+  validateFiniteNumber,
+} = require('internal/validators');
+
+const kFlushFlag = Symbol('kFlushFlag');
+const kError = Symbol('kError');
+
+const constants = internalBinding('constants').zlib;
+const {
+  // Zlib flush levels
+  Z_NO_FLUSH, Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH,
+  // Zlib option values
+  Z_MIN_CHUNK, Z_MIN_WINDOWBITS, Z_MAX_WINDOWBITS, Z_MIN_LEVEL, Z_MAX_LEVEL,
+  Z_MIN_MEMLEVEL, Z_MAX_MEMLEVEL, Z_DEFAULT_CHUNK, Z_DEFAULT_COMPRESSION,
+  Z_DEFAULT_STRATEGY, Z_DEFAULT_WINDOWBITS, Z_DEFAULT_MEMLEVEL, Z_FIXED,
+  // Node's compression stream modes (node_zlib_mode)
+  DEFLATE, DEFLATERAW, INFLATE, INFLATERAW, GZIP, GUNZIP, UNZIP,
+  BROTLI_DECODE, BROTLI_ENCODE,
+  ZSTD_COMPRESS, ZSTD_DECOMPRESS,
+  // Brotli operations (~flush levels)
+  BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_FLUSH,
+  BROTLI_OPERATION_FINISH, BROTLI_OPERATION_EMIT_METADATA,
+  // Zstd end directives (~flush levels)
+  ZSTD_e_continue, ZSTD_e_flush, ZSTD_e_end,
+} = constants;
+
+// Translation table for return codes.
+const codes = {
+  Z_OK: constants.Z_OK,
+  Z_STREAM_END: constants.Z_STREAM_END,
+  Z_NEED_DICT: constants.Z_NEED_DICT,
+  Z_ERRNO: constants.Z_ERRNO,
+  Z_STREAM_ERROR: constants.Z_STREAM_ERROR,
+  Z_DATA_ERROR: constants.Z_DATA_ERROR,
+  Z_MEM_ERROR: constants.Z_MEM_ERROR,
+  Z_BUF_ERROR: constants.Z_BUF_ERROR,
+  Z_VERSION_ERROR: constants.Z_VERSION_ERROR,
+};
+
+for (const ckey of ObjectKeys(codes)) {
+  codes[codes[ckey]] = ckey;
+}
+
+function zlibBuffer(engine, buffer, callback) {
+  validateFunction(callback, 'callback');
+  // Streams do not support non-Uint8Array ArrayBufferViews yet. Convert it to a
+  // Buffer without copying.
+  if (isArrayBufferView(buffer) && !isUint8Array(buffer)) {
+    buffer = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  } else if (isAnyArrayBuffer(buffer)) {
+    buffer = Buffer.from(buffer);
+  }
+  engine.buffers = null;
+  engine.nread = 0;
+  engine.cb = callback;
+  engine.on('data', zlibBufferOnData);
+  engine.on('error', zlibBufferOnError);
+  engine.on('end', zlibBufferOnEnd);
+  engine.end(buffer);
+}
+
+function zlibBufferOnData(chunk) {
+  if (!this.buffers) {
+    this.buffers = [chunk];
+  } else {
+    this.buffers.push(chunk);
+  }
+  this.nread += chunk.length;
+  if (this.nread > this._maxOutputLength) {
+    this.close();
+    this.removeAllListeners('end');
+    this.cb(new ERR_BUFFER_TOO_LARGE(this._maxOutputLength));
+  }
+}
+
+function zlibBufferOnError(err) {
+  this.removeAllListeners('end');
+  this.cb(err);
+}
+
+function zlibBufferOnEnd() {
+  let buf;
+  if (this.nread === 0) {
+    buf = Buffer.alloc(0);
+  } else {
+    const bufs = this.buffers;
+    buf = (bufs.length === 1 ? bufs[0] : Buffer.concat(bufs, this.nread));
+  }
+  this.close();
+  if (this._info)
+    this.cb(null, { buffer: buf, engine: this });
+  else
+    this.cb(null, buf);
+}
+
+function zlibBufferSync(engine, buffer) {
+  if (typeof buffer === 'string') {
+    buffer = Buffer.from(buffer);
+  } else if (!isArrayBufferView(buffer)) {
+    if (isAnyArrayBuffer(buffer)) {
+      buffer = Buffer.from(buffer);
+    } else {
+      throw new ERR_INVALID_ARG_TYPE(
+        'buffer',
+        ['string', 'Buffer', 'TypedArray', 'DataView', 'ArrayBuffer'],
+        buffer,
+      );
+    }
+  }
+  buffer = processChunkSync(engine, buffer, engine._finishFlushFlag);
+  if (engine._info)
+    return { buffer, engine };
+  return buffer;
+}
+
+function zlibOnError(message, errno, code) {
+  const self = this[owner_symbol];
+  // There is no way to cleanly recover.
+  // Continuing only obscures problems.
+
+  const error = genericNodeError(message, { errno, code });
+  error.errno = errno;
+  error.code = code;
+  self.destroy(error);
+  self[kError] = error;
+}
+
+const FLUSH_BOUND = [
+  [ Z_NO_FLUSH, Z_BLOCK ],
+  [ BROTLI_OPERATION_PROCESS, BROTLI_OPERATION_EMIT_METADATA ],
+  [ ZSTD_e_continue, ZSTD_e_end ],
+];
+const FLUSH_BOUND_IDX_NORMAL = 0;
+const FLUSH_BOUND_IDX_BROTLI = 1;
+const FLUSH_BOUND_IDX_ZSTD = 2;
+
+/**
+ * The base class for all Zlib-style streams.
+ * @class
+ */
+function ZlibBase(opts, mode, handle, { flush, finishFlush, fullFlush }) {
+  let chunkSize = Z_DEFAULT_CHUNK;
+  let maxOutputLength = kMaxLength;
+  // The ZlibBase class is not exported to user land, the mode should only be
+  // passed in by us.
+  assert(typeof mode === 'number');
+  assert(mode >= DEFLATE && mode <= ZSTD_DECOMPRESS);
+
+  let flushBoundIdx;
+  if (mode === BROTLI_ENCODE || mode === BROTLI_DECODE) {
+    flushBoundIdx = FLUSH_BOUND_IDX_BROTLI;
+  } else if (mode === ZSTD_COMPRESS || mode === ZSTD_DECOMPRESS) {
+    flushBoundIdx = FLUSH_BOUND_IDX_ZSTD;
+  } else {
+    flushBoundIdx = FLUSH_BOUND_IDX_NORMAL;
+  }
+
+  if (opts) {
+    chunkSize = opts.chunkSize;
+    if (!validateFiniteNumber(chunkSize, 'options.chunkSize')) {
+      chunkSize = Z_DEFAULT_CHUNK;
+    } else if (chunkSize < Z_MIN_CHUNK) {
+      throw new ERR_OUT_OF_RANGE('options.chunkSize',
+                                 `>= ${Z_MIN_CHUNK}`, chunkSize);
+    }
+
+    flush = checkRangesOrGetDefault(
+      opts.flush, 'options.flush',
+      FLUSH_BOUND[flushBoundIdx][0], FLUSH_BOUND[flushBoundIdx][1], flush);
+
+    finishFlush = checkRangesOrGetDefault(
+      opts.finishFlush, 'options.finishFlush',
+      FLUSH_BOUND[flushBoundIdx][0], FLUSH_BOUND[flushBoundIdx][1],
+      finishFlush);
+
+    maxOutputLength = checkRangesOrGetDefault(
+      opts.maxOutputLength, 'options.maxOutputLength',
+      1, kMaxLength, kMaxLength);
+
+    if (opts.encoding || opts.objectMode || opts.writableObjectMode) {
+      opts = { ...opts };
+      opts.encoding = null;
+      opts.objectMode = false;
+      opts.writableObjectMode = false;
+    }
+  }
+
+  ReflectApply(Transform, this, [{ autoDestroy: true, ...opts }]);
+  this[kError] = null;
+  this.bytesWritten = 0;
+  this._handle = handle;
+  handle[owner_symbol] = this;
+  // Used by processCallback() and zlibOnError()
+  handle.onerror = zlibOnError;
+  this._outBuffer = Buffer.allocUnsafe(chunkSize);
+  this._outOffset = 0;
+
+  this._chunkSize = chunkSize;
+  this._defaultFlushFlag = flush;
+  this._finishFlushFlag = finishFlush;
+  this._defaultFullFlushFlag = fullFlush;
+  this._info = opts?.info;
+  this._maxOutputLength = maxOutputLength;
+
+  this._rejectGarbageAfterEnd = opts?.rejectGarbageAfterEnd === true;
+}
+ObjectSetPrototypeOf(ZlibBase.prototype, Transform.prototype);
+ObjectSetPrototypeOf(ZlibBase, Transform);
+
+ObjectDefineProperty(ZlibBase.prototype, '_closed', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    return !this._handle;
+  },
+});
+
+/**
+ * @this {ZlibBase}
+ * @returns {void}
+ */
+ZlibBase.prototype.reset = function() {
+  assert(this._handle, 'zlib binding closed');
+  return this._handle.reset();
+};
+
+/**
+ * @this {ZlibBase}
+ * This is the _flush function called by the transform class,
+ * internally, when the last chunk has been written.
+ * @returns {void}
+ */
+ZlibBase.prototype._flush = function(callback) {
+  this._transform(Buffer.alloc(0), '', callback);
+};
+
+/**
+ * @this {ZlibBase}
+ * Force Transform compat behavior.
+ * @returns {void}
+ */
+ZlibBase.prototype._final = function(callback) {
+  callback();
+};
+
+// If a flush is scheduled while another flush is still pending, a way to figure
+// out which one is the "stronger" flush is needed.
+// This is currently only used to figure out which flush flag to use for the
+// last chunk.
+// Roughly, the following holds:
+// Z_NO_FLUSH < Z_BLOCK < Z_PARTIAL_FLUSH <
+//     Z_SYNC_FLUSH < Z_FULL_FLUSH < Z_FINISH
+const flushiness = [];
+const kFlushFlagList = [Z_NO_FLUSH, Z_BLOCK, Z_PARTIAL_FLUSH,
+                        Z_SYNC_FLUSH, Z_FULL_FLUSH, Z_FINISH];
+for (let i = 0; i < kFlushFlagList.length; i++) {
+  flushiness[kFlushFlagList[i]] = i;
+}
+
+function maxFlush(a, b) {
+  return flushiness[a] > flushiness[b] ? a : b;
+}
+
+// Set up a list of 'special' buffers that can be written using .write()
+// from the .flush() code as a way of introducing flushing operations into the
+// write sequence.
+const kFlushBuffers = [];
+{
+  const dummyArrayBuffer = new ArrayBuffer();
+  for (const flushFlag of kFlushFlagList) {
+    kFlushBuffers[flushFlag] = Buffer.from(dummyArrayBuffer);
+    kFlushBuffers[flushFlag][kFlushFlag] = flushFlag;
+  }
+}
+
+ZlibBase.prototype.flush = function(kind, callback) {
+  if (typeof kind === 'function' || (kind === undefined && !callback)) {
+    callback = kind;
+    kind = this._defaultFullFlushFlag;
+  }
+
+  if (this.writableFinished) {
+    if (callback)
+      process.nextTick(callback);
+  } else if (this.writableEnded) {
+    if (callback)
+      this.once('end', callback);
+  } else {
+    this.write(kFlushBuffers[kind], '', callback);
+  }
+};
+
+/**
+ * @this {import('stream').Transform}
+ * @param {(err?: Error) => any} [callback]
+ */
+ZlibBase.prototype.close = function(callback) {
+  if (callback) finished(this, callback);
+  this.destroy();
+};
+
+ZlibBase.prototype._destroy = function(err, callback) {
+  _close(this);
+  callback(err);
+};
+
+ZlibBase.prototype._transform = function(chunk, encoding, cb) {
+  let flushFlag = this._defaultFlushFlag;
+  // We use a 'fake' zero-length chunk to carry information about flushes from
+  // the public API to the actual stream implementation.
+  if (typeof chunk[kFlushFlag] === 'number') {
+    flushFlag = chunk[kFlushFlag];
+  }
+
+  // For the last chunk, also apply `_finishFlushFlag`.
+  if (this.writableEnded && this.writableLength === chunk.byteLength) {
+    flushFlag = maxFlush(flushFlag, this._finishFlushFlag);
+  }
+  processChunk(this, chunk, flushFlag, cb);
+};
+
+ZlibBase.prototype._processChunk = function(chunk, flushFlag, cb) {
+  // _processChunk() is left for backwards compatibility
+  if (typeof cb === 'function')
+    processChunk(this, chunk, flushFlag, cb);
+  else
+    return processChunkSync(this, chunk, flushFlag);
+};
+
+function processChunkSync(self, chunk, flushFlag) {
+  let availInBefore = chunk.byteLength;
+  let availOutBefore = self._chunkSize - self._outOffset;
+  let inOff = 0;
+  let availOutAfter;
+  let availInAfter;
+
+  const buffers = [];
+  let nread = 0;
+  let inputRead = 0;
+  const state = self._writeState;
+  const handle = self._handle;
+  let buffer = self._outBuffer;
+  let offset = self._outOffset;
+  const chunkSize = self._chunkSize;
+
+  let error;
+  self.on('error', function onError(er) {
+    error = er;
+  });
+
+  while (true) {
+    handle.writeSync(flushFlag,
+                     chunk, // in
+                     inOff, // in_off
+                     availInBefore, // in_len
+                     buffer, // out
+                     offset, // out_off
+                     availOutBefore); // out_len
+    if (error)
+      throw error;
+    else if (self[kError])
+      throw self[kError];
+
+    availOutAfter = state[0];
+    availInAfter = state[1];
+
+    const inDelta = (availInBefore - availInAfter);
+    inputRead += inDelta;
+
+    const have = availOutBefore - availOutAfter;
+    if (have > 0) {
+      const out = buffer.slice(offset, offset + have);
+      offset += have;
+      buffers.push(out);
+      nread += out.byteLength;
+
+      if (nread > self._maxOutputLength) {
+        _close(self);
+        throw new ERR_BUFFER_TOO_LARGE(self._maxOutputLength);
+      }
+
+    } else {
+      assert(have === 0, 'have should not go down');
+    }
+
+    // Exhausted the output buffer, or used all the input create a new one.
+    if (availOutAfter === 0 || offset >= chunkSize) {
+      availOutBefore = chunkSize;
+      offset = 0;
+      buffer = Buffer.allocUnsafe(chunkSize);
+    }
+
+    if (availOutAfter === 0) {
+      // Not actually done. Need to reprocess.
+      // Also, update the availInBefore to the availInAfter value,
+      // so that if we have to hit it a third (fourth, etc.) time,
+      // it'll have the correct byte counts.
+      inOff += inDelta;
+      availInBefore = availInAfter;
+    } else {
+      break;
+    }
+  }
+
+  self.bytesWritten = inputRead;
+  _close(self);
+
+  if (nread === 0)
+    return Buffer.alloc(0);
+
+  return (buffers.length === 1 ? buffers[0] : Buffer.concat(buffers, nread));
+}
+
+function processChunk(self, chunk, flushFlag, cb) {
+  const handle = self._handle;
+  if (!handle) return process.nextTick(cb);
+
+  handle.buffer = chunk;
+  handle.cb = cb;
+  handle.availOutBefore = self._chunkSize - self._outOffset;
+  handle.availInBefore = chunk.byteLength;
+  handle.inOff = 0;
+  handle.flushFlag = flushFlag;
+
+  handle.write(flushFlag,
+               chunk, // in
+               0, // in_off
+               handle.availInBefore, // in_len
+               self._outBuffer, // out
+               self._outOffset, // out_off
+               handle.availOutBefore); // out_len
+}
+
+function processCallback() {
+  // This callback's context (`this`) is the `_handle` (ZCtx) object. It is
+  // important to null out the values once they are no longer needed since
+  // `_handle` can stay in memory long after the buffer is needed.
+  const handle = this;
+  const self = this[owner_symbol];
+  const state = self._writeState;
+
+  if (self.destroyed) {
+    this.buffer = null;
+    this.cb();
+    return;
+  }
+
+  const availOutAfter = state[0];
+  const availInAfter = state[1];
+
+  const inDelta = handle.availInBefore - availInAfter;
+  self.bytesWritten += inDelta;
+
+  const have = handle.availOutBefore - availOutAfter;
+  let streamBufferIsFull = false;
+  if (have > 0) {
+    const out = self._outBuffer.slice(self._outOffset, self._outOffset + have);
+    self._outOffset += have;
+    streamBufferIsFull = !self.push(out);
+  } else {
+    assert(have === 0, 'have should not go down');
+  }
+
+  if (self.destroyed) {
+    this.cb();
+    return;
+  }
+
+  // Exhausted the output buffer, or used all the input create a new one.
+  if (availOutAfter === 0 || self._outOffset >= self._chunkSize) {
+    handle.availOutBefore = self._chunkSize;
+    self._outOffset = 0;
+    self._outBuffer = Buffer.allocUnsafe(self._chunkSize);
+  }
+
+  if (availOutAfter === 0) {
+    // Not actually done. Need to reprocess.
+    // Also, update the availInBefore to the availInAfter value,
+    // so that if we have to hit it a third (fourth, etc.) time,
+    // it'll have the correct byte counts.
+    handle.inOff += inDelta;
+    handle.availInBefore = availInAfter;
+
+
+    if (!streamBufferIsFull) {
+      this.write(handle.flushFlag,
+                 this.buffer, // in
+                 handle.inOff, // in_off
+                 handle.availInBefore, // in_len
+                 self._outBuffer, // out
+                 self._outOffset, // out_off
+                 self._chunkSize); // out_len
+    } else {
+      const oldRead = self._read;
+      self._read = (n) => {
+        self._read = oldRead;
+        this.write(handle.flushFlag,
+                   this.buffer, // in
+                   handle.inOff, // in_off
+                   handle.availInBefore, // in_len
+                   self._outBuffer, // out
+                   self._outOffset, // out_off
+                   self._chunkSize); // out_len
+        self._read(n);
+      };
+    }
+    return;
+  }
+
+  if (availInAfter > 0) {
+    // If we have more input that should be written, but we also have output
+    // space available, that means that the compression library was not
+    // interested in receiving more data, and in particular that the input
+    // stream has ended early.
+    // This applies to streams where we don't check data past the end of
+    // what was consumed; that is, everything except Gunzip/Unzip.
+
+    if (self._rejectGarbageAfterEnd) {
+      const err = new ERR_TRAILING_JUNK_AFTER_STREAM_END();
+      self.destroy(err);
+      this.cb(err);
+      return;
+    }
+
+    self.push(null);
+  }
+
+  // Finished with the chunk.
+  this.buffer = null;
+  this.cb();
+}
+
+/**
+ * @param {ZlibBase} engine
+ * @private
+ */
+function _close(engine) {
+  // Caller may invoke .close after a zlib error (which will null _handle)
+  engine._handle?.close();
+  engine._handle = null;
+}
+
+const zlibDefaultOpts = {
+  flush: Z_NO_FLUSH,
+  finishFlush: Z_FINISH,
+  fullFlush: Z_FULL_FLUSH,
+};
+// Base class for all streams actually backed by zlib and using zlib-specific
+// parameters.
+function Zlib(opts, mode) {
+  let windowBits = Z_DEFAULT_WINDOWBITS;
+  let level = Z_DEFAULT_COMPRESSION;
+  let memLevel = Z_DEFAULT_MEMLEVEL;
+  let strategy = Z_DEFAULT_STRATEGY;
+  let dictionary;
+
+  if (opts) {
+    // windowBits is special. On the compression side, 0 is an invalid value.
+    // But on the decompression side, a value of 0 for windowBits tells zlib
+    // to use the window size in the zlib header of the compressed stream.
+    if ((opts.windowBits == null || opts.windowBits === 0) &&
+        (mode === INFLATE ||
+         mode === GUNZIP ||
+         mode === UNZIP)) {
+      windowBits = 0;
+    } else {
+      // `{ windowBits: 8 }` is valid for deflate but not gzip.
+      const min = Z_MIN_WINDOWBITS + (mode === GZIP ? 1 : 0);
+      windowBits = checkRangesOrGetDefault(
+        opts.windowBits, 'options.windowBits',
+        min, Z_MAX_WINDOWBITS, Z_DEFAULT_WINDOWBITS);
+    }
+
+    level = checkRangesOrGetDefault(
+      opts.level, 'options.level',
+      Z_MIN_LEVEL, Z_MAX_LEVEL, Z_DEFAULT_COMPRESSION);
+
+    memLevel = checkRangesOrGetDefault(
+      opts.memLevel, 'options.memLevel',
+      Z_MIN_MEMLEVEL, Z_MAX_MEMLEVEL, Z_DEFAULT_MEMLEVEL);
+
+    strategy = checkRangesOrGetDefault(
+      opts.strategy, 'options.strategy',
+      Z_DEFAULT_STRATEGY, Z_FIXED, Z_DEFAULT_STRATEGY);
+
+    dictionary = opts.dictionary;
+    if (dictionary !== undefined && !isArrayBufferView(dictionary)) {
+      if (isAnyArrayBuffer(dictionary)) {
+        dictionary = Buffer.from(dictionary);
+      } else {
+        throw new ERR_INVALID_ARG_TYPE(
+          'options.dictionary',
+          ['Buffer', 'TypedArray', 'DataView', 'ArrayBuffer'],
+          dictionary,
+        );
+      }
+    }
+  }
+
+  const handle = new binding.Zlib(mode);
+  // Ideally, we could let ZlibBase() set up _writeState. I haven't been able
+  // to come up with a good solution that doesn't break our internal API,
+  // and with it all supported npm versions at the time of writing.
+  this._writeState = new Uint32Array(2);
+  handle.init(windowBits,
+              level,
+              memLevel,
+              strategy,
+              this._writeState,
+              processCallback,
+              dictionary);
+
+  ReflectApply(ZlibBase, this, [opts, mode, handle, zlibDefaultOpts]);
+
+  this._level = level;
+  this._strategy = strategy;
+  this._mode = mode;
+}
+ObjectSetPrototypeOf(Zlib.prototype, ZlibBase.prototype);
+ObjectSetPrototypeOf(Zlib, ZlibBase);
+
+// This callback is used by `.params()` to wait until a full flush happened
+// before adjusting the parameters. In particular, the call to the native
+// `params()` function should not happen while a write is currently in progress
+// on the threadpool.
+function paramsAfterFlushCallback(level, strategy, callback) {
+  assert(this._handle, 'zlib binding closed');
+  this._handle.params(level, strategy);
+  if (!this.destroyed) {
+    this._level = level;
+    this._strategy = strategy;
+    if (callback) callback();
+  }
+}
+
+Zlib.prototype.params = function params(level, strategy, callback) {
+  checkRangesOrGetDefault(level, 'level', Z_MIN_LEVEL, Z_MAX_LEVEL);
+  checkRangesOrGetDefault(strategy, 'strategy', Z_DEFAULT_STRATEGY, Z_FIXED);
+
+  if (this._level !== level || this._strategy !== strategy) {
+    this.flush(
+      Z_SYNC_FLUSH,
+      paramsAfterFlushCallback.bind(this, level, strategy, callback),
+    );
+  } else {
+    process.nextTick(callback);
+  }
+};
+
+// generic zlib
+// minimal 2-byte header
+function Deflate(opts) {
+  if (!(this instanceof Deflate)) {
+    return deprecateInstantiation(Deflate, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, DEFLATE]);
+}
+ObjectSetPrototypeOf(Deflate.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(Deflate, Zlib);
+
+function Inflate(opts) {
+  if (!(this instanceof Inflate)) {
+    return deprecateInstantiation(Inflate, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, INFLATE]);
+}
+ObjectSetPrototypeOf(Inflate.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(Inflate, Zlib);
+
+function Gzip(opts) {
+  if (!(this instanceof Gzip)) {
+    return deprecateInstantiation(Gzip, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, GZIP]);
+}
+ObjectSetPrototypeOf(Gzip.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(Gzip, Zlib);
+
+function Gunzip(opts) {
+  if (!(this instanceof Gunzip)) {
+    return deprecateInstantiation(Gunzip, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, GUNZIP]);
+}
+ObjectSetPrototypeOf(Gunzip.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(Gunzip, Zlib);
+
+function DeflateRaw(opts) {
+  if (opts && opts.windowBits === 8) opts.windowBits = 9;
+  if (!(this instanceof DeflateRaw)) {
+    return deprecateInstantiation(DeflateRaw, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, DEFLATERAW]);
+}
+ObjectSetPrototypeOf(DeflateRaw.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(DeflateRaw, Zlib);
+
+function InflateRaw(opts) {
+  if (!(this instanceof InflateRaw)) {
+    return deprecateInstantiation(InflateRaw, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, INFLATERAW]);
+}
+ObjectSetPrototypeOf(InflateRaw.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(InflateRaw, Zlib);
+
+function Unzip(opts) {
+  if (!(this instanceof Unzip)) {
+    return deprecateInstantiation(Unzip, 'DEP0184', opts);
+  }
+  ReflectApply(Zlib, this, [opts, UNZIP]);
+}
+ObjectSetPrototypeOf(Unzip.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(Unzip, Zlib);
+
+function createConvenienceMethod(ctor, sync) {
+  if (sync) {
+    return function syncBufferWrapper(buffer, opts) {
+      return zlibBufferSync(new ctor(opts), buffer);
+    };
+  }
+  return function asyncBufferWrapper(buffer, opts, callback) {
+    if (typeof opts === 'function') {
+      callback = opts;
+      opts = {};
+    }
+    return zlibBuffer(new ctor(opts), buffer, callback);
+  };
+}
+
+const kMaxBrotliParam = MathMax(
+  ...ObjectEntries(constants)
+    .map(({ 0: key, 1: value }) => (key.startsWith('BROTLI_PARAM_') ? value : 0)),
+);
+const brotliInitParamsArray = new Uint32Array(kMaxBrotliParam + 1);
+
+const brotliDefaultOpts = {
+  flush: BROTLI_OPERATION_PROCESS,
+  finishFlush: BROTLI_OPERATION_FINISH,
+  fullFlush: BROTLI_OPERATION_FLUSH,
+};
+function Brotli(opts, mode) {
+  assert(mode === BROTLI_DECODE || mode === BROTLI_ENCODE);
+
+  brotliInitParamsArray.fill(-1);
+  if (opts?.params) {
+    ObjectKeys(opts.params).forEach((origKey) => {
+      const key = +origKey;
+      if (NumberIsNaN(key) || key < 0 || key > kMaxBrotliParam ||
+          (brotliInitParamsArray[key] | 0) !== -1) {
+        throw new ERR_BROTLI_INVALID_PARAM(origKey);
+      }
+
+      const value = opts.params[origKey];
+      if (typeof value !== 'number' && typeof value !== 'boolean') {
+        throw new ERR_INVALID_ARG_TYPE('options.params[key]',
+                                       'number', opts.params[origKey]);
+      }
+      brotliInitParamsArray[key] = value;
+    });
+  }
+
+  const handle = mode === BROTLI_DECODE ?
+    new binding.BrotliDecoder(mode) : new binding.BrotliEncoder(mode);
+
+  this._writeState = new Uint32Array(2);
+  handle.init(brotliInitParamsArray, this._writeState, processCallback);
+
+  ReflectApply(ZlibBase, this, [opts, mode, handle, brotliDefaultOpts]);
+}
+ObjectSetPrototypeOf(Brotli.prototype, Zlib.prototype);
+ObjectSetPrototypeOf(Brotli, Zlib);
+
+function BrotliCompress(opts) {
+  if (!(this instanceof BrotliCompress)) {
+    return deprecateInstantiation(BrotliCompress, 'DEP0184', opts);
+  }
+  ReflectApply(Brotli, this, [opts, BROTLI_ENCODE]);
+}
+ObjectSetPrototypeOf(BrotliCompress.prototype, Brotli.prototype);
+ObjectSetPrototypeOf(BrotliCompress, Brotli);
+
+function BrotliDecompress(opts) {
+  if (!(this instanceof BrotliDecompress)) {
+    return deprecateInstantiation(BrotliDecompress, 'DEP0184', opts);
+  }
+  ReflectApply(Brotli, this, [opts, BROTLI_DECODE]);
+}
+ObjectSetPrototypeOf(BrotliDecompress.prototype, Brotli.prototype);
+ObjectSetPrototypeOf(BrotliDecompress, Brotli);
+
+
+const zstdDefaultOpts = {
+  flush: ZSTD_e_continue,
+  finishFlush: ZSTD_e_end,
+  fullFlush: ZSTD_e_flush,
+};
+class Zstd extends ZlibBase {
+  constructor(opts, mode, initParamsArray, maxParam) {
+    assert(mode === ZSTD_COMPRESS || mode === ZSTD_DECOMPRESS);
+
+    initParamsArray.fill(-1);
+    if (opts?.params) {
+      ObjectKeys(opts.params).forEach((origKey) => {
+        const key = +origKey;
+        if (NumberIsNaN(key) || key < 0 || key > maxParam ||
+            (initParamsArray[key] | 0) !== -1) {
+          throw new ERR_ZSTD_INVALID_PARAM(origKey);
+        }
+
+        const value = opts.params[origKey];
+        if (typeof value !== 'number' && typeof value !== 'boolean') {
+          throw new ERR_INVALID_ARG_TYPE('options.params[key]',
+                                         'number', opts.params[origKey]);
+        }
+        initParamsArray[key] = value;
+      });
+    }
+
+    const handle = mode === ZSTD_COMPRESS ?
+      new binding.ZstdCompress() : new binding.ZstdDecompress();
+
+    const pledgedSrcSize = opts?.pledgedSrcSize ?? undefined;
+
+    const writeState = new Uint32Array(2);
+
+    handle.init(
+      initParamsArray,
+      pledgedSrcSize,
+      writeState,
+      processCallback,
+      opts?.dictionary && isArrayBufferView(opts.dictionary) ? opts.dictionary : undefined,
+    );
+
+    super(opts, mode, handle, zstdDefaultOpts);
+    this._writeState = writeState;
+  }
+}
+
+const kMaxZstdCParam = MathMax(...ObjectKeys(constants).map(
+  (key) => (key.startsWith('ZSTD_c_') ?
+    constants[key] :
+    0),
+));
+
+const zstdInitCParamsArray = new Uint32Array(kMaxZstdCParam + 1);
+
+class ZstdCompress extends Zstd {
+  constructor(opts) {
+    super(opts, ZSTD_COMPRESS, zstdInitCParamsArray, kMaxZstdCParam);
+  }
+}
+
+const kMaxZstdDParam = MathMax(...ObjectKeys(constants).map(
+  (key) => (key.startsWith('ZSTD_d_') ?
+    constants[key] :
+    0),
+));
+
+const zstdInitDParamsArray = new Uint32Array(kMaxZstdDParam + 1);
+
+class ZstdDecompress extends Zstd {
+  constructor(opts) {
+    super(opts, ZSTD_DECOMPRESS, zstdInitDParamsArray, kMaxZstdDParam);
+  }
+}
+
+function createProperty(ctor) {
+  return {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    value: function(options) {
+      return new ctor(options);
+    },
+  };
+}
+
+function crc32(data, value = 0) {
+  if (typeof data !== 'string' && !isArrayBufferView(data)) {
+    throw new ERR_INVALID_ARG_TYPE('data', ['Buffer', 'TypedArray', 'DataView', 'string'], data);
+  }
+  validateUint32(value, 'value');
+  return crc32Native(data, value);
+}
+
+// Legacy alias on the C++ wrapper object. This is not public API, so we may
+// want to runtime-deprecate it at some point. There's no hurry, though.
+ObjectDefineProperty(binding.Zlib.prototype, 'jsref', {
+  __proto__: null,
+  get() { return this[owner_symbol]; },
+  set(v) { return this[owner_symbol] = v; },
+});
+
+module.exports = {
+  crc32,
+  Deflate,
+  Inflate,
+  Gzip,
+  Gunzip,
+  DeflateRaw,
+  InflateRaw,
+  Unzip,
+  BrotliCompress,
+  BrotliDecompress,
+  ZstdCompress,
+  ZstdDecompress,
+
+  // Convenience methods.
+  // compress/decompress a string or buffer in one step.
+  deflate: createConvenienceMethod(Deflate, false),
+  deflateSync: createConvenienceMethod(Deflate, true),
+  gzip: createConvenienceMethod(Gzip, false),
+  gzipSync: createConvenienceMethod(Gzip, true),
+  deflateRaw: createConvenienceMethod(DeflateRaw, false),
+  deflateRawSync: createConvenienceMethod(DeflateRaw, true),
+  unzip: createConvenienceMethod(Unzip, false),
+  unzipSync: createConvenienceMethod(Unzip, true),
+  inflate: createConvenienceMethod(Inflate, false),
+  inflateSync: createConvenienceMethod(Inflate, true),
+  gunzip: createConvenienceMethod(Gunzip, false),
+  gunzipSync: createConvenienceMethod(Gunzip, true),
+  inflateRaw: createConvenienceMethod(InflateRaw, false),
+  inflateRawSync: createConvenienceMethod(InflateRaw, true),
+  brotliCompress: createConvenienceMethod(BrotliCompress, false),
+  brotliCompressSync: createConvenienceMethod(BrotliCompress, true),
+  brotliDecompress: createConvenienceMethod(BrotliDecompress, false),
+  brotliDecompressSync: createConvenienceMethod(BrotliDecompress, true),
+  zstdCompress: createConvenienceMethod(ZstdCompress, false),
+  zstdCompressSync: createConvenienceMethod(ZstdCompress, true),
+  zstdDecompress: createConvenienceMethod(ZstdDecompress, false),
+  zstdDecompressSync: createConvenienceMethod(ZstdDecompress, true),
+};
+
+ObjectDefineProperties(module.exports, {
+  createDeflate: createProperty(Deflate),
+  createInflate: createProperty(Inflate),
+  createDeflateRaw: createProperty(DeflateRaw),
+  createInflateRaw: createProperty(InflateRaw),
+  createGzip: createProperty(Gzip),
+  createGunzip: createProperty(Gunzip),
+  createUnzip: createProperty(Unzip),
+  createBrotliCompress: createProperty(BrotliCompress),
+  createBrotliDecompress: createProperty(BrotliDecompress),
+  createZstdCompress: createProperty(ZstdCompress),
+  createZstdDecompress: createProperty(ZstdDecompress),
+  constants: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: constants,
+  },
+  codes: {
+    __proto__: null,
+    enumerable: true,
+    writable: false,
+    value: ObjectFreeze(codes),
+  },
+});
+
+// These should be considered deprecated
+// expose all the zlib constants
+for (const { 0: key, 1: value } of ObjectEntries(constants)) {
+  if (key.startsWith('BROTLI')) continue;
+  ObjectDefineProperty(module.exports, key, {
+    __proto__: null,
+    enumerable: false,
+    value,
+    writable: false,
+  });
+}
\ No newline at end of file
diff --git a/.codesandbox/tasks.json b/.codesandbox/tasks.json
new file mode 100644
index 0000000000..2285b1c8c5
--- /dev/null
+++ b/.codesandbox/tasks.json
@@ -0,0 +1,18 @@
+{
+  // These tasks will run in order when initializing your CodeSandbox project.
+  "setupTasks": [
+    {
+      "command": "pnpm install",
+      "name": "Installing Dependencies"
+    }
+  ],
+
+  // These tasks can be run from CodeSandbox. Running one will open a log in the app.
+  "tasks": {
+    "postinstall": {
+      "name": "postinstall",
+      "command": "pnpm postinstall",
+      "runAtStart": false
+    }
+  }
+}
diff --git a/.gitignore b/.gitignore
index 3d70248ba2..67aced909f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,4 +12,6 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
-package-lock.json
\ No newline at end of file
+package-lock.json
+# Local Netlify folder
+.netlify
diff --git a/.idx/dev.nix b/.idx/dev.nix
new file mode 100644
index 0000000000..7651aa28d4
--- /dev/null
+++ b/.idx/dev.nix
@@ -0,0 +1,65 @@
+# To learn more about how to use Nix to configure your environment
+# see: https://firebase.google.com/docs/studio/customize-workspace
+{ pkgs, ... }: {
+  # Which nixpkgs channel to use.
+  channel = "stable-24.05"; # or "unstable"
+
+  # Use https://search.nixos.org/packages to find packages
+  packages = [
+    
+    # pkgs.go
+    # pkgs.python311
+    # pkgs.python311Packages.pip
+    # pkgs.nodejs_20
+    # pkgs.nodePackages.nodemon
+    # pkgs.sudo
+    # pkgs.sudo-rs
+    # pkgs.doas-sudo-shim
+    # pkgs.python312Packages.pip
+    # pkgs.openssh
+    # pkgs.openshh_hpn
+    # pkgs.openssh_gssapi
+    # pkgs.busybox
+    # pkgs.speech-tools
+  ];
+
+  # Sets environment variables in the workspace
+  env = {};
+  idx = {
+    # Search for the extensions you want on https://open-vsx.org/ and use "publisher.id"
+    extensions = [
+      # "vscodevim.vim"
+    ];
+
+    # Enable previews
+    previews = {
+      enable = true;
+      previews = {
+        # web = {
+        #   # Example: run "npm run dev" with PORT set to IDX's defined port for previews,
+        #   # and show it in IDX's web preview panel
+        #   command = ["npm" "run" "dev"];
+        #   manager = "web";
+        #   env = {
+        #     # Environment variables to set for your server
+        #     PORT = "$PORT";
+        #   };
+        # };
+      };
+    };
+
+    # Workspace lifecycle hooks
+    workspace = {
+      # Runs when a workspace is first created
+      onCreate = {
+        # Example: install JS dependencies from NPM
+        # npm-install = "npm install";
+      };
+      # Runs when the workspace is (re)started
+      onStart = {
+        # Example: start a background task to watch and re-build backend code
+        # watch-backend = "npm run watch-backend";
+      };
+    };
+  };
+}
diff --git a/.package.json.swp b/.package.json.swp
new file mode 100644
index 0000000000..55fb00c678
Binary files /dev/null and b/.package.json.swp differ
diff --git a/.vscode/$PROFILE b/.vscode/$PROFILE
new file mode 100644
index 0000000000..f7069873c1
--- /dev/null
+++ b/.vscode/$PROFILE
@@ -0,0 +1,6 @@
+echo "function yarn { corepack yarn `$args }" >> $PROFILE
+echo "function yarnpkg { corepack yarnpkg `$args }" >> $PROFILE
+echo "function pnpm { corepack pnpm `$args }" >> $PROFILE
+echo "function pnpx { corepack pnpx `$args }" >> $PROFILE
+echo "function npm { corepack npm `$args }" >> $PROFILE
+echo "function npx { corepack npx `$args }" >> $PROFILE
\ No newline at end of file
diff --git a/.vscode/.bash_aliases b/.vscode/.bash_aliases
new file mode 100644
index 0000000000..e562182892
--- /dev/null
+++ b/.vscode/.bash_aliases
@@ -0,0 +1,6 @@
+alias yarn="corepack yarn"
+alias yarnpkg="corepack yarnpkg"
+alias pnpm="corepack pnpm"
+alias pnpx="corepack pnpx"
+alias npm="corepack npm"
+alias npx="corepack npx"
\ No newline at end of file
diff --git a/.vscode/.gitignore b/.vscode/.gitignore
new file mode 100644
index 0000000000..3d70248ba2
--- /dev/null
+++ b/.vscode/.gitignore
@@ -0,0 +1,15 @@
+node_modules
+.DS_Store
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+build
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+package-lock.json
\ No newline at end of file
diff --git a/.vscode/App.css b/.vscode/App.css
new file mode 100644
index 0000000000..a571b3ae9a
--- /dev/null
+++ b/.vscode/App.css
@@ -0,0 +1,43 @@
+#root {
+    max-width: 1280px;
+    margin: 0 auto;
+    padding: 2rem;
+    text-align: center;
+  }
+  
+  .logo {
+    height: 6em;
+    padding: 1.5em;
+    will-change: filter;
+    transition: filter 300ms;
+  }
+  .logo:hover {
+    filter: drop-shadow(0 0 2em #646cffaa);
+  }
+  .logo.react:hover {
+    filter: drop-shadow(0 0 2em #61dafbaa);
+  }
+  
+  @keyframes logo-spin {
+    from {
+      transform: rotate(0deg);
+    }
+    to {
+      transform: rotate(360deg);
+    }
+  }
+  
+  @media (prefers-reduced-motion: no-preference) {
+    a:nth-of-type(2) .logo {
+      animation: logo-spin infinite 20s linear;
+    }
+  }
+  
+  .card {
+    padding: 2em;
+  }
+  
+  .read-the-docs {
+    color: #888;
+  }
+  
\ No newline at end of file
diff --git a/.vscode/App.jsx b/.vscode/App.jsx
new file mode 100644
index 0000000000..6ca85721ce
--- /dev/null
+++ b/.vscode/App.jsx
@@ -0,0 +1,69 @@
+:root {
+    font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+    line-height: 1.5;
+    font-weight: 400;
+  
+    color-scheme: light dark;
+    color: rgba(255, 255, 255, 0.87);
+    background-color: #242424;
+  
+    font-synthesis: none;
+    text-rendering: optimizeLegibility;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  
+  a {
+    font-weight: 500;
+    color: #646cff;
+    text-decoration: inherit;
+  }
+  a:hover {
+    color: #535bf2;
+  }
+  
+  body {
+    margin: 0;
+    display: flex;
+    place-items: center;
+    min-width: 320px;
+    min-height: 100vh;
+  }
+  
+  h1 {
+    font-size: 3.2em;
+    line-height: 1.1;
+  }
+  
+  button {
+    border-radius: 8px;
+    border: 1px solid transparent;
+    padding: 0.6em 1.2em;
+    font-size: 1em;
+    font-weight: 500;
+    font-family: inherit;
+    background-color: #1a1a1a;
+    cursor: pointer;
+    transition: border-color 0.25s;
+  }
+  button:hover {
+    border-color: #646cff;
+  }
+  button:focus,
+  button:focus-visible {
+    outline: 4px auto -webkit-focus-ring-color;
+  }
+  
+  @media (prefers-color-scheme: light) {
+    :root {
+      color: #213547;
+      background-color: #ffffff;
+    }
+    a:hover {
+      color: #747bff;
+    }
+    button {
+      background-color: #f9f9f9;
+    }
+  }
+  
\ No newline at end of file
diff --git a/.vscode/[ b/.vscode/[
new file mode 100644
index 0000000000..3664692d69
--- /dev/null
+++ b/.vscode/[
@@ -0,0 +1 @@
+more is not installed, but available in the following packages, pick one to run it, Ctrl+C to cancel.
\ No newline at end of file
diff --git a/.vscode/app.js b/.vscode/app.js
new file mode 100644
index 0000000000..d33fe40d85
--- /dev/null
+++ b/.vscode/app.js
@@ -0,0 +1,59 @@
+require('dotenv').config();
+
+var createError = require('http-errors');
+var express = require('express');
+var path = require('path');
+var cookieParser = require('cookie-parser');
+var logger = require('morgan');
+var session = require('express-session');
+var passport = require('passport');
+var SQLiteStore = require('connect-sqlite3')(session);
+var indexRouter = require('./routes/index');
+var authRouter = require('./routes/auth');
+
+var app = express();
+
+app.locals.pluralize = require('pluralize');
+
+// view engine setup
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', 'ejs');
+
+app.use(logger('dev'));
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(cookieParser());
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+app.use('/', indexRouter);
+app.use('/', authRouter);
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+app.use(passport.authenticate('session'));
+// catch 404 and forward to error handler
+app.use(function(req, res, next) {
+  next(createError(404));
+});
+
+// error handler
+app.use(function(err, req, res, next) {
+  // set locals, only providing error in development
+  res.locals.message = err.message;
+  res.locals.error = req.app.get('env') === 'development' ? err : {};
+
+  // render the error page
+  res.status(err.status || 500);
+  res.render('error');
+});
+
+module.exports = app;
diff --git a/.vscode/auth.js b/.vscode/auth.js
new file mode 100644
index 0000000000..4a302adb10
--- /dev/null
+++ b/.vscode/auth.js
@@ -0,0 +1,79 @@
+var express = require('express');
+var passport = require('passport');
+var FacebookStrategy = require('passport-facebook');
+var session = require('express-session');
+var passport = require('passport');
+var db = require('../db');
+var router = express.Router();
+passport.use(new FacebookStrategy({
+  clientID: process.env['FACEBOOK_CLIENT_ID'],
+  clientSecret: process.env['FACEBOOK_CLIENT_SECRET'],
+  callbackURL: '/oauth2/redirect/facebook',
+  state: true
+}, function verify(accessToken, refreshToken, profile, cb) {
+  db.get('SELECT * FROM federated_credentials WHERE provider = ? AND subject = ?', [
+    'https://www.facebook.com',
+    profile.id
+  ], function(err, row) {
+    if (err) { return cb(err); }
+    if (!row) {
+      db.run('INSERT INTO users (name) VALUES (?)', [
+        profile.displayName
+      ], function(err) {
+        if (err) { return cb(err); }
+        
+        var id = this.lastID;
+        db.run('INSERT INTO federated_credentials (user_id, provider, subject) VALUES (?, ?, ?)', [
+          id,
+          'https://www.facebook.com',
+          profile.id
+        ], function(err) {
+          if (err) { return cb(err); }
+          var user = {
+            id: id,
+            name: profile.displayName
+          };
+          return cb(null, user);
+        });
+      });
+    } else {
+      db.get('SELECT * FROM users WHERE id = ?', [ row.user_id ], function(err, row) {
+        if (err) { return cb(err); }
+        if (!row) { return cb(null, false); }
+        return cb(null, row);
+      });
+    }
+  });
+  passport.serializeUser(function(user, cb) {
+    process.nextTick(function() {
+      cb(null, { id: user.id, username: user.username, name: user.name });
+    });
+  });
+  
+  passport.deserializeUser(function(user, cb) {
+    process.nextTick(function() {
+      return cb(null, user);
+    });
+  });
+}));
+router.get('/login', function(req, res, next) {
+  res.render('login');
+});
+router.get('/login/federated/facebook', passport.authenticate('facebook'));
+router.get('/oauth2/redirect/facebook', passport.authenticate('facebook', {
+  successRedirect: '/',
+  failureRedirect: '/login'
+}));
+router.post('/logout', function(req, res, next) {
+  req.logout(function(err) {
+    if (err) { return next(err); }
+    res.redirect('/');
+    router.post('/logout', function(req, res, next) {
+      req.logout(function(err) {
+        if (err) { return next(err); }
+        res.redirect('/');
+      });
+    });
+  });
+});
+module.exports = router;
\ No newline at end of file
diff --git a/.vscode/edit.jsx b/.vscode/edit.jsx
new file mode 100644
index 0000000000..56b56fd04a
--- /dev/null
+++ b/.vscode/edit.jsx
@@ -0,0 +1,144 @@
+import { Form, useLoaderData } from "react-router-dom";
+
+export default function EditContact() {
+  const { contact } = useLoaderData();
+
+  return (
+    <Form method="post" id="contact-form">
+      <p>
+        <span>Name</span>
+        <input
+          placeholder="First"
+          aria-label="First name"
+          type="text"
+          name="first"
+          defaultValue={contact?.first}
+        />
+        <input
+          placeholder="Last"
+          aria-label="Last name"
+          type="text"
+          name="last"
+          defaultValue={contact?.last}
+        />
+      </p>
+      <label>
+        <span>Twitter</span>
+        <input
+          type="text"
+          name="twitter"
+          placeholder="@jack"
+          defaultValue={contact?.twitter}
+        />
+      </label>
+      <label>
+        <span>Avatar URL</span>
+        <input
+          placeholder="https://example.com/avatar.jpg"
+          aria-label="Avatar URL"
+          type="text"
+          name="avatar"
+          defaultValue={contact?.avatar}
+        />
+      </label>
+      <label>
+        <span>Notes</span>
+        <textarea
+          name="notes"
+          defaultValue={contact?.notes}
+          rows={6}
+        />
+      </label>
+      <p>
+        <button type="submit">Save</button>
+        <button type="button">Cancel</button>
+      </p>
+    </Form>
+  );
+}
+import {
+    Form,
+    useLoaderData,
+    redirect,
+  } from "react-router-dom";
+  import { updateContact } from "../contacts";
+  
+  export async function action({ request, params }) {
+    const formData = await request.formData();
+    const updates = Object.fromEntries(formData);
+    await updateContact(params.contactId, updates);
+    return redirect(`/contacts/${params.contactId}`);
+  }
+  
+  /* existing code */
+  /* existing code */
+import EditContact, {
+  action as editAction,
+} from "./routes/edit";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+        loader: contactLoader,
+      },
+      {
+        path: "contacts/:contactId/edit",
+        element: <EditContact />,
+        loader: contactLoader,
+        action: editAction,
+      },
+    ],
+  },
+]);
+
+/* existing code */
+<input
+  placeholder="First"
+  aria-label="First name"
+  type="text"
+  name="first"
+  defaultValue={contact.first}
+/>
+export async function action({ request, params }) {
+    const formData = await request.formData();
+    const updates = Object.fromEntries(formData);
+    await updateContact(params.contactId, updates);
+    return redirect(`/contacts/${params.contactId}`);
+  }
+  import {
+    Form,
+    useLoaderData,
+    redirect,
+    useNavigate,
+  } from "react-router-dom";
+  
+  export default function EditContact() {
+    const { contact } = useLoaderData();
+    const navigate = useNavigate();
+  
+    return (
+      <Form method="post" id="contact-form">
+        {/* existing code */}
+  
+        <p>
+          <button type="submit">Save</button>
+          <button
+            type="button"
+            onClick={() => {
+              navigate(-1);
+            }}
+          >
+            Cancel
+          </button>
+        </p>
+      </Form>
+    );
+  }
\ No newline at end of file
diff --git a/.vscode/eslint-config.js b/.vscode/eslint-config.js
new file mode 100644
index 0000000000..cee1e2c788
--- /dev/null
+++ b/.vscode/eslint-config.js
@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs['recommended-latest'],
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])
diff --git a/.vscode/index.css b/.vscode/index.css
new file mode 100644
index 0000000000..6ca85721ce
--- /dev/null
+++ b/.vscode/index.css
@@ -0,0 +1,69 @@
+:root {
+    font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+    line-height: 1.5;
+    font-weight: 400;
+  
+    color-scheme: light dark;
+    color: rgba(255, 255, 255, 0.87);
+    background-color: #242424;
+  
+    font-synthesis: none;
+    text-rendering: optimizeLegibility;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+  
+  a {
+    font-weight: 500;
+    color: #646cff;
+    text-decoration: inherit;
+  }
+  a:hover {
+    color: #535bf2;
+  }
+  
+  body {
+    margin: 0;
+    display: flex;
+    place-items: center;
+    min-width: 320px;
+    min-height: 100vh;
+  }
+  
+  h1 {
+    font-size: 3.2em;
+    line-height: 1.1;
+  }
+  
+  button {
+    border-radius: 8px;
+    border: 1px solid transparent;
+    padding: 0.6em 1.2em;
+    font-size: 1em;
+    font-weight: 500;
+    font-family: inherit;
+    background-color: #1a1a1a;
+    cursor: pointer;
+    transition: border-color 0.25s;
+  }
+  button:hover {
+    border-color: #646cff;
+  }
+  button:focus,
+  button:focus-visible {
+    outline: 4px auto -webkit-focus-ring-color;
+  }
+  
+  @media (prefers-color-scheme: light) {
+    :root {
+      color: #213547;
+      background-color: #ffffff;
+    }
+    a:hover {
+      color: #747bff;
+    }
+    button {
+      background-color: #f9f9f9;
+    }
+  }
+  
\ No newline at end of file
diff --git a/.vscode/index.jsx b/.vscode/index.jsx
new file mode 100644
index 0000000000..263d016834
--- /dev/null
+++ b/.vscode/index.jsx
@@ -0,0 +1,13 @@
+export default function Index() {
+    return (
+      <p id="zero-state">
+        This is a demo for React Router.
+        <br />
+        Check out{" "}
+        <a href="https://reactrouter.com">
+          the docs at reactrouter.com
+        </a>
+        .
+      </p>
+    );
+  }
\ No newline at end of file
diff --git a/.vscode/login.ejs b/.vscode/login.ejs
new file mode 100644
index 0000000000..200208c1aa
--- /dev/null
+++ b/.vscode/login.ejs
@@ -0,0 +1,16 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h1>Sign in</h1>
+<a class="button facebook" href="/login/federated/facebook">Sign in with Facebook</a>
\ No newline at end of file
diff --git a/.vscode/main.jsx b/.vscode/main.jsx
new file mode 100644
index 0000000000..7e0ac90660
--- /dev/null
+++ b/.vscode/main.jsx
@@ -0,0 +1,326 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom/client";
+import {
+  createBrowserRouter,
+  RouterProvider,
+} from "react-router-dom";
+import "./index.css";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <div>Hello world!</div>,
+  },
+]);
+
+ReactDOM.createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <RouterProvider router={router} />
+  </React.StrictMode>
+);
+/* existing imports */
+import Root from "./routes/root";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+  },
+]);
+
+ReactDOM.createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <RouterProvider router={router} />
+  </React.StrictMode>
+);
+import { useRouteError } from "react-router-dom";
+
+export default function ErrorPage() {
+  const error = useRouteError();
+  console.error(error);
+
+  return (
+    <div id="error-page">
+      <h1>Oops!</h1>
+      <p>Sorry, an unexpected error has occurred.</p>
+      <p>
+        <i>{error.statusText || error.message}</i>
+      </p>
+    </div>
+  );
+}
+/* existing imports */
+import Contact from "./routes/contact";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+  },
+  {
+    path: "contacts/:contactId",
+    element: <Contact />,
+  },
+]);
+
+/* existing code */
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+      },
+    ],
+  },
+]);
+/* other imports */
+import Root, { loader as rootLoader } from "./routes/root";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+      },
+    ],
+  },
+]);
+/* other imports */
+
+import Root, {
+  loader as rootLoader,
+  action as rootAction,
+} from "./routes/root";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+      },
+    ],
+  },
+]);
+/* existing code */
+import Contact, {
+  loader as contactLoader,
+} from "./routes/contact";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+        loader: contactLoader,
+      },
+    ],
+  },
+]);
+
+/* existing code */
+/* existing code */
+import EditContact from "./routes/edit";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+        loader: contactLoader,
+      },
+      {
+        path: "contacts/:contactId/edit",
+        element: <EditContact />,
+        loader: contactLoader,
+      },
+    ],
+  },
+]);
+
+/* existing code */
+/* existing code */
+import EditContact, {
+  action as editAction,
+} from "./routes/edit";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+        loader: contactLoader,
+      },
+      {
+        path: "contacts/:contactId/edit",
+        element: <EditContact />,
+        loader: contactLoader,
+        action: editAction,
+      },
+    ],
+  },
+]);
+
+/* existing code */
+/* existing code */
+import { action as destroyAction } from "./routes/destroy";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    /* existing root route props */
+    children: [
+      /* existing routes */
+      {
+        path: "contacts/:contactId/destroy",
+        action: destroyAction,
+      },
+    ],
+  },
+]);
+
+/* existing code */
+[
+  /* other routes */
+  {
+    path: "contacts/:contactId/destroy",
+    action: destroyAction,
+    errorElement: <div>Oops! There was an error.</div>,
+  },
+];
+// existing code
+import Index from "./routes/index";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      { index: true, element: <Index /> },
+      /* existing routes */
+    ],
+  },
+]);
+// existing code
+import Contact, {
+  loader as contactLoader,
+  action as contactAction,
+} from "./routes/contact";
+
+const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    errorElement: <ErrorPage />,
+    loader: rootLoader,
+    action: rootAction,
+    children: [
+      { index: true, element: <Index /> },
+      {
+        path: "contacts/:contactId",
+        element: <Contact />,
+        loader: contactLoader,
+        action: contactAction,
+      },
+      /* existing code */
+    ],
+  },
+]);
+createBrowserRouter([
+  {
+    path: "/",
+    element: <Root />,
+    loader: rootLoader,
+    action: rootAction,
+    errorElement: <ErrorPage />,
+    children: [
+      {
+        errorElement: <ErrorPage />,
+        children: [
+          { index: true, element: <Index /> },
+          {
+            path: "contacts/:contactId",
+            element: <Contact />,
+            loader: contactLoader,
+            action: contactAction,
+          },
+          /* the rest of the routes */
+        ],
+      },
+    ],
+  },
+]);
+import {
+  createRoutesFromElements,
+  createBrowserRouter,
+  Route,
+} from "react-router-dom";
+
+const router = createBrowserRouter(
+  createRoutesFromElements(
+    <Route
+      path="/"
+      element={<Root />}
+      loader={rootLoader}
+      action={rootAction}
+      errorElement={<ErrorPage />}
+    >
+      <Route errorElement={<ErrorPage />}>
+        <Route index element={<Index />} />
+        <Route
+          path="contacts/:contactId"
+          element={<Contact />}
+          loader={contactLoader}
+          action={contactAction}
+        />
+        <Route
+          path="contacts/:contactId/edit"
+          element={<EditContact />}
+          loader={contactLoader}
+          action={editAction}
+        />
+        <Route
+          path="contacts/:contactId/destroy"
+          action={destroyAction}
+        />
+      </Route>
+    </Route>
+  )
+);
+
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000..03adc8d207
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,4 @@
+{
+    "IDX.aI.enableInlineCompletion": true,
+    "IDX.aI.enableCodebaseIndexing": true
+}
\ No newline at end of file
diff --git a/.vscode/src/routes/contact.jsx b/.vscode/src/routes/contact.jsx
new file mode 100644
index 0000000000..65bd641181
--- /dev/null
+++ b/.vscode/src/routes/contact.jsx
@@ -0,0 +1,195 @@
+import { Form } from "react-router-dom";
+
+export default function Contact() {
+  const contact = {
+    first: "Your",
+    last: "Name",
+    avatar: "https://robohash.org/you.png?size=200x200",
+    twitter: "your_handle",
+    notes: "Some notes",
+    favorite: true,
+  };
+
+  return (
+    <div id="contact">
+      <div>
+        <img
+          key={contact.avatar}
+          src={
+            contact.avatar ||
+            `https://robohash.org/${contact.id}.png?size=200x200`
+          }
+        />
+      </div>
+
+      <div>
+        <h1>
+          {contact.first || contact.last ? (
+            <>
+              {contact.first} {contact.last}
+            </>
+          ) : (
+            <i>No Name</i>
+          )}{" "}
+          <Favorite contact={contact} />
+        </h1>
+
+        {contact.twitter && (
+          <p>
+            <a
+              target="_blank"
+              href={`https://twitter.com/${contact.twitter}`}
+            >
+              {contact.twitter}
+            </a>
+          </p>
+        )}
+
+        {contact.notes && <p>{contact.notes}</p>}
+
+        <div>
+          <Form action="edit">
+            <button type="submit">Edit</button>
+          </Form>
+          <Form
+            method="post"
+            action="destroy"
+            onSubmit={(event) => {
+              if (
+                !confirm(
+                  "Please confirm you want to delete this record."
+                )
+              ) {
+                event.preventDefault();
+              }
+            }}
+          >
+            <button type="submit">Delete</button>
+          </Form>
+        </div>
+      </div>
+    </div>
+  );
+}
+
+function Favorite({ contact }) {
+  const favorite = contact.favorite;
+  return (
+    <Form method="post">
+      <button
+        name="favorite"
+        value={favorite ? "false" : "true"}
+        aria-label={
+          favorite
+            ? "Remove from favorites"
+            : "Add to favorites"
+        }
+      >
+        {favorite ? "★" : "☆"}
+      </button>
+    </Form>
+  );
+}
+import { Form, useLoaderData } from "react-router-dom";
+import { getContact } from "../contacts";
+
+export async function loader({ params }) {
+  const contact = await getContact(params.contactId);
+  return { contact };
+}
+
+export default function Contact() {
+  const { contact } = useLoaderData();
+  // existing code
+}
+<Form
+  method="post"
+  action="destroy"
+  onSubmit={(event) => {
+    if (
+      !confirm(
+        "Please confirm you want to delete this record."
+      )
+    ) {
+      event.preventDefault();
+    }
+  }}
+>
+  <button type="submit">Delete</button>
+</Form>
+import {
+    useLoaderData,
+    Form,
+    useFetcher,
+  } from "react-router-dom";
+  
+  // existing code
+  
+  function Favorite({ contact }) {
+    const fetcher = useFetcher();
+    const favorite = contact.favorite;
+  
+    return (
+      <fetcher.Form method="post">
+        <button
+          name="favorite"
+          value={favorite ? "false" : "true"}
+          aria-label={
+            favorite
+              ? "Remove from favorites"
+              : "Add to favorites"
+          }
+        >
+          {favorite ? "★" : "☆"}
+        </button>
+      </fetcher.Form>
+    );
+  }
+  // existing code
+import { getContact, updateContact } from "../contacts";
+
+export async function action({ request, params }) {
+  const formData = await request.formData();
+  return updateContact(params.contactId, {
+    favorite: formData.get("favorite") === "true",
+  });
+}
+
+export default function Contact() {
+  // existing code
+}
+// existing code
+
+function Favorite({ contact }) {
+    const fetcher = useFetcher();
+  
+    const favorite = fetcher.formData
+      ? fetcher.formData.get("favorite") === "true"
+      : contact.favorite;
+  
+    return (
+      <fetcher.Form method="post">
+        <button
+          name="favorite"
+          value={favorite ? "false" : "true"}
+          aria-label={
+            favorite
+              ? "Remove from favorites"
+              : "Add to favorites"
+          }
+        >
+          {favorite ? "★" : "☆"}
+        </button>
+      </fetcher.Form>
+    );
+  }
+  export async function loader({ params }) {
+    const contact = await getContact(params.contactId);
+    if (!contact) {
+      throw new Response("", {
+        status: 404,
+        statusText: "Not Found",
+      });
+    }
+    return { contact };
+  }
\ No newline at end of file
diff --git a/.vscode/src/routes/destroy.jsx b/.vscode/src/routes/destroy.jsx
new file mode 100644
index 0000000000..39a5bad3c0
--- /dev/null
+++ b/.vscode/src/routes/destroy.jsx
@@ -0,0 +1,12 @@
+import { redirect } from "react-router-dom";
+import { deleteContact } from "../contacts";
+
+export async function action({ params }) {
+  await deleteContact(params.contactId);
+  return redirect("/");
+}
+export async function action({ params }) {
+    throw new Error("oh dang!");
+    await deleteContact(params.contactId);
+    return redirect("/");
+  }
\ No newline at end of file
diff --git a/.vscode/src/routes/edit.jsx b/.vscode/src/routes/edit.jsx
new file mode 100644
index 0000000000..ca07336c56
--- /dev/null
+++ b/.vscode/src/routes/edit.jsx
@@ -0,0 +1,86 @@
+import { Form, useLoaderData } from "react-router-dom";
+
+export default function EditContact() {
+  const { contact } = useLoaderData();
+
+  return (
+    <Form method="post" id="contact-form">
+      <p>
+        <span>Name</span>
+        <input
+          placeholder="First"
+          aria-label="First name"
+          type="text"
+          name="first"
+          defaultValue={contact?.first}
+        />
+        <input
+          placeholder="Last"
+          aria-label="Last name"
+          type="text"
+          name="last"
+          defaultValue={contact?.last}
+        />
+      </p>
+      <label>
+        <span>Twitter</span>
+        <input
+          type="text"
+          name="twitter"
+          placeholder="@jack"
+          defaultValue={contact?.twitter}
+        />
+      </label>
+      <label>
+        <span>Avatar URL</span>
+        <input
+          placeholder="https://example.com/avatar.jpg"
+          aria-label="Avatar URL"
+          type="text"
+          name="avatar"
+          defaultValue={contact?.avatar}
+        />
+      </label>
+      <label>
+        <span>Notes</span>
+        <textarea
+          name="notes"
+          defaultValue={contact?.notes}
+          rows={6}
+        />
+      </label>
+      <p>
+        <button type="submit">Save</button>
+        <button type="button">Cancel</button>
+      </p>
+    </Form>
+  );
+}
+import {
+    Form,
+    useLoaderData,
+    redirect,
+  } from "react-router-dom";
+  import { updateContact } from "../contacts";
+  
+  export async function action({ request, params }) {
+    const formData = await request.formData();
+    const updates = Object.fromEntries(formData);
+    await updateContact(params.contactId, updates);
+    return redirect(`/contacts/${params.contactId}`);
+  }
+  
+  /* existing code */
+  <input
+  placeholder="First"
+  aria-label="First name"
+  type="text"
+  name="first"
+  defaultValue={contact.first}
+/>
+export async function action({ request, params }) {
+    const formData = await request.formData();
+    const updates = Object.fromEntries(formData);
+    await updateContact(params.contactId, updates);
+    return redirect(`/contacts/${params.contactId}`);
+  }
\ No newline at end of file
diff --git a/.vscode/src/routes/error-page.jsx b/.vscode/src/routes/error-page.jsx
new file mode 100644
index 0000000000..17cb2e0c36
--- /dev/null
+++ b/.vscode/src/routes/error-page.jsx
@@ -0,0 +1,16 @@
+import { useRouteError } from "react-router-dom";
+
+export default function ErrorPage() {
+  const error = useRouteError();
+  console.error(error);
+
+  return (
+    <div id="error-page">
+      <h1>Oops!</h1>
+      <p>Sorry, an unexpected error has occurred.</p>
+      <p>
+        <i>{error.statusText || error.message}</i>
+      </p>
+    </div>
+  );
+}
\ No newline at end of file
diff --git a/.vscode/src/routes/index.jsx b/.vscode/src/routes/index.jsx
new file mode 100644
index 0000000000..263d016834
--- /dev/null
+++ b/.vscode/src/routes/index.jsx
@@ -0,0 +1,13 @@
+export default function Index() {
+    return (
+      <p id="zero-state">
+        This is a demo for React Router.
+        <br />
+        Check out{" "}
+        <a href="https://reactrouter.com">
+          the docs at reactrouter.com
+        </a>
+        .
+      </p>
+    );
+  }
\ No newline at end of file
diff --git a/.vscode/src/routes/root.jsx b/.vscode/src/routes/root.jsx
new file mode 100644
index 0000000000..6dbefd1149
--- /dev/null
+++ b/.vscode/src/routes/root.jsx
@@ -0,0 +1,440 @@
+export default function Root() {
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          <div>
+            <form id="search-form" role="search">
+              <input
+                id="q"
+                aria-label="Search contacts"
+                placeholder="Search"
+                type="search"
+                name="q"
+              />
+              <div
+                id="search-spinner"
+                aria-hidden
+                hidden={true}
+              />
+              <div
+                className="sr-only"
+                aria-live="polite"
+              ></div>
+            </form>
+            <form method="post">
+              <button type="submit">New</button>
+            </form>
+          </div>
+          <nav>
+            <ul>
+              <li>
+                <a href={`/contacts/1`}>Your Name</a>
+              </li>
+              <li>
+                <a href={`/contacts/2`}>Your Friend</a>
+              </li>
+            </ul>
+          </nav>
+        </div>
+        <div id="detail"></div>
+      </>
+    );
+  }
+  import { Outlet } from "react-router-dom";
+
+export default function Root() {
+  return (
+    <>
+      {/* all the other elements */}
+      <div id="detail">
+        <Outlet />
+      </div>
+    </>
+  );
+}
+import { Outlet, Link } from "react-router-dom";
+
+export default function Root() {
+  return (
+    <>
+      <div id="sidebar">
+        {/* other elements */}
+
+        <nav>
+          <ul>
+            <li>
+              <Link to={`contacts/1`}>Your Name</Link>
+            </li>
+            <li>
+              <Link to={`contacts/2`}>Your Friend</Link>
+            </li>
+          </ul>
+        </nav>
+
+        {/* other elements */}
+      </div>
+    </>
+  );
+}
+import { Outlet, Link } from "react-router-dom";
+import { getContacts } from "../contacts";
+
+export async function loader() {
+  const contacts = await getContacts();
+  return { contacts };
+}
+import {
+    Outlet,
+    Link,
+    useLoaderData,
+  } from "react-router-dom";
+  import { getContacts } from "../contacts";
+  
+  /* other code */
+  
+  export default function Root() {
+    const { contacts } = useLoaderData();
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          {/* other code */}
+  
+          <nav>
+            {contacts.length ? (
+              <ul>
+                {contacts.map((contact) => (
+                  <li key={contact.id}>
+                    <Link to={`contacts/${contact.id}`}>
+                      {contact.first || contact.last ? (
+                        <>
+                          {contact.first} {contact.last}
+                        </>
+                      ) : (
+                        <i>No Name</i>
+                      )}{" "}
+                      {contact.favorite && <span>★</span>}
+                    </Link>
+                  </li>
+                ))}
+              </ul>
+            ) : (
+              <p>
+                <i>No contacts</i>
+              </p>
+            )}
+          </nav>
+  
+          {/* other code */}
+        </div>
+      </>
+    );
+  }
+  import {
+    Outlet,
+    Link,
+    useLoaderData,
+  } from "react-router-dom";
+  import { getContacts } from "../contacts";
+  
+  /* other code */
+  
+  export default function Root() {
+    const { contacts } = useLoaderData();
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          {/* other code */}
+  
+          <nav>
+            {contacts.length ? (
+              <ul>
+                {contacts.map((contact) => (
+                  <li key={contact.id}>
+                    <Link to={`contacts/${contact.id}`}>
+                      {contact.first || contact.last ? (
+                        <>
+                          {contact.first} {contact.last}
+                        </>
+                      ) : (
+                        <i>No Name</i>
+                      )}{" "}
+                      {contact.favorite && <span>★</span>}
+                    </Link>
+                  </li>
+                ))}
+              </ul>
+            ) : (
+              <p>
+                <i>No contacts</i>
+              </p>
+            )}
+          </nav>
+  
+          {/* other code */}
+        </div>
+      </>
+    );
+  }
+  import {
+    Outlet,
+    Link,
+    useLoaderData,
+    Form,
+    redirect,
+  } from "react-router-dom";
+  import { getContacts, createContact } from "../contacts";
+  
+  export async function action() {
+    const contact = await createContact();
+    return redirect(`/contacts/${contact.id}/edit`);
+  }
+  import {
+    Outlet,
+    Link,
+    useLoaderData,
+    Form,
+    redirect,
+  } from "react-router-dom";
+  import { getContacts, createContact } from "../contacts";
+  
+  export async function action() {
+    const contact = await createContact();
+    return redirect(`/contacts/${contact.id}/edit`);
+  }
+  import {
+    // existing code
+    useNavigation,
+  } from "react-router-dom";
+  
+  // existing code
+  
+  export default function Root() {
+    const { contacts } = useLoaderData();
+    const navigation = useNavigation();
+  
+    return (
+      <>
+        <div id="sidebar">{/* existing code */}</div>
+        <div
+          id="detail"
+          className={
+            navigation.state === "loading" ? "loading" : ""
+          }
+        >
+          <Outlet />
+        </div>
+      </>
+    );
+  }
+  import {
+    Form,
+    useLoaderData,
+    redirect,
+    useNavigate,
+  } from "react-router-dom";
+  
+  export default function EditContact() {
+    const { contact } = useLoaderData();
+    const navigate = useNavigate();
+  
+    return (
+      <Form method="post" id="contact-form">
+        {/* existing code */}
+  
+        <p>
+          <button type="submit">Save</button>
+          <button
+            type="button"
+            onClick={() => {
+              navigate(-1);
+            }}
+          >
+            Cancel
+          </button>
+        </p>
+      </Form>
+    );
+  }
+  <Form id="search-form" role="search">
+  <input
+    id="q"
+    aria-label="Search contacts"
+    placeholder="Search"
+    type="search"
+    name="q"
+  />
+  <div id="search-spinner" aria-hidden hidden={true} />
+  <div className="sr-only" aria-live="polite"></div>
+</Form>
+export async function loader({ request }) {
+    const url = new URL(request.url);
+    const q = url.searchParams.get("q");
+    const contacts = await getContacts(q);
+    return { contacts };
+  }
+  // existing code
+
+export async function loader({ request }) {
+    const url = new URL(request.url);
+    const q = url.searchParams.get("q");
+    const contacts = await getContacts(q);
+    return { contacts, q };
+  }
+  
+  export default function Root() {
+    const { contacts, q } = useLoaderData();
+    const navigation = useNavigation();
+  
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          <div>
+            <Form id="search-form" role="search">
+              <input
+                id="q"
+                aria-label="Search contacts"
+                placeholder="Search"
+                type="search"
+                name="q"
+                defaultValue={q}
+              />
+              {/* existing code */}
+            </Form>
+            {/* existing code */}
+          </div>
+          {/* existing code */}
+        </div>
+        {/* existing code */}
+      </>
+    );
+  }
+  import { useEffect } from "react";
+
+// existing code
+
+export default function Root() {
+  const { contacts, q } = useLoaderData();
+  const navigation = useNavigation();
+
+  useEffect(() => {
+    document.getElementById("q").value = q;
+  }, [q]);
+
+  // existing code
+}
+// existing code
+import {
+    // existing code
+    useSubmit,
+  } from "react-router-dom";
+  
+  export default function Root() {
+    const { contacts, q } = useLoaderData();
+    const navigation = useNavigation();
+    const submit = useSubmit();
+  
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          <div>
+            <Form id="search-form" role="search">
+              <input
+                id="q"
+                aria-label="Search contacts"
+                placeholder="Search"
+                type="search"
+                name="q"
+                defaultValue={q}
+                onChange={(event) => {
+                  submit(event.currentTarget.form);
+                }}
+              />
+              {/* existing code */}
+            </Form>
+            {/* existing code */}
+          </div>
+          {/* existing code */}
+        </div>
+        {/* existing code */}
+      </>
+    );
+  }
+  // existing code
+
+export default function Root() {
+    const { contacts, q } = useLoaderData();
+    const navigation = useNavigation();
+    const submit = useSubmit();
+  
+    const searching =
+      navigation.location &&
+      new URLSearchParams(navigation.location.search).has(
+        "q"
+      );
+  
+    useEffect(() => {
+      document.getElementById("q").value = q;
+    }, [q]);
+  
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          <div>
+            <Form id="search-form" role="search">
+              <input
+                id="q"
+                className={searching ? "loading" : ""}
+                // existing code
+              />
+              <div
+                id="search-spinner"
+                aria-hidden
+                hidden={!searching}
+              />
+              {/* existing code */}
+            </Form>
+            {/* existing code */}
+          </div>
+          {/* existing code */}
+        </div>
+        {/* existing code */}
+      </>
+    );
+  }
+  // existing code
+
+export default function Root() {
+    // existing code
+  
+    return (
+      <>
+        <div id="sidebar">
+          <h1>React Router Contacts</h1>
+          <div>
+            <Form id="search-form" role="search">
+              <input
+                id="q"
+                // existing code
+                onChange={(event) => {
+                  const isFirstSearch = q == null;
+                  submit(event.currentTarget.form, {
+                    replace: !isFirstSearch,
+                  });
+                }}
+              />
+              {/* existing code */}
+            </Form>
+            {/* existing code */}
+          </div>
+          {/* existing code */}
+        </div>
+        {/* existing code */}
+      </>
+    );
+  }
\ No newline at end of file
diff --git a/.vscode/vite.config.js b/.vscode/vite.config.js
new file mode 100644
index 0000000000..8b0f57b91a
--- /dev/null
+++ b/.vscode/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/Form.css b/Form.css
new file mode 100644
index 0000000000..112f81a5b2
--- /dev/null
+++ b/Form.css
@@ -0,0 +1,106 @@
+/* Base styles */
+@import url("http://fonts.googleapis.com/css2?family=Poppins&display=swap");
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+    font-family: "Poppins", sans-serif;
+}
+
+body {
+    height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+fieldset {
+    padding: 20px;
+    border: 2px solid lightgrey;
+    width: 90%;
+    max-width: 500px;
+}
+
+fieldset:hover {
+    border: 2px solid grey;
+}
+
+legend {
+    font-size: 1.5rem;
+    text-align: center;
+}
+
+.search {
+    display: flex;
+    height: auto;
+    width: 100%;
+    margin: 10px 0;
+    flex-wrap: wrap;
+}
+
+.search-field {
+    height: 35px;
+    margin-right: 5px;
+    padding-left: 5px;
+    border: 2px solid lightgrey;
+    flex: 1 1 200px;
+    margin-bottom: 10px;
+}
+
+.search-field:hover {
+    border: 2px solid grey;
+}
+
+.search-field::placeholder {
+    font-size: 1rem;
+}
+
+.search-button {
+    height: 35px;
+    width: 35px;
+    font-size: 1.25rem;
+    background: none;
+    border: 2px solid lightgrey;
+}
+
+.search-button:hover {
+    border: 2px solid grey;
+}
+
+/* Responsive styles */
+@media (min-width: 320px) {
+    legend {
+        font-size: 1.2rem;
+    }
+}
+
+@media (min-width: 480px) {
+    legend {
+        font-size: 1.4rem;
+    }
+}
+
+@media (min-width: 768px) {
+    legend {
+        font-size: 1.6rem;
+    }
+    .search {
+        flex-wrap: nowrap;
+    }
+    .search-field {
+        margin-bottom: 0;
+    }
+}
+
+@media (min-width: 1024px) {
+    legend {
+        font-size: 1.8rem;
+    }
+}
+
+@media (min-width: 1600px) {
+    legend {
+        font-size: 2rem;
+    }
+}
diff --git a/README.md b/README.md
index 31466b54c2..a893de2b46 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Final Project
+npm install --save-dev @babel/preset-flown-# Final Project
 
 Replace this readme with your own information about your project.
 
@@ -10,4 +10,46 @@ Describe how you approached to problem, and what tools and techniques you used t
 
 ## View it live
 
-Every project should be deployed somewhere. Be sure to include the link to the deployed project so that the viewer can click around and see what it's all about.
\ No newline at end of file
+Every project should be deployed somewhere. Be sure to include the link to the deployed project so that the viewer can click around and see what it's all about.
+
+Final-project-Special Garden Group
+
+Legal
+@Copyright 2025 Special Garden Group. All rights resered.
+A/RES/217/(III)
+A/RES/70/1
+The Bern Convention
+WCAG
+
+Libarys
+React
+Node.js
+Express.js
+MongoDB
+React router
+API Zustand + 2 libarys (leaflet, openlayers)
+Clean code
+Accessibility Chrome, Firefox, Safari (320px-1600px)
+New React Hook
+Authentication
+Navigation using React Router
+Global state management using context API Zustand
+
+CSS
+Tailwind, Mui@materials
+
+h1-h6 styles
+Sizes cohensive colour
+The Appfuel.com/flows
+thin testing.com
+Coolors
+
+Tests
+
+
+Features
+
+Temperature
+Weather
+Garden pictures
+Forms
\ No newline at end of file
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000..034e848032
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 5.1.x   | :white_check_mark: |
+| 5.0.x   | :x:                |
+| 4.0.x   | :white_check_mark: |
+| < 4.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+
+Tell them where to go, how often they can expect to get an update on a
+reported vulnerability, what to expect if the vulnerability is accepted or
+declined, etc.
diff --git a/To b/To
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/[ b/[
new file mode 100644
index 0000000000..1de0c549e9
--- /dev/null
+++ b/[
@@ -0,0 +1 @@
+more is not installed, but available in the following packages, pick one to run it, Ctrl+C to cancel.
diff --git a/babel.config.js b/babel.config.js
new file mode 100644
index 0000000000..a50f0807c8
--- /dev/null
+++ b/babel.config.js
@@ -0,0 +1,6 @@
+module.exports = {
+    presets: [
+      ['@babel/preset-env', {targets: {node: 'current'}}],
+      '@babel/preset-typescript',
+    ],
+  };
\ No newline at end of file
diff --git a/backend/$PROFILE b/backend/$PROFILE
new file mode 100644
index 0000000000..f7069873c1
--- /dev/null
+++ b/backend/$PROFILE
@@ -0,0 +1,6 @@
+echo "function yarn { corepack yarn `$args }" >> $PROFILE
+echo "function yarnpkg { corepack yarnpkg `$args }" >> $PROFILE
+echo "function pnpm { corepack pnpm `$args }" >> $PROFILE
+echo "function pnpx { corepack pnpx `$args }" >> $PROFILE
+echo "function npm { corepack npm `$args }" >> $PROFILE
+echo "function npx { corepack npx `$args }" >> $PROFILE
\ No newline at end of file
diff --git a/backend/README.md b/backend/README.md
index d1438c9108..18b1f5394f 100644
--- a/backend/README.md
+++ b/backend/README.md
@@ -5,4 +5,17 @@ This project includes the packages and babel setup for an express server, and is
 ## Getting Started
 
 1.  Install the required dependencies using `npm install`.
-2.  Start the development server using `npm run dev`.
\ No newline at end of file
+2.  Start the development server using `npm run dev`.
+
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.
diff --git a/backend/[ b/backend/[
new file mode 100644
index 0000000000..3664692d69
--- /dev/null
+++ b/backend/[
@@ -0,0 +1 @@
+more is not installed, but available in the following packages, pick one to run it, Ctrl+C to cancel.
\ No newline at end of file
diff --git a/backend/app.js b/backend/app.js
new file mode 100644
index 0000000000..db017e7dea
--- /dev/null
+++ b/backend/app.js
@@ -0,0 +1,118 @@
+require('dotenv').config();
+
+var createError = require('http-errors');
+var express = require('express');
+var path = require('path');
+var cookieParser = require('cookie-parser');
+var logger = require('morgan');
+var session = require('express-session');
+var passport = require('passport');
+var SQLiteStore = require('connect-sqlite3')(session);
+var indexRouter = require('./routes/index');
+var authRouter = require('./routes/auth');
+
+var app = express();
+
+app.locals.pluralize = require('pluralize');
+
+// view engine setup
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', 'ejs');
+
+app.use(logger('dev'));
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(cookieParser());
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+app.use('/', indexRouter);
+app.use('/', authRouter);
+require('dotenv').config();
+
+var createError = require('http-errors');
+var express = require('express');
+var path = require('path');
+var cookieParser = require('cookie-parser');
+var logger = require('morgan');
+var session = require('express-session');
+var passport = require('passport');
+var SQLiteStore = require('connect-sqlite3')(session);
+var indexRouter = require('./routes/index');
+var authRouter = require('./routes/auth');
+
+var app = express();
+
+app.locals.pluralize = require('pluralize');
+
+// view engine setup
+app.set('views', path.join(__dirname, 'views'));
+app.set('view engine', 'ejs');
+
+app.use(logger('dev'));
+app.use(express.json());
+app.use(express.urlencoded({ extended: false }));
+app.use(cookieParser());
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+app.use('/', indexRouter);
+app.use('/', authRouter);
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+app.use(passport.authenticate('session'));
+// catch 404 and forward to error handler
+app.use(function(req, res, next) {
+  next(createError(404));
+});
+
+// error handler
+app.use(function(err, req, res, next) {
+  // set locals, only providing error in development
+  res.locals.message = err.message;
+  res.locals.error = req.app.get('env') === 'development' ? err : {};
+
+  // render the error page
+  res.status(err.status || 500);
+  res.render('error');
+});
+
+module.exports = app;
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+app.use(passport.authenticate('session'));
+// catch 404 and forward to error handler
+app.use(function(req, res, next) {
+  next(createError(404));
+});
+
+// error handler
+app.use(function(err, req, res, next) {
+  // set locals, only providing error in development
+  res.locals.message = err.message;
+  res.locals.error = req.app.get('env') === 'development' ? err : {};
+
+  // render the error page
+  res.status(err.status || 500);
+  res.render('error');
+});
+
+module.exports = app;
diff --git a/backend/babel.config.js b/backend/babel.config.js
new file mode 100644
index 0000000000..54a7981b5e
--- /dev/null
+++ b/backend/babel.config.js
@@ -0,0 +1,18 @@
+module.exports ={
+    presents: [['@babel/present-env', {targets:{node: {node 'current'}}]],
+
+},
+module.exports = api => {
+    const isTest = api.env('test');
+    // You can use isTest to determine what presets and plugins to use.
+  
+    return {
+      // ...
+    };
+  };
+  module.exports = {
+    presets: [
+      ['@babel/preset-env', {targets: {node: 'current'}}],
+      '@babel/preset-typescript',
+    ],
+  };
\ No newline at end of file
diff --git a/backend/core-js-banners b/backend/core-js-banners
new file mode 100644
index 0000000000..abd5fd4143
--- /dev/null
+++ b/backend/core-js-banners
@@ -0,0 +1 @@
+["\u001b[96mThank you for using core-js (\u001b[94m https://github.com/zloirock/core-js \u001b[96m) for polyfilling JavaScript standard library!\u001b[0m\n\n\u001b[96mThe project needs your help! Please consider supporting core-js:\u001b[0m\n\u001b[96m>\u001b[94m https://opencollective.com/core-js \u001b[0m\n\u001b[96m>\u001b[94m https://patreon.com/zloirock \u001b[0m\n\u001b[96m>\u001b[94m https://boosty.to/zloirock \u001b[0m\n\u001b[96m>\u001b[94m bitcoin: bc1qlea7544qtsmj2rayg0lthvza9fau63ux0fstcz \u001b[0m\n\n\u001b[96mI highly recommend reading this:\u001b[94m https://github.com/zloirock/core-js/blob/master/docs/2023-02-14-so-whats-next.md \u001b[96m\u001b[0m\n"]
diff --git a/backend/db.js b/backend/db.js
new file mode 100644
index 0000000000..ade0dc2a00
--- /dev/null
+++ b/backend/db.js
@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+const { Schema } = mongoose;
+
+const blogSchema = new Schema({
+  title: String, // String is shorthand for {type: String}
+  author: String,
+  body: String,
+  comments: [{ body: String, date: Date }],
+  date: { type: Date, default: Date.now },
+  hidden: Boolean,
+  meta: {
+    votes: Number,
+    favs: Number
+  }
+});
+
+const Blog = mongoose.model('Blog', blogSchema);
+
+main().catch(err => console.log(err));
+
+async function main() {
+  await mongoose.connect('mongodb://127.0.0.1:27017/test');
+  console.log("Connected to database");
+  // use `await mongoose.connect('mongodb://user:password@127.0.0.1:27017/test');` if your database has auth enabled
+}
diff --git a/backend/dfn.js b/backend/dfn.js
new file mode 100644
index 0000000000..29b453dc2f
--- /dev/null
+++ b/backend/dfn.js
@@ -0,0 +1,118 @@
+var dfnMapTarget = -1;
+var dfnMapDone = 0;
+var dfnMap = {};
+document.addEventListener('DOMContentLoaded', function (event) {
+  var links = [];
+  dfnMapTarget = document.links.length;
+  for (var i = 0; i < dfnMapTarget; i += 1)
+    links[i] = document.links[i];
+  var inc = 100;
+  for (var i = 0; i < dfnMapTarget; i += inc) {
+    setTimeout(function (j) {
+      for (var k = j; k < j+inc && k < dfnMapTarget; k += 1) {
+        if (links[k].href.indexOf('#') >= 0) {
+          if (links[k].className != "no-backref" &&
+              links[k].parentNode.className != "no-backref") {
+            var s = links[k].href.substr(links[k].href.indexOf('#') + 1);
+            if (!(s in dfnMap))
+              dfnMap[s] = [];
+            dfnMap[s].push(links[k]);
+          }
+        }
+        dfnMapDone += 1;
+      }
+    }, 0, i);
+  }
+  document.body.className += " dfnEnabled";
+}, false);
+
+var dfnPanel;
+var dfnUniqueId = 0;
+var dfnTimeout;
+document.addEventListener('click', dfnShow, false);
+function dfnShow(event) {
+  if (dfnTimeout) {
+    clearTimeout(dfnTimeout);
+    dfnTimeout = null;
+  }
+  if (dfnPanel) {
+    dfnPanel.parentNode.removeChild(dfnPanel);
+    dfnPanel = null;
+  }
+  if (dfnMapDone == dfnMapTarget) {
+    var node = event.target;
+    while (node && (node.nodeType != event.target.ELEMENT_NODE || node.tagName != "DFN"))
+      node = node.parentNode;
+    if (node) {
+      var panel = document.createElement('div');
+      panel.className = 'dfnPanel';
+      if (node.id) {
+        var permalinkP = document.createElement('p');
+        var permalinkA = document.createElement('a');
+        permalinkA.href = '#' + node.id;
+        permalinkA.textContent = '#' + node.id;
+        permalinkP.appendChild(permalinkA);
+        panel.appendChild(permalinkP);
+      }
+      var p = document.createElement('p');
+      panel.appendChild(p);
+      if (node.id in dfnMap || node.parentNode.id in dfnMap) {
+        p.textContent = 'Referenced in:';
+        var ul = document.createElement('ul');
+        var lastHeader;
+        var lastLi;
+        var n;
+        var sourceLinks = [];
+        if (node.id in dfnMap)
+          for (var i = 0; i < dfnMap[node.id].length; i += 1)
+            sourceLinks.push(dfnMap[node.id][i]);
+        if (node.parentNode.id in dfnMap)
+          for (var i = 0; i < dfnMap[node.parentNode.id].length; i += 1)
+            sourceLinks.push(dfnMap[node.parentNode.id][i]);
+        for (var i = 0; i < sourceLinks.length; i += 1) {
+          var link = sourceLinks[i];
+          var header = dfnGetCaption(link);
+          var a = document.createElement('a');
+          if (!link.id)
+            link.id = 'dfnReturnLink-' + dfnUniqueId++;
+          a.href = '#' + link.id;
+          if (header != lastHeader) {
+            lastHeader = header;
+            n = 1;
+            var li = document.createElement('li');
+            var cloneHeader = header.cloneNode(true);
+            while (cloneHeader.hasChildNodes())
+              if (cloneHeader.firstChild.className == 'section-link')
+                cloneHeader.removeChild(cloneHeader.firstChild);
+              else
+                a.appendChild(cloneHeader.firstChild);
+            lastLi = li;
+            li.appendChild(a);
+            ul.appendChild(li);
+          } else {
+            n += 1;
+            a.appendChild(document.createTextNode('(' + n + ')'));
+            lastLi.appendChild(document.createTextNode(' '));
+            lastLi.appendChild(a);
+          }
+        }
+        panel.appendChild(ul);
+      } else {
+        p.textContent = 'No references in this file.';
+      }
+      node.appendChild(panel);
+      dfnPanel = panel;
+    }
+  } else {
+    dfnTimeout = setTimeout(dfnShow, 250, event);
+  }
+}
+
+function dfnGetCaption(link) {
+  var node = link;
+  while (node && !(node.parentNode.tagName == "DIV" && node.parentNode.className == "section"))
+    node = node.parentNode;
+  while (node && (node.nodeType != node.ELEMENT_NODE || !node.tagName.match(/^H[1-6]$/)))
+    node = node.previousSibling;
+  return node;
+}
\ No newline at end of file
diff --git a/backend/hello-world.js b/backend/hello-world.js
new file mode 100644
index 0000000000..857229108d
--- /dev/null
+++ b/backend/hello-world.js
@@ -0,0 +1,14 @@
+const http = require('node:http');
+
+const hostname = '127.0.0.1';
+const port = 3000;
+
+const server = http.createServer((req, res) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/plain');
+  res.end('Hello, World!\n');
+});
+
+server.listen(port, hostname, () => {
+  console.log(`Server running at http://${hostname}:${port}/`);
+});
\ No newline at end of file
diff --git a/backend/hello.cc: b/backend/hello.cc:
new file mode 100644
index 0000000000..98fa1f05d2
--- /dev/null
+++ b/backend/hello.cc:
@@ -0,0 +1,153 @@
+// hello.cc
+#include <node.h>
+
+namespace demo {
+
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::NewStringType;
+using v8::Object;
+using v8::String;
+using v8::Value;
+
+void Method(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  args.GetReturnValue().Set(String::NewFromUtf8(
+      isolate, "world", NewStringType::kNormal).ToLocalChecked());
+}
+
+void Initialize(Local<Object> exports) {
+  NODE_SET_METHOD(exports, "hello", Method);
+}
+
+NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+
+}  // namespace demo
+void Initialize(Local<Object> exports);
+NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+using namespace v8;
+
+extern "C" NODE_MODULE_EXPORT void
+NODE_MODULE_INITIALIZER(Local<Object> exports,
+                        Local<Value> module,
+                        Local<Context> context) {
+  /* Perform addon initialization steps here. */
+}
+static void DeleteInstance(void* data) {
+  // Cast `data` to an instance of the class and delete it.
+}
+#include <node.h>
+
+using namespace v8;
+
+class AddonData {
+ public:
+  explicit AddonData(Isolate* isolate):
+      call_count(0) {
+    // Ensure this per-addon-instance data is deleted at environment cleanup.
+    node::AddEnvironmentCleanupHook(isolate, DeleteInstance, this);
+  }
+
+  // Per-addon data.
+  int call_count;
+
+  static void DeleteInstance(void* data) {
+    delete static_cast<AddonData*>(data);
+  }
+};
+
+static void Method(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  // Retrieve the per-addon-instance data.
+  AddonData* data =
+      reinterpret_cast<AddonData*>(info.Data().As<External>()->Value());
+  data->call_count++;
+  info.GetReturnValue().Set((double)data->call_count);
+}
+
+// Initialize this addon to be context-aware.
+NODE_MODULE_INIT(/* exports, module, context */) {
+  Isolate* isolate = context->GetIsolate();
+
+  // Create a new instance of `AddonData` for this instance of the addon and
+  // tie its life cycle to that of the Node.js environment.
+  AddonData* data = new AddonData(isolate);
+
+  // Wrap the data in a `v8::External` so we can pass it to the method we
+  // expose.
+  Local<External> external = External::New(isolate, data);
+
+  // Expose the method `Method` to JavaScript, and make sure it receives the
+  // per-addon-instance data we created above by passing `external` as the
+  // third parameter to the `FunctionTemplate` constructor.
+  exports->Set(context,
+               String::NewFromUtf8(isolate, "method").ToLocalChecked(),
+               FunctionTemplate::New(isolate, Method, external)
+                  ->GetFunction(context).ToLocalChecked()).FromJust();
+}
+void AddEnvironmentCleanupHook(v8::Isolate* isolate,
+                               void (*fun)(void* arg),
+                               void* arg);
+                               // addon.cc
+#include <node.h>
+#include <assert.h>
+#include <stdlib.h>
+
+using node::AddEnvironmentCleanupHook;
+using v8::HandleScope;
+using v8::Isolate;
+using v8::Local;
+using v8::Object;
+
+// Note: In a real-world application, do not rely on static/global data.
+static char cookie[] = "yum yum";
+static int cleanup_cb1_called = 0;
+static int cleanup_cb2_called = 0;
+
+static void cleanup_cb1(void* arg) {
+  Isolate* isolate = static_cast<Isolate*>(arg);
+  HandleScope scope(isolate);
+  Local<Object> obj = Object::New(isolate);
+  assert(!obj.IsEmpty());  // assert VM is still alive
+  assert(obj->IsObject());
+  cleanup_cb1_called++;
+}
+
+static void cleanup_cb2(void* arg) {
+  assert(arg == static_cast<void*>(cookie));
+  cleanup_cb2_called++;
+}
+
+static void sanity_check(void*) {
+  assert(cleanup_cb1_called == 1);
+  assert(cleanup_cb2_called == 1);
+}
+
+// Initialize this addon to be context-aware.
+NODE_MODULE_INIT(/* exports, module, context */) {
+  Isolate* isolate = context->GetIsolate();
+
+  AddEnvironmentCleanupHook(isolate, sanity_check, nullptr);
+  AddEnvironmentCleanupHook(isolate, cleanup_cb2, cookie);
+  AddEnvironmentCleanupHook(isolate, cleanup_cb1, isolate);
+}
+// test.js
+require('./build/Release/addon');
+{
+  "targets": [
+    {
+      "target_name": "addon",
+      "sources": [ "hello.cc" ]
+    }
+  ]
+}
+// hello.js
+const addon = require('./build/Release/addon');
+
+console.log(addon.hello());
+// Prints: 'world'
+try {
+  return require('./build/Release/addon.node');
+} catch (err) {
+  return require('./build/Debug/addon.node');
+}
\ No newline at end of file
diff --git a/backend/index.html b/backend/index.html
new file mode 100644
index 0000000000..0c589eccd4
--- /dev/null
+++ b/backend/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/backend/jest.config.ts b/backend/jest.config.ts
new file mode 100644
index 0000000000..cb14db5dc4
--- /dev/null
+++ b/backend/jest.config.ts
@@ -0,0 +1,201 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+import type {Config} from 'jest';
+
+const config: Config = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "mts",
+  //   "cts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.?([mc])[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).?([mc])[jt]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};
+
+export default config;
\ No newline at end of file
diff --git a/backend/package.json b/backend/package.json
index 08f29f2448..ec0d0d1af7 100644
--- a/backend/package.json
+++ b/backend/package.json
@@ -6,8 +6,8 @@
     "start": "babel-node server.js",
     "dev": "nodemon server.js --exec babel-node"
   },
-  "author": "",
-  "license": "ISC",
+  "author": "Code-lab-web",
+  "license": "(ISC OR GPL-3.0)",
   "dependencies": {
     "@babel/core": "^7.17.9",
     "@babel/node": "^7.16.8",
diff --git a/backend/section-links.js b/backend/section-links.js
new file mode 100644
index 0000000000..4c370de1f4
--- /dev/null
+++ b/backend/section-links.js
@@ -0,0 +1,22 @@
+document.addEventListener('DOMContentLoaded', function(event) {
+    function f(n) {
+      if (n.nodeType == 1 && n.tagName.match(/^H[1-6]$/)) {
+        var span = document.createElement('span');
+        span.className = 'section-link';
+        span.textContent = '\xa0';
+        var a = document.createElement('a');
+        a.href = '#' + n.parentNode.id;
+        a.textContent = '\xb6';
+        span.appendChild(a);
+        n.appendChild(span);
+      } else {
+        n = n.firstChild;
+        while (n) {
+          f(n);
+          n = n.nextSibling;
+        }
+      }
+    }
+    f(document.getElementById('sections'));
+  }, false);
+
diff --git a/backend/server.js b/backend/server.js
index 070c875189..29921db9cb 100644
--- a/backend/server.js
+++ b/backend/server.js
@@ -1,22 +1,148 @@
-import express from "express";
-import cors from "cors";
-import mongoose from "mongoose";
+import express from 'express'
+import bodyParser from 'body-parser'
+import cors from 'cors'
+import crypto from 'crypto'
+import mongoose from 'mongoose'
+import bcrypt from 'bcrypt-nodejs'
+import dotenv from 'dotenv'
 
-const mongoUrl = process.env.MONGO_URL || "mongodb://localhost/final-project";
-mongoose.connect(mongoUrl);
-mongoose.Promise = Promise;
+dotenv.config()
 
-const port = process.env.PORT || 8080;
-const app = express();
+const mongoUrl =process.env_MONGO_URL II "mongodb://localhost/auth",
+mongoose.connect(mongoUrl, { useNewUrlParser: true, useundefinedtopology: true})
+mongoose.Promise = Promise
 
-app.use(cors());
+const { Schema, model } = mongoose
+const userSchema = new Schema({
+
+const User = mongoose.model('User', {
+    name: {
+        type: String,
+        unique: true
+    },
+    password:{
+        type:String,
+        required:true
+    },
+    accessToken:{
+        type:String,
+        default: () => crypto.randomBytes(128)toString('hex')
+    }
+    });
+    const User = model("User", userSchema)
+
+    // Example
+    // POST Request
+    const request = {name: "Bob", password: "foobar};
+        // DB Entry
+        const dbEntry = {name :"Bob, password:"5abbc32983def"}
+            bcrypt.compareSync(request.password, dbEntry.password);
+    // One-way encryption
+const user = new User({name:"Bob", password:bcrypt.hashSync("foobar")});
+user.save();
+// Defines the port the app will run on. Defaults to 8080, but can be overritten when starting the server. For example:
+//
+// PORT-9000 npm start
+const port = process.env.PORT II 8080
+const app = express()
+const authenticateUser = async (req, res, next) => {
+    const user = await User.findOne({accesToken: req.header('Authorization')});
+    if(user){
+        req.user = user;
+        next();
+        {else{
+res.status(401).json({loggedOut:true});
+        }}
+    }
+}
+
+// Add middlewares to enable cors and json body parsing
+app.use(cors())
 app.use(express.json());
+app.use(bodyParser.json())
+
+// Start defining your routes here
+app.get('/', (req, res) => {
+    res.send('Hello Member')
+    app.post('/tweets' authenticateUser);
+    app.post('/tweets', async (req,res) =>{
+        // This will only happen if the next() function is called from middleware!
+        // now we can access the req.user object from the middleware
+    })
 
-app.get("/", (req, res) => {
-  res.send("Hello Technigo!");
+        }
+    })
+})
+
+// Start defining your routes here
+app.get('/,(req, res) => {
+    res.send('Hello world')
+})
+app.post('/sessions' async (req res) => {
+    const user = await User.findOne({name: req.body.name});
+    if(user && bcrypt.compareSync(req.body.password, user.password)){
+        // Success
+        res.json({userId: user._id, accessToken}};
+    }else{
+        // Failure
+        // a.User does not exist
+        // b. Encrypted password does not march
+        res.json({notFound: true});
+    }
+    }
 });
+app.post("/users", (req, res) => {
+    try {
+      const { name, email, password } = req.body
+      const salt = bcrypt.genSaltSync()
+      const user = new User({ name, email, password: bcrypt.hashSync(password, salt) })
+      user.save()
+      res.status(201).json({
+        success: true,
+        message: "User created",
+        id: user._id,
+        accessToken: user.accessToken,
+      })
+    } catch (error) {
+      res.status(400).json({
+        success: false,
+        message: "Could not create user",
+        errors: error
+      })
+    }
+  })
+
+  app.get("/secrets", authenticateUser)
+app.get("/secrets", (req, res) => {
+  res.json({
+    secret: "This is secret"
+    app.get('/secrets', (req, res) =>{
+        res.jsons({secret: 'This is a super secret message'})
+      });
+      }
+      app.post('/sessions' async (req, res) => {
+        const user = await User.findOne({email: req.body.email});
+        if (user && bcrypt.compareSync(req.body.password. user.password)){
+          res.json({userId: user_Id, assessToken: user.accessToken});
+        }else{
+          res.json({notFound: true});
+       
+// Add middlewares to enable cors and json body parsing
+app.use(cors())
+app.use(bodyParser.json())
+//Start defing your routes here
+app.get('/',(req, res) => {
+  //fetch('...,{headers:{Authorization:
+  'my secret apt key'}}}
+  res.send{process.env.API_KEY}})
+}          
+    
+
 
 // Start the server
+})
 app.listen(port, () => {
-  console.log(`Server running on http://localhost:${port}`);
-});
+    console.log('Server running on http://localhost:${port}')
+})
+    console.log(bcrypt.hashSync("foobar"));
+})
\ No newline at end of file
diff --git a/backend/string_decoder.js b/backend/string_decoder.js
new file mode 100644
index 0000000000..b774af1b40
--- /dev/null
+++ b/backend/string_decoder.js
@@ -0,0 +1,125 @@
+'use strict';
+
+const {
+  ArrayBufferIsView,
+  ObjectDefineProperties,
+  Symbol,
+  TypedArrayPrototypeSubarray,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const {
+  kIncompleteCharactersStart,
+  kIncompleteCharactersEnd,
+  kMissingBytes,
+  kBufferedBytes,
+  kEncodingField,
+  kSize,
+  decode,
+  flush,
+} = internalBinding('string_decoder');
+const {
+  encodingsMap,
+  normalizeEncoding,
+} = require('internal/util');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_THIS,
+  ERR_UNKNOWN_ENCODING,
+} = require('internal/errors').codes;
+
+const kNativeDecoder = Symbol('kNativeDecoder');
+
+/**
+ * StringDecoder provides an interface for efficiently splitting a series of
+ * buffers into a series of JS strings without breaking apart multibyte
+ * characters.
+ * @param {string} [encoding]
+ */
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  if (this.encoding === undefined) {
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+  }
+  this[kNativeDecoder] = Buffer.alloc(kSize);
+  this[kNativeDecoder][kEncodingField] = encodingsMap[this.encoding];
+}
+
+/**
+ * Returns a decoded string, omitting any incomplete multi-bytes
+ * characters at the end of the Buffer, or TypedArray, or DataView
+ * @param {string | Buffer | TypedArray | DataView} buf
+ * @returns {string}
+ * @throws {TypeError} Throws when buf is not in one of supported types
+ */
+StringDecoder.prototype.write = function write(buf) {
+  if (typeof buf === 'string')
+    return buf;
+  if (!ArrayBufferIsView(buf))
+    throw new ERR_INVALID_ARG_TYPE('buf',
+                                   ['Buffer', 'TypedArray', 'DataView'],
+                                   buf);
+  if (!this[kNativeDecoder]) {
+    throw new ERR_INVALID_THIS('StringDecoder');
+  }
+  return decode(this[kNativeDecoder], buf);
+};
+
+/**
+ * Returns any remaining input stored in the internal buffer as a string.
+ * After end() is called, the stringDecoder object can be reused for new
+ * input.
+ * @param {string | Buffer | TypedArray | DataView} [buf]
+ * @returns {string}
+ */
+StringDecoder.prototype.end = function end(buf) {
+  const ret = buf === undefined ? '' : this.write(buf);
+  if (this[kNativeDecoder][kBufferedBytes] > 0)
+    return ret + flush(this[kNativeDecoder]);
+  return ret;
+};
+
+/* Everything below this line is undocumented legacy stuff. */
+/**
+ *
+ * @param {string | Buffer | TypedArray | DataView} buf
+ * @param {number} offset
+ * @returns {string}
+ */
+StringDecoder.prototype.text = function text(buf, offset) {
+  this[kNativeDecoder][kMissingBytes] = 0;
+  this[kNativeDecoder][kBufferedBytes] = 0;
+  return this.write(buf.slice(offset));
+};
+
+ObjectDefineProperties(StringDecoder.prototype, {
+  lastChar: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return TypedArrayPrototypeSubarray(this[kNativeDecoder],
+                                         kIncompleteCharactersStart,
+                                         kIncompleteCharactersEnd);
+    },
+  },
+  lastNeed: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return this[kNativeDecoder][kMissingBytes];
+    },
+  },
+  lastTotal: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return this[kNativeDecoder][kBufferedBytes] +
+             this[kNativeDecoder][kMissingBytes];
+    },
+  },
+});
+
+exports.StringDecoder = StringDecoder;
\ No newline at end of file
diff --git a/backend/task_processor.js b/backend/task_processor.js
new file mode 100644
index 0000000000..b774af1b40
--- /dev/null
+++ b/backend/task_processor.js
@@ -0,0 +1,125 @@
+'use strict';
+
+const {
+  ArrayBufferIsView,
+  ObjectDefineProperties,
+  Symbol,
+  TypedArrayPrototypeSubarray,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const {
+  kIncompleteCharactersStart,
+  kIncompleteCharactersEnd,
+  kMissingBytes,
+  kBufferedBytes,
+  kEncodingField,
+  kSize,
+  decode,
+  flush,
+} = internalBinding('string_decoder');
+const {
+  encodingsMap,
+  normalizeEncoding,
+} = require('internal/util');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_THIS,
+  ERR_UNKNOWN_ENCODING,
+} = require('internal/errors').codes;
+
+const kNativeDecoder = Symbol('kNativeDecoder');
+
+/**
+ * StringDecoder provides an interface for efficiently splitting a series of
+ * buffers into a series of JS strings without breaking apart multibyte
+ * characters.
+ * @param {string} [encoding]
+ */
+function StringDecoder(encoding) {
+  this.encoding = normalizeEncoding(encoding);
+  if (this.encoding === undefined) {
+    throw new ERR_UNKNOWN_ENCODING(encoding);
+  }
+  this[kNativeDecoder] = Buffer.alloc(kSize);
+  this[kNativeDecoder][kEncodingField] = encodingsMap[this.encoding];
+}
+
+/**
+ * Returns a decoded string, omitting any incomplete multi-bytes
+ * characters at the end of the Buffer, or TypedArray, or DataView
+ * @param {string | Buffer | TypedArray | DataView} buf
+ * @returns {string}
+ * @throws {TypeError} Throws when buf is not in one of supported types
+ */
+StringDecoder.prototype.write = function write(buf) {
+  if (typeof buf === 'string')
+    return buf;
+  if (!ArrayBufferIsView(buf))
+    throw new ERR_INVALID_ARG_TYPE('buf',
+                                   ['Buffer', 'TypedArray', 'DataView'],
+                                   buf);
+  if (!this[kNativeDecoder]) {
+    throw new ERR_INVALID_THIS('StringDecoder');
+  }
+  return decode(this[kNativeDecoder], buf);
+};
+
+/**
+ * Returns any remaining input stored in the internal buffer as a string.
+ * After end() is called, the stringDecoder object can be reused for new
+ * input.
+ * @param {string | Buffer | TypedArray | DataView} [buf]
+ * @returns {string}
+ */
+StringDecoder.prototype.end = function end(buf) {
+  const ret = buf === undefined ? '' : this.write(buf);
+  if (this[kNativeDecoder][kBufferedBytes] > 0)
+    return ret + flush(this[kNativeDecoder]);
+  return ret;
+};
+
+/* Everything below this line is undocumented legacy stuff. */
+/**
+ *
+ * @param {string | Buffer | TypedArray | DataView} buf
+ * @param {number} offset
+ * @returns {string}
+ */
+StringDecoder.prototype.text = function text(buf, offset) {
+  this[kNativeDecoder][kMissingBytes] = 0;
+  this[kNativeDecoder][kBufferedBytes] = 0;
+  return this.write(buf.slice(offset));
+};
+
+ObjectDefineProperties(StringDecoder.prototype, {
+  lastChar: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return TypedArrayPrototypeSubarray(this[kNativeDecoder],
+                                         kIncompleteCharactersStart,
+                                         kIncompleteCharactersEnd);
+    },
+  },
+  lastNeed: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return this[kNativeDecoder][kMissingBytes];
+    },
+  },
+  lastTotal: {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get() {
+      return this[kNativeDecoder][kBufferedBytes] +
+             this[kNativeDecoder][kMissingBytes];
+    },
+  },
+});
+
+exports.StringDecoder = StringDecoder;
\ No newline at end of file
diff --git a/backend/tests.js b/backend/tests.js
new file mode 100644
index 0000000000..69fccafc69
--- /dev/null
+++ b/backend/tests.js
@@ -0,0 +1,75 @@
+'use strict';
+
+const {
+  ObjectAssign,
+  ObjectDefineProperty,
+} = primordials;
+
+const { test, suite, before, after, beforeEach, afterEach } = require('internal/test_runner/harness');
+const { run } = require('internal/test_runner/runner');
+
+module.exports = test;
+ObjectAssign(module.exports, {
+  after,
+  afterEach,
+  before,
+  beforeEach,
+  describe: suite,
+  it: test,
+  run,
+  suite,
+  test,
+});
+
+let lazyMock;
+
+ObjectDefineProperty(module.exports, 'mock', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    if (lazyMock === undefined) {
+      const { MockTracker } = require('internal/test_runner/mock/mock');
+
+      lazyMock = new MockTracker();
+    }
+
+    return lazyMock;
+  },
+});
+
+let lazySnapshot;
+
+ObjectDefineProperty(module.exports, 'snapshot', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    if (lazySnapshot === undefined) {
+      const {
+        setDefaultSnapshotSerializers,
+        setResolveSnapshotPath,
+      } = require('internal/test_runner/snapshot');
+
+      lazySnapshot = {
+        __proto__: null,
+        setDefaultSnapshotSerializers,
+        setResolveSnapshotPath,
+      };
+    }
+
+    return lazySnapshot;
+  },
+});
+
+ObjectDefineProperty(module.exports, 'assert', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    const { register } = require('internal/test_runner/assert');
+    const assert = { __proto__: null, register };
+    ObjectDefineProperty(module.exports, 'assert', assert);
+    return assert;
+  },
+});
\ No newline at end of file
diff --git a/backend/tls.js b/backend/tls.js
new file mode 100644
index 0000000000..8afaea5f0d
--- /dev/null
+++ b/backend/tls.js
@@ -0,0 +1,405 @@
+'use strict';
+
+const {
+  Array,
+  ArrayIsArray,
+  // eslint-disable-next-line no-restricted-syntax
+  ArrayPrototypePush,
+  JSONParse,
+  ObjectDefineProperty,
+  ObjectFreeze,
+  StringFromCharCode,
+} = primordials;
+
+const {
+  ERR_TLS_CERT_ALTNAME_FORMAT,
+  ERR_TLS_CERT_ALTNAME_INVALID,
+  ERR_OUT_OF_RANGE,
+  ERR_INVALID_ARG_VALUE,
+  ERR_INVALID_ARG_TYPE,
+} = require('internal/errors').codes;
+const internalUtil = require('internal/util');
+internalUtil.assertCrypto();
+const {
+  isArrayBufferView,
+  isUint8Array,
+} = require('internal/util/types');
+
+const net = require('net');
+const { getOptionValue } = require('internal/options');
+const {
+  getBundledRootCertificates,
+  getExtraCACertificates,
+  getSystemCACertificates,
+  resetRootCertStore,
+  getUserRootCertificates,
+  getSSLCiphers,
+} = internalBinding('crypto');
+const { Buffer } = require('buffer');
+const { canonicalizeIP } = internalBinding('cares_wrap');
+const _tls_common = require('_tls_common');
+const _tls_wrap = require('_tls_wrap');
+const { validateString } = require('internal/validators');
+
+// Allow {CLIENT_RENEG_LIMIT} client-initiated session renegotiations
+// every {CLIENT_RENEG_WINDOW} seconds. An error event is emitted if more
+// renegotiations are seen. The settings are applied to all remote client
+// connections.
+exports.CLIENT_RENEG_LIMIT = 3;
+exports.CLIENT_RENEG_WINDOW = 600;
+
+exports.DEFAULT_CIPHERS = getOptionValue('--tls-cipher-list');
+
+exports.DEFAULT_ECDH_CURVE = 'auto';
+
+if (getOptionValue('--tls-min-v1.0'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1';
+else if (getOptionValue('--tls-min-v1.1'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.1';
+else if (getOptionValue('--tls-min-v1.2'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.2';
+else if (getOptionValue('--tls-min-v1.3'))
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.3';
+else
+  exports.DEFAULT_MIN_VERSION = 'TLSv1.2';
+
+if (getOptionValue('--tls-max-v1.3'))
+  exports.DEFAULT_MAX_VERSION = 'TLSv1.3';
+else if (getOptionValue('--tls-max-v1.2'))
+  exports.DEFAULT_MAX_VERSION = 'TLSv1.2';
+else
+  exports.DEFAULT_MAX_VERSION = 'TLSv1.3'; // Will depend on node version.
+
+
+exports.getCiphers = internalUtil.cachedResult(
+  () => internalUtil.filterDuplicateStrings(getSSLCiphers(), true),
+);
+
+let bundledRootCertificates;
+function cacheBundledRootCertificates() {
+  bundledRootCertificates ||= ObjectFreeze(getBundledRootCertificates());
+
+  return bundledRootCertificates;
+}
+
+ObjectDefineProperty(exports, 'rootCertificates', {
+  __proto__: null,
+  configurable: false,
+  enumerable: true,
+  get: cacheBundledRootCertificates,
+});
+
+let extraCACertificates;
+function cacheExtraCACertificates() {
+  extraCACertificates ||= ObjectFreeze(getExtraCACertificates());
+
+  return extraCACertificates;
+}
+
+let systemCACertificates;
+function cacheSystemCACertificates() {
+  systemCACertificates ||= ObjectFreeze(getSystemCACertificates());
+
+  return systemCACertificates;
+}
+
+let defaultCACertificates;
+let hasResetDefaultCACertificates = false;
+
+function cacheDefaultCACertificates() {
+  if (defaultCACertificates) { return defaultCACertificates; }
+
+  if (hasResetDefaultCACertificates) {
+    defaultCACertificates = getUserRootCertificates();
+    ObjectFreeze(defaultCACertificates);
+    return defaultCACertificates;
+  }
+
+  defaultCACertificates = [];
+
+  if (!getOptionValue('--use-openssl-ca')) {
+    const bundled = cacheBundledRootCertificates();
+    for (let i = 0; i < bundled.length; ++i) {
+      ArrayPrototypePush(defaultCACertificates, bundled[i]);
+    }
+    if (getOptionValue('--use-system-ca')) {
+      const system = cacheSystemCACertificates();
+      for (let i = 0; i < system.length; ++i) {
+
+        ArrayPrototypePush(defaultCACertificates, system[i]);
+      }
+    }
+  }
+
+  if (process.env.NODE_EXTRA_CA_CERTS) {
+    const extra = cacheExtraCACertificates();
+    for (let i = 0; i < extra.length; ++i) {
+
+      ArrayPrototypePush(defaultCACertificates, extra[i]);
+    }
+  }
+
+  ObjectFreeze(defaultCACertificates);
+  return defaultCACertificates;
+}
+
+// TODO(joyeecheung): support X509Certificate output?
+function getCACertificates(type = 'default') {
+  validateString(type, 'type');
+
+  switch (type) {
+    case 'default':
+      return cacheDefaultCACertificates();
+    case 'bundled':
+      return cacheBundledRootCertificates();
+    case 'system':
+      return cacheSystemCACertificates();
+    case 'extra':
+      return cacheExtraCACertificates();
+    default:
+      throw new ERR_INVALID_ARG_VALUE('type', type);
+  }
+}
+exports.getCACertificates = getCACertificates;
+
+function setDefaultCACertificates(certs) {
+  if (!ArrayIsArray(certs)) {
+    throw new ERR_INVALID_ARG_TYPE('certs', 'Array', certs);
+  }
+
+  // Verify that all elements in the array are strings
+  for (let i = 0; i < certs.length; i++) {
+    if (typeof certs[i] !== 'string' && !isArrayBufferView(certs[i])) {
+      throw new ERR_INVALID_ARG_TYPE(
+        `certs[${i}]`, ['string', 'ArrayBufferView'], certs[i]);
+    }
+  }
+
+  resetRootCertStore(certs);
+  defaultCACertificates = undefined; // Reset the cached default certificates
+  hasResetDefaultCACertificates = true;
+}
+
+exports.setDefaultCACertificates = setDefaultCACertificates;
+
+// Convert protocols array into valid OpenSSL protocols list
+// ("\x06spdy/2\x08http/1.1\x08http/1.0")
+function convertProtocols(protocols) {
+  const lens = new Array(protocols.length);
+  const buff = Buffer.allocUnsafe(protocols.reduce((p, c, i) => {
+    const len = Buffer.byteLength(c);
+    if (len > 255) {
+      throw new ERR_OUT_OF_RANGE('The byte length of the protocol at index ' +
+        `${i} exceeds the maximum length.`, '<= 255', len, true);
+    }
+    lens[i] = len;
+    return p + 1 + len;
+  }, 0));
+
+  let offset = 0;
+  for (let i = 0, c = protocols.length; i < c; i++) {
+    buff[offset++] = lens[i];
+    buff.write(protocols[i], offset);
+    offset += lens[i];
+  }
+
+  return buff;
+}
+
+exports.convertALPNProtocols = function convertALPNProtocols(protocols, out) {
+  // If protocols is Array - translate it into buffer
+  if (ArrayIsArray(protocols)) {
+    out.ALPNProtocols = convertProtocols(protocols);
+  } else if (isUint8Array(protocols)) {
+    // Copy new buffer not to be modified by user.
+    out.ALPNProtocols = Buffer.from(protocols);
+  } else if (isArrayBufferView(protocols)) {
+    out.ALPNProtocols = Buffer.from(protocols.buffer.slice(
+      protocols.byteOffset,
+      protocols.byteOffset + protocols.byteLength,
+    ));
+  }
+};
+
+function unfqdn(host) {
+  return host.replace(/[.]$/, '');
+}
+
+// String#toLowerCase() is locale-sensitive so we use
+// a conservative version that only lowercases A-Z.
+function toLowerCase(c) {
+  return StringFromCharCode(32 + c.charCodeAt(0));
+}
+
+function splitHost(host) {
+  return unfqdn(host).replace(/[A-Z]/g, toLowerCase).split('.');
+}
+
+function check(hostParts, pattern, wildcards) {
+  // Empty strings, null, undefined, etc. never match.
+  if (!pattern)
+    return false;
+
+  const patternParts = splitHost(pattern);
+
+  if (hostParts.length !== patternParts.length)
+    return false;
+
+  // Pattern has empty components, e.g. "bad..example.com".
+  if (patternParts.includes(''))
+    return false;
+
+  // RFC 6125 allows IDNA U-labels (Unicode) in names but we have no
+  // good way to detect their encoding or normalize them so we simply
+  // reject them.  Control characters and blanks are rejected as well
+  // because nothing good can come from accepting them.
+  const isBad = (s) => /[^\u0021-\u007F]/u.test(s);
+  if (patternParts.some(isBad))
+    return false;
+
+  // Check host parts from right to left first.
+  for (let i = hostParts.length - 1; i > 0; i -= 1) {
+    if (hostParts[i] !== patternParts[i])
+      return false;
+  }
+
+  const hostSubdomain = hostParts[0];
+  const patternSubdomain = patternParts[0];
+  const patternSubdomainParts = patternSubdomain.split('*', 3);
+
+  // Short-circuit when the subdomain does not contain a wildcard.
+  // RFC 6125 does not allow wildcard substitution for components
+  // containing IDNA A-labels (Punycode) so match those verbatim.
+  if (patternSubdomainParts.length === 1 ||
+      patternSubdomain.includes('xn--'))
+    return hostSubdomain === patternSubdomain;
+
+  if (!wildcards)
+    return false;
+
+  // More than one wildcard is always wrong.
+  if (patternSubdomainParts.length > 2)
+    return false;
+
+  // *.tld wildcards are not allowed.
+  if (patternParts.length <= 2)
+    return false;
+
+  const { 0: prefix, 1: suffix } = patternSubdomainParts;
+
+  if (prefix.length + suffix.length > hostSubdomain.length)
+    return false;
+
+  if (!hostSubdomain.startsWith(prefix))
+    return false;
+
+  if (!hostSubdomain.endsWith(suffix))
+    return false;
+
+  return true;
+}
+
+// This pattern is used to determine the length of escaped sequences within
+// the subject alt names string. It allows any valid JSON string literal.
+// This MUST match the JSON specification (ECMA-404 / RFC8259) exactly.
+const jsonStringPattern =
+  // eslint-disable-next-line no-control-regex
+  /^"(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/;
+
+function splitEscapedAltNames(altNames) {
+  const result = [];
+  let currentToken = '';
+  let offset = 0;
+  while (offset !== altNames.length) {
+    const nextSep = altNames.indexOf(',', offset);
+    const nextQuote = altNames.indexOf('"', offset);
+    if (nextQuote !== -1 && (nextSep === -1 || nextQuote < nextSep)) {
+      // There is a quote character and there is no separator before the quote.
+      currentToken += altNames.substring(offset, nextQuote);
+      const match = jsonStringPattern.exec(altNames.substring(nextQuote));
+      if (!match) {
+        throw new ERR_TLS_CERT_ALTNAME_FORMAT();
+      }
+      currentToken += JSONParse(match[0]);
+      offset = nextQuote + match[0].length;
+    } else if (nextSep !== -1) {
+      // There is a separator and no quote before it.
+      currentToken += altNames.substring(offset, nextSep);
+      result.push(currentToken);
+      currentToken = '';
+      offset = nextSep + 2;
+    } else {
+      currentToken += altNames.substring(offset);
+      offset = altNames.length;
+    }
+  }
+  result.push(currentToken);
+  return result;
+}
+
+exports.checkServerIdentity = function checkServerIdentity(hostname, cert) {
+  const subject = cert.subject;
+  const altNames = cert.subjectaltname;
+  const dnsNames = [];
+  const ips = [];
+
+  hostname = '' + hostname;
+
+  if (altNames) {
+    const splitAltNames = altNames.includes('"') ?
+      splitEscapedAltNames(altNames) :
+      altNames.split(', ');
+    splitAltNames.forEach((name) => {
+      if (name.startsWith('DNS:')) {
+        dnsNames.push(name.slice(4));
+      } else if (name.startsWith('IP Address:')) {
+        ips.push(canonicalizeIP(name.slice(11)));
+      }
+    });
+  }
+
+  let valid = false;
+  let reason = 'Unknown reason';
+
+  hostname = unfqdn(hostname);  // Remove trailing dot for error messages.
+
+  if (net.isIP(hostname)) {
+    valid = ips.includes(canonicalizeIP(hostname));
+    if (!valid)
+      reason = `IP: ${hostname} is not in the cert's list: ` + ips.join(', ');
+  } else if (dnsNames.length > 0 || subject?.CN) {
+    const hostParts = splitHost(hostname);
+    const wildcard = (pattern) => check(hostParts, pattern, true);
+
+    if (dnsNames.length > 0) {
+      valid = dnsNames.some(wildcard);
+      if (!valid)
+        reason =
+          `Host: ${hostname}. is not in the cert's altnames: ${altNames}`;
+    } else {
+      // Match against Common Name only if no supported identifiers exist.
+      const cn = subject.CN;
+
+      if (ArrayIsArray(cn))
+        valid = cn.some(wildcard);
+      else if (cn)
+        valid = wildcard(cn);
+
+      if (!valid)
+        reason = `Host: ${hostname}. is not cert's CN: ${cn}`;
+    }
+  } else {
+    reason = 'Cert does not contain a DNS name';
+  }
+
+  if (!valid) {
+    return new ERR_TLS_CERT_ALTNAME_INVALID(reason, hostname, cert);
+  }
+};
+
+exports.createSecureContext = _tls_common.createSecureContext;
+exports.SecureContext = _tls_common.SecureContext;
+exports.TLSSocket = _tls_wrap.TLSSocket;
+exports.Server = _tls_wrap.Server;
+exports.createServer = _tls_wrap.createServer;
+exports.connect = _tls_wrap.connect;
diff --git a/backend/trace_events.js b/backend/trace_events.js
new file mode 100644
index 0000000000..69fccafc69
--- /dev/null
+++ b/backend/trace_events.js
@@ -0,0 +1,75 @@
+'use strict';
+
+const {
+  ObjectAssign,
+  ObjectDefineProperty,
+} = primordials;
+
+const { test, suite, before, after, beforeEach, afterEach } = require('internal/test_runner/harness');
+const { run } = require('internal/test_runner/runner');
+
+module.exports = test;
+ObjectAssign(module.exports, {
+  after,
+  afterEach,
+  before,
+  beforeEach,
+  describe: suite,
+  it: test,
+  run,
+  suite,
+  test,
+});
+
+let lazyMock;
+
+ObjectDefineProperty(module.exports, 'mock', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    if (lazyMock === undefined) {
+      const { MockTracker } = require('internal/test_runner/mock/mock');
+
+      lazyMock = new MockTracker();
+    }
+
+    return lazyMock;
+  },
+});
+
+let lazySnapshot;
+
+ObjectDefineProperty(module.exports, 'snapshot', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    if (lazySnapshot === undefined) {
+      const {
+        setDefaultSnapshotSerializers,
+        setResolveSnapshotPath,
+      } = require('internal/test_runner/snapshot');
+
+      lazySnapshot = {
+        __proto__: null,
+        setDefaultSnapshotSerializers,
+        setResolveSnapshotPath,
+      };
+    }
+
+    return lazySnapshot;
+  },
+});
+
+ObjectDefineProperty(module.exports, 'assert', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get() {
+    const { register } = require('internal/test_runner/assert');
+    const assert = { __proto__: null, register };
+    ObjectDefineProperty(module.exports, 'assert', assert);
+    return assert;
+  },
+});
\ No newline at end of file
diff --git a/backend/wasi.js b/backend/wasi.js
new file mode 100644
index 0000000000..71dbc60ac8
--- /dev/null
+++ b/backend/wasi.js
@@ -0,0 +1,176 @@
+'use strict';
+const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  FunctionPrototypeBind,
+  ObjectEntries,
+  String,
+  Symbol,
+} = primordials;
+
+const {
+  ERR_INVALID_ARG_VALUE,
+  ERR_WASI_ALREADY_STARTED,
+} = require('internal/errors').codes;
+const {
+  emitExperimentalWarning,
+  kEmptyObject,
+} = require('internal/util');
+const {
+  validateArray,
+  validateBoolean,
+  validateFunction,
+  validateInt32,
+  validateObject,
+  validateString,
+  validateUndefined,
+} = require('internal/validators');
+const kExitCode = Symbol('kExitCode');
+const kSetMemory = Symbol('kSetMemory');
+const kStarted = Symbol('kStarted');
+const kInstance = Symbol('kInstance');
+const kBindingName = Symbol('kBindingName');
+
+emitExperimentalWarning('WASI');
+
+class WASI {
+  constructor(options = kEmptyObject) {
+    validateObject(options, 'options');
+
+    let _WASI;
+    validateString(options.version, 'options.version');
+    switch (options.version) {
+      case 'unstable':
+        ({ WASI: _WASI } = internalBinding('wasi'));
+        this[kBindingName] = 'wasi_unstable';
+        break;
+      case 'preview1':
+        ({ WASI: _WASI } = internalBinding('wasi'));
+        this[kBindingName] = 'wasi_snapshot_preview1';
+        break;
+      // When adding support for additional wasi versions add case here
+      default:
+        throw new ERR_INVALID_ARG_VALUE('options.version',
+                                        options.version,
+                                        'unsupported WASI version');
+    }
+
+    if (options.args !== undefined)
+      validateArray(options.args, 'options.args');
+    const args = ArrayPrototypeMap(options.args || [], String);
+
+    const env = [];
+    if (options.env !== undefined) {
+      validateObject(options.env, 'options.env');
+      ArrayPrototypeForEach(
+        ObjectEntries(options.env),
+        ({ 0: key, 1: value }) => {
+          if (value !== undefined)
+            ArrayPrototypePush(env, `${key}=${value}`);
+        });
+    }
+
+    const preopens = [];
+    if (options.preopens !== undefined) {
+      validateObject(options.preopens, 'options.preopens');
+      ArrayPrototypeForEach(
+        ObjectEntries(options.preopens),
+        ({ 0: key, 1: value }) =>
+          ArrayPrototypePush(preopens, String(key), String(value)),
+      );
+    }
+
+    const { stdin = 0, stdout = 1, stderr = 2 } = options;
+    validateInt32(stdin, 'options.stdin', 0);
+    validateInt32(stdout, 'options.stdout', 0);
+    validateInt32(stderr, 'options.stderr', 0);
+    const stdio = [stdin, stdout, stderr];
+
+    const wrap = new _WASI(args, env, preopens, stdio);
+
+    for (const prop in wrap) {
+      wrap[prop] = FunctionPrototypeBind(wrap[prop], wrap);
+    }
+
+    let returnOnExit = true;
+    if (options.returnOnExit !== undefined) {
+      validateBoolean(options.returnOnExit, 'options.returnOnExit');
+      returnOnExit = options.returnOnExit;
+    }
+    if (returnOnExit)
+      wrap.proc_exit = FunctionPrototypeBind(wasiReturnOnProcExit, this);
+
+    this[kSetMemory] = wrap._setMemory;
+    delete wrap._setMemory;
+    this.wasiImport = wrap;
+    this[kStarted] = false;
+    this[kExitCode] = 0;
+    this[kInstance] = undefined;
+  }
+
+  finalizeBindings(instance, {
+    memory = instance?.exports?.memory,
+  } = {}) {
+    if (this[kStarted]) {
+      throw new ERR_WASI_ALREADY_STARTED();
+    }
+
+    validateObject(instance, 'instance');
+    validateObject(instance.exports, 'instance.exports');
+
+    this[kSetMemory](memory);
+
+    this[kInstance] = instance;
+    this[kStarted] = true;
+  }
+
+  // Must not export _initialize, must export _start
+  start(instance) {
+    this.finalizeBindings(instance);
+
+    const { _start, _initialize } = this[kInstance].exports;
+
+    validateFunction(_start, 'instance.exports._start');
+    validateUndefined(_initialize, 'instance.exports._initialize');
+
+    try {
+      _start();
+    } catch (err) {
+      if (err !== kExitCode) {
+        throw err;
+      }
+    }
+
+    return this[kExitCode];
+  }
+
+  // Must not export _start, may optionally export _initialize
+  initialize(instance) {
+    this.finalizeBindings(instance);
+
+    const { _start, _initialize } = this[kInstance].exports;
+
+    validateUndefined(_start, 'instance.exports._start');
+    if (_initialize !== undefined) {
+      validateFunction(_initialize, 'instance.exports._initialize');
+      _initialize();
+    }
+  }
+
+  getImportObject() {
+    return { [this[kBindingName]]: this.wasiImport };
+  }
+}
+
+module.exports = { WASI };
+
+
+function wasiReturnOnProcExit(rval) {
+  // If __wasi_proc_exit() does not terminate the process, an assertion is
+  // triggered in the wasm runtime. Node can sidestep the assertion and return
+  // an exit code by recording the exit code, and throwing a JavaScript
+  // exception that WebAssembly cannot catch.
+  this[kExitCode] = rval;
+  throw kExitCode;
+}
\ No newline at end of file
diff --git a/backend/worker_pool.js b/backend/worker_pool.js
new file mode 100644
index 0000000000..bc0e59c7d9
--- /dev/null
+++ b/backend/worker_pool.js
@@ -0,0 +1,13 @@
+const WorkerPool = require('./worker_pool.js');
+const os = require('node:os');
+
+const pool = new WorkerPool(os.availableParallelism());
+
+let finished = 0;
+for (let i = 0; i < 10; i++) {
+  pool.runTask({ a: 42, b: 100 }, (err, result) => {
+    console.log(i, err, result);
+    if (++finished === 10)
+      pool.close();
+  });
+}
\ No newline at end of file
diff --git a/core-js-banners b/core-js-banners
new file mode 100644
index 0000000000..0e7cb70d46
--- /dev/null
+++ b/core-js-banners
@@ -0,0 +1 @@
+["\u001b[96mThank you for using core-js (\u001b[94m https://github.com/zloirock/core-js \u001b[96m) for polyfilling JavaScript standard library!\u001b[0m\n\n\u001b[96mThe project needs your help! Please consider supporting core-js:\u001b[0m\n\u001b[96m>\u001b[94m https://opencollective.com/core-js \u001b[0m\n\u001b[96m>\u001b[94m https://patreon.com/zloirock \u001b[0m\n\u001b[96m>\u001b[94m https://boosty.to/zloirock \u001b[0m\n\u001b[96m>\u001b[94m bitcoin: bc1qlea7544qtsmj2rayg0lthvza9fau63ux0fstcz \u001b[0m\n\n\u001b[96mI highly recommend reading this:\u001b[94m https://github.com/zloirock/core-js/blob/master/docs/2023-02-14-so-whats-next.md \u001b[96m\u001b[0m\n"]
\ No newline at end of file
diff --git a/facebook-tutorial b/facebook-tutorial
new file mode 160000
index 0000000000..b7ea970d08
--- /dev/null
+++ b/facebook-tutorial
@@ -0,0 +1 @@
+Subproject commit b7ea970d08f6ed9ca43b0256d9a16747e2b04f47
diff --git a/frontend/components/App.css b/frontend/components/App.css
new file mode 100644
index 0000000000..85b5fc75d0
--- /dev/null
+++ b/frontend/components/App.css
@@ -0,0 +1,24 @@
+
+.img{
+    width: 100%;
+    height: 5rem;
+}
+
+/* Responsive styles */
+@media (max-width: 768px) {
+  .img {
+    height: 4rem;
+  }
+}
+
+@media (min-width: 769px) and (max-width: 1024px) {
+  .img {
+    height: 6rem;
+  }
+}
+
+@media (min-width: 1025px) {
+  .img {
+    height: 8rem;
+  }
+}
diff --git a/frontend/components/Home.jsx b/frontend/components/Home.jsx
new file mode 100644
index 0000000000..0e555f46bb
--- /dev/null
+++ b/frontend/components/Home.jsx
@@ -0,0 +1,6 @@
+import {appContentStore} from "../stores/appContentStore"
+export const Home () => {
+    const { appContent } = appContentStore()
+    return(
+        <h1>{appContent.heading}</h1>
+}
\ No newline at end of file
diff --git a/frontend/components/UserSettings.jsx b/frontend/components/UserSettings.jsx
new file mode 100644
index 0000000000..ef7fc4fc86
--- /dev/null
+++ b/frontend/components/UserSettings.jsx
@@ -0,0 +1,17 @@
+import { useUserStore } from "../stores/userstore"
+export const UserSettings = () => {
+    const { toggleLogin, } inCrementAge, setUserName} isLoggedIn, userName } = useUserStore()
+    return(
+        <div>
+            <h2>User Settings</h2>
+            <p>Logged in: {isLoggedIn ? "Yes" : "No"}</p>
+            <button onClick={toggleLogin}>Toggle Login</button>
+            <button onClick = { incrementAge }>Increment Age</button>
+            <label>
+                New User Name:
+                <input value={useName} onChange={(event) => setUserName(event.target.value)}/>
+
+            </label>
+        </div>
+    )
+}
\ No newline at end of file
diff --git a/frontend/components/Userinfo.jsx b/frontend/components/Userinfo.jsx
new file mode 100644
index 0000000000..ec7f3b54d1
--- /dev/null
+++ b/frontend/components/Userinfo.jsx
@@ -0,0 +1,11 @@
+import { useUserStore } from "../stores/userStore"
+export const UserInfo = () => {
+    const { userName, age } = useUserStore()
+
+return (
+    <div>
+}        <h2> User Profile </h2>
+        <p> User Name: {userName}></p>
+        <p> Age: {age} </p>
+    </div>
+))
diff --git a/frontend/components/accordian b/frontend/components/accordian
new file mode 100644
index 0000000000..ef72a280e8
--- /dev/null
+++ b/frontend/components/accordian
@@ -0,0 +1,67 @@
+import * as React from "react;
+import { styled } from "@mui/material/styles";
+import ArrowForwardIosSharpIcon from "@mui/icons-material/ArrowForwardIosSharp";
+import MuiAccordion from "@mui/material/Accordion";
+import MuiAccordionSummury from "@mui/materials/AccordionSummury";
+import MuiAccordionDetails from "@mui/material/AccordionDetails";
+import Typography from "@mui/material/Typography";
+
+const Accordion = styled((props => (
+    <MuiAccordion disableGutters elevation={0} square {...props} />
+))(({theme})) => ({
+    border: '1px solid ${theme.palette.divider}',
+    "&;not(:last-child)":{
+        borderBottom: 0,
+
+    },
+    "&:before":{
+        display: "none",
+    },
+}));
+const AccordionSummary = styled((props) =>(
+    <MuiAccordionSummary
+)
+    }
+    }
+})
+)))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export default function CustomizedAccordions() {
+    const [expanded, setExpanded] = React.useState("panel1");
+    const handleChange =(panel) => (event, newExpanded) => {
+        setExpanded(newExpanded ? panel : false);
+    };
+
+    return (
+        <div>
+            <Accordion
+            expanded={expanded === "panel1"}
+            onChange={handleChange("panel1")}
+
+            <AccordionSummary aria-controls="panel1d-content" id="panel1d-header">
+                <Typography>Collapsible Group Item #1</Typography>
+            </AccordionSummary>
+            <AccordionDetails>
+                <Typography></Typography>
+            </AccordionDetails>
+
+        </div>
+    )
+    }
+}
diff --git a/frontend/components/keyboardnavigation.js b/frontend/components/keyboardnavigation.js
new file mode 100644
index 0000000000..ba6123a73f
--- /dev/null
+++ b/frontend/components/keyboardnavigation.js
@@ -0,0 +1,41 @@
+// JavaScript for keyboard navigation
+Element.addEventListener('keydown', (e) => {
+    switch (e.key) {
+        case 'Enter':
+        case ' ':
+            // Activate the element
+            break;
+        case 'ArrowRight':
+        case 'ArrowDown':
+            // Move to next item
+            break;
+        case 'ArrowLeft':
+        case 'ArrowUp':
+            // Move to previous item
+            break;
+        case 'Home':
+            // Move to first item
+            break;
+        case 'End':
+            // Move to last item
+            break;
+    }
+});
+
+// Focus Management
+
+// After form submission
+submitButton.addEventListener('click', () => {
+    // Hide form
+    FormData.hidden = true;
+
+    // Show results
+    SpeechRecognitionResultList.hidden = false;
+
+    // Set focus to results
+    SpeechRecognitionResultList.setAttribute('tabindex', '-1');
+    SpeechRecognitionResultList.focus();
+
+    // Announce to screen readers
+    announcer.textContent = 'Form submitted successfully';
+});
\ No newline at end of file
diff --git a/frontend/components/main.jsx b/frontend/components/main.jsx
new file mode 100644
index 0000000000..cf065ad40e
--- /dev/null
+++ b/frontend/components/main.jsx
@@ -0,0 +1,167 @@
+import React from "react";
+import ReactDOM from "react-dom/client";
+import { App } from "../src/App.jsx";
+import "./index.css";
+
+document.addEventListener('DOMContentLoaded', () => {
+  const introSection = document.getElementById('user-info');
+  const announcer = document.getElementById('announcer');
+
+  const introContinueButton = document.getElementById('intro-continue');
+
+introContinueButton.addEventListener('click', () => {
+  introSection.hidden = true;
+  const userSection = document.getElementById('user-info-section');
+  userSection.hidden = false;
+  window.location.hash = '#user-info';
+  document.getElementById('name').focus();
+  announcer.textContent = 'Moved to user information section';
+  });
+});
+
+const userInfoForm = document.getElementById('user-info-form');
+const nameInput = document.getElementById('name');
+const emailInput = document.getElementById('email');
+const emailError = document.getElementById('email-error');
+const nameError = document.getElementById('name-error');
+let userName = '';
+
+function clearError(input, errorElement) {
+  input.removeAttribute('aria-invalid');
+  errorElement.textContent = '';
+  errorElement.hidden = true;
+}
+
+function isValidEmail(email) {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+function showError(input, errorElement, message) {
+  input.setAttribute('aria-invalid', 'true');
+  errorElement.textContent = message;
+  errorElement.hidden = false;
+}
+
+nameInput.addEventListener('input', () => {
+  if (nameInput.value.trim()) {
+      clearError(nameInput, nameError);
+  }
+});
+
+emailInput.addEventListener('input', () => {
+  if (emailInput.value.trim() && isValidEmail(emailInput.value)) {
+      clearError(emailInput, emailError);
+  }
+});
+
+userInfoForm.addEventListener('submit', (e) => {
+  e.preventDefault();
+  let isValid = true;
+
+  if (!nameInput.value.trim()) {
+      showError(nameInput, nameError, 'Please enter your name');
+      isValid = false;
+      nameInput.focus();
+  } else {
+      clearError(nameInput, nameError);
+  }
+
+  if (!emailInput.value.trim()) {
+      showError(emailInput, emailError, 'Please enter your email address');
+      isValid = false;
+      if (!nameError.textContent) {
+          emailInput.focus();
+      }
+  } else if (!isValidEmail(emailInput.value.trim())) {
+      showError(emailInput, emailError, 'Please enter a valid email address');
+      isValid = false;
+      if (!nameError.textContent) {
+          emailInput.focus();
+      }
+  } else {
+      clearError(emailInput, emailError);
+  }
+
+  if (isValid) {
+      userName = nameInput.value.trim();
+      const userInfoSection = document.getElementById('user-info-section');
+      const feedbackSection = document.getElementById('feedback-section');
+      userInfoSection.hidden = true;
+      feedbackSection.hidden = false;
+      feedbackSection.scrollIntoView({ behavior: 'smooth' });
+      document.querySelector('#feedback-form input[type="radio"]').focus();
+  }
+});
+
+const feedbackSection = document.getElementById('feedback-form');
+const resultsSection = document.getElementById('results');
+const form = document.getElementById('feedback-form');
+      const resultsContent =document.getElementById('results-content')
+  const feedbackDetails =document.querySelector('feedback-details')
+const progressFill =document.querySelector('progress-fill')
+const progressText = document.querySelector('.progress-text')
+let answeredQuestions = new Set();
+          
+function updateProgress(){
+  const totalQuestion =2;
+const answeredCount = answeredQuestions.size;
+const percentage = (answeredCount / totalQuestion) * 100;
+
+progressFill.style.width = `${percentage}%`;
+progressText.textContent = `${answeredCount} of ${totalQuestion} sections completed`;
+announcer.textContent = `${answeredCount} of ${totalQuestion} sections completed`;
+}
+form.querySelectorAll('input[type="radio"]').forEach((radio) => {
+  radio.addEventListener('change', () => {
+      const questionName = radio.name;
+      answeredQuestions.add(questionName);
+      updateProgress();
+  });
+});
+form.addEventListener('submit', (e) => {
+  e.preventDefault();
+
+  const formData = new FormData(form);
+  const userAnswers = Object.fromEntries(formData);
+
+  let feedback = `Thank you for your feedback, ${userName}`;
+  
+  const detailedFeedback =[];
+  
+if (userAnswers.navigation === 'easy') {
+  detailedFeedback.push('Navigation: You found the site easy to navigate.');
+} else if (userAnswers.navigation === 'difficult') {
+  detailedFeedback.push('Navigation: You found the site difficult to navigate.');
+}
+
+if (userAnswers.readability === 'clear') {
+  detailedFeedback.push('Readability: Content is clear and readable.');
+} else if (userAnswers.readability === 'unclear') {
+  detailedFeedback.push('Readability: Content needs improvement.');
+}
+const userAnswerValues = Object.values(userAnswers);
+let positiveResponses = 0;
+
+for (const answer of userAnswerValues) {
+  if (answer === 'easy' || answer === 'clear') {
+      positiveResponses += 1;
+  }
+}
+  const totalResponses = Object.keys(userAnswers).length;
+  const satisfactionPercentage = Math.round((positiveResponses / totalResponses) * 100);
+  feedback = `Based on your responses, you seem ${satisfactionPercentage}% satisfied with our website.`;
+  feedback += positiveResponses >= totalResponses / 2
+      ? ' Thank you for your positive feedback!'
+      : ' We will work hard to improve.';
+
+  feedbackDetails.innerHTML = detailedFeedback.map((text) => `<p>${text}</p>`).join('');
+  resultsSection.setAttribute('tabindex', '-1');
+  resultsSection.focus();
+  announcer.textContent = 'Feedback submitted. Your results are now displayed.';
+});
+
+ReactDOM.createRoot(document.getElementById("root")).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
diff --git a/frontend/components/pages/About.js b/frontend/components/pages/About.js
new file mode 100644
index 0000000000..ded220e2ca
--- /dev/null
+++ b/frontend/components/pages/About.js
@@ -0,0 +1,9 @@
+import React from 'react'
+export const About = () => {
+    return(
+        <article>
+            <h1>Special Garden Group</h1>
+            <p>...</p>
+        </article>
+    )
+}
\ No newline at end of file
diff --git a/frontend/components/pages/Accordian.js b/frontend/components/pages/Accordian.js
new file mode 100644
index 0000000000..ef72a280e8
--- /dev/null
+++ b/frontend/components/pages/Accordian.js
@@ -0,0 +1,67 @@
+import * as React from "react;
+import { styled } from "@mui/material/styles";
+import ArrowForwardIosSharpIcon from "@mui/icons-material/ArrowForwardIosSharp";
+import MuiAccordion from "@mui/material/Accordion";
+import MuiAccordionSummury from "@mui/materials/AccordionSummury";
+import MuiAccordionDetails from "@mui/material/AccordionDetails";
+import Typography from "@mui/material/Typography";
+
+const Accordion = styled((props => (
+    <MuiAccordion disableGutters elevation={0} square {...props} />
+))(({theme})) => ({
+    border: '1px solid ${theme.palette.divider}',
+    "&;not(:last-child)":{
+        borderBottom: 0,
+
+    },
+    "&:before":{
+        display: "none",
+    },
+}));
+const AccordionSummary = styled((props) =>(
+    <MuiAccordionSummary
+)
+    }
+    }
+})
+)))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export default function CustomizedAccordions() {
+    const [expanded, setExpanded] = React.useState("panel1");
+    const handleChange =(panel) => (event, newExpanded) => {
+        setExpanded(newExpanded ? panel : false);
+    };
+
+    return (
+        <div>
+            <Accordion
+            expanded={expanded === "panel1"}
+            onChange={handleChange("panel1")}
+
+            <AccordionSummary aria-controls="panel1d-content" id="panel1d-header">
+                <Typography>Collapsible Group Item #1</Typography>
+            </AccordionSummary>
+            <AccordionDetails>
+                <Typography></Typography>
+            </AccordionDetails>
+
+        </div>
+    )
+    }
+}
diff --git a/frontend/components/pages/App.css b/frontend/components/pages/App.css
new file mode 100644
index 0000000000..9e8956f152
--- /dev/null
+++ b/frontend/components/pages/App.css
@@ -0,0 +1,21 @@
+@import "tailwindcss";
+@ tailwind base:
+@ tailwind components:
+@ tailwind utilities:
+
+img{
+    width: 100%;
+    height: 5rem;
+}
+body {
+    font-family: Arial, sans-serif;
+      /* background-color: #f0f0f0; */
+  
+    background-image: url('Flower 1');
+    background-size: cover;
+    background-position: center;
+    background-repeat: no-repeat;
+    height: 100vh; /* Set the height to fill the viewport */
+    margin: 0; /* Remove default margin */
+    padding: 0; 
+  }
\ No newline at end of file
diff --git a/frontend/components/pages/App.js b/frontend/components/pages/App.js
new file mode 100644
index 0000000000..56ccc6346c
--- /dev/null
+++ b/frontend/components/pages/App.js
@@ -0,0 +1,62 @@
+import React from 'react';
+import { BrowserRouter, Routes, Route } from "react-router-dom";
+import Container from '@mui/material/Container';
+import Grid from "@mui/material/Grid";
+import Typography from '@mui/material/Typography';
+import Home from "./Home";
+import GardenCard from "./GardenCard";
+import GardenTour from './GardenTour';
+import SearchAppBar from './AppBar';
+import gardens from "./data.json";
+import './App.css';
+
+var logger = require('morgan');
+var session = require('express-session');
+
+var SQLiteStore = require('connect-sqlite3')(session);
+var indexRouter = require('./routes/index');
+var authRouter = require('./routes/auth');
+app.use('/', indexRouter);
+app.use('/', authRouter);
+app.use(express.static(path.join(__dirname, 'public')));
+app.use(session({
+  secret: 'keyboard cat',
+  resave: false,
+  saveUninitialized: false,
+  store: new SQLiteStore({ db: 'sessions.db', dir: './var/db' })
+}));
+
+function App() {
+    return (
+        <BrowserRouter>
+            <SearchAppBar />
+            <Routes>
+                <Route path="/" element={<Home />} />
+                <Route path="/:id"  element={<GardenTour />} />
+            </Routes>
+            <div className="App">
+                <Container sx={{ marginY: 5 }}>
+                    {gardens.map((garden) => (
+                        <div key={garden.id}>
+                            <Typography
+                                variant="h4"
+                                component="h2"
+                                marginTop={5}
+                                marginBottom={3}
+                            >
+                                Top {garden.name} Tours
+                            </Typography>
+                            <Grid container spacing={5}>
+                                {garden.tours.map((tour, index) => (
+                                    <GardenCard tour={tour} key={index} />
+                                ))}
+                            </Grid>
+                        </div>
+                    ))}
+                </Container>
+            </div>
+        </BrowserRouter>
+    );
+}
+
+export default App;
diff --git a/frontend/components/pages/AppBar.js b/frontend/components/pages/AppBar.js
new file mode 100644
index 0000000000..3442f8975a
--- /dev/null
+++ b/frontend/components/pages/AppBar.js
@@ -0,0 +1,91 @@
+import * as React from 'react';
+import { styled, alpha } from '@mui/material/styles';
+import AppBar from '@mui/material/AppBar';
+import Box from '@mui/material/Box';
+import Toolbar from '@mui/material/Toolbar';
+import IconButton from '@mui/material/IconButton';
+import Typography from '@mui/material/Typography';
+import InputBase from '@mui/material/InputBase';
+import MenuIcon from '@mui/icons-material/Menu';
+import SearchIcon from '@mui/icons-material/Search';
+
+const Search = styled('div')(({theme}) => ({
+    position: 'relative'
+    borderRadius: theme.shape.borderRadius,
+    backgroundColor: alpha(theme.palette.common.white, 0.25)
+},
+marginLeft: 0,
+width: '100%',
+(theme.breakpoints.up('sm']: {
+    marginLeft: theme.spacing(1),
+    width: 'auto',
+},
+}));
+const SearchIconWrapper = styled('div')(({theme})) => ({
+    padding: theme.spacing(0,2),
+    height: '100',
+    position: 'absolute',
+    ponterEvents: 'none',
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+}));
+const StyledInputBase = styled(InputBase)(({theme}) => [{
+    color: 'inherit'
+    '&. MuiInputBase-input': {
+        padding: theme.spacing(1, 1, 1, 0),
+        // vertical padding + font size from searchIcon
+        paddingLeft: 'calc(1em + ${theme.spacing(4)})',
+        transition: theme.transitions.create('width'),
+        width: '100%',
+        [theme.breakpoints.up('sm')]: {
+            width: '12ch,
+            '&:focus': {
+                width: '20ch',
+            },
+            '
+        },
+    },
+    }));
+
+    export default function SearchAppBar() {
+        return [
+            <Box sx{{ flexGrow: 1 }){
+                return[
+                    <Box sx={{ flexGrow: 1 })>
+                    <AppBar position="static">
+                        <Toolbar>
+                            <IconButton
+                            size="large"
+                            edge="start"
+                            color="inherit"
+                            aria-label="open drawer"
+                            sx={ mr: 2}}
+                            <MenuIcon />
+                            </IconButton>
+                            <Typograpphy
+                            variant="h6"
+                            noWrap
+                            components="div"
+                            sx={{ flexGrow: 1 display; { xs: 'none', sm: 'block'}}}
+                            >
+                                MUI
+                                </Typography>
+                                <Search>
+                                    <SearchIconWrapper>
+                                        <SearchIcon/>
+                                    </SearchIconWrapper>
+                                    <StyledInputBase
+                                    placeholder="Search_"
+                                    inputProps={{ 'aria-label': 'search'}}
+                                    />
+                                </Search>
+                                </Toolbar>
+                            </AppBar>
+                    </Box>
+                ]
+            }
+        ]
+    }
+})
+}
\ No newline at end of file
diff --git a/frontend/components/pages/Contact.js b/frontend/components/pages/Contact.js
new file mode 100644
index 0000000000..67e744fc5d
--- /dev/null
+++ b/frontend/components/pages/Contact.js
@@ -0,0 +1,9 @@
+import React from 'react'
+export const Contact = () => (
+    return(
+        <article>
+            <h1>Contact us</h1>
+            <p>...</p>
+        </article>
+    )
+}
\ No newline at end of file
diff --git a/frontend/components/pages/DatePicker.js b/frontend/components/pages/DatePicker.js
new file mode 100644
index 0000000000..06b724e4eb
--- /dev/null
+++ b/frontend/components/pages/DatePicker.js
@@ -0,0 +1,34 @@
+import * as React from "react";
+import TextField from "@mui/material/TextField";
+import StaticDateRangePicker from "@mui/lab/AdapterDateFns";
+import LocalizationProvider from "@mui/lab/LocalizationProvider";
+import Box from "@mui/material/Box";
+
+export default function StaticDateRangePickerDemo() {
+    
+
+}
+
+
+
+
+
+
+
+const [value, setValue] = React.useState([null, null]);
+
+return(
+    <LocalizationProvider dateAdapter
+
+    displayStaticWrapperAs="desktop"
+    value={value}
+    onChange=(newValue);
+}}
+renderInput={(startProps, endProps) => (
+    <React.Fragment>
+        <TextField {...startProps} />
+        <Box sx={{ mx:2}}> to </Box>
+        <TextField {...endProps} />
+    </React.Fragment>
+)}
+</LocalizationProvider>
\ No newline at end of file
diff --git a/frontend/components/pages/GardenCard.js b/frontend/components/pages/GardenCard.js
new file mode 100644
index 0000000000..ceee356eab
--- /dev/null
+++ b/frontend/components/pages/GardenCard.js
@@ -0,0 +1,89 @@
+import AppBar from '@mui/material/AppBar';
+import Paper from '@mui/material/Paper';
+import { Box } from '@mui/material';
+import Grid from "@mui/material/Grid";
+import Typography from '@mui/material/Typography';
+import hoistNonReactStatics from 'styled-components/dist/utils/hoist';
+import { HouseRounded } from '@mui/icons-material';
+import { AccessTime } from "@mui/icons-material"
+import Rating from '@mui/material/Rating';
+import { createTheme , ThemeProvider } from "@mui/material"
+import Paper from '@mui/material/Paper';
+import { Box } from '@mui/material';
+import Grid from "@mui/material/Grid";
+import Typography from '@mui/material/Typography';
+import { AccessTime } from "@mui/icons-material";
+import Rating from '@mui/material/Rating';
+import { createTheme, ThemeProvider } from "@mui/material";
+
+const theme = createTheme({
+    components: {
+        MuiTypography: {
+            variants: [
+                {
+                    props: {
+                        variant: "body2",
+                    },
+                    style: {
+                        fontSize: 11,
+                        backgroundColor:"blue"
+                    },
+                },
+                {
+                    props: {
+                        variant: "body3",
+                    },
+                    style: {
+                        fontSize: 9,
+                    },
+                },
+            ],
+        },
+    },
+});
+
+const GardenCard = ({tour}) => {
+    return (
+        <Grid item xs={3}>
+        <ThemeProvider theme={theme}>
+            <Paper elevation={3}>
+                <img src="Flower1.jpg" alt="Flower" className="img" />
+                <Box paddingX={1}>
+                    <Typography variant="subtitle1" component="h2">
+                        Desert
+                    </Typography>
+                    <Box
+                        sx={{
+                            display: "flex",
+                            alignItems: "center",
+                        }}
+                        marginTop={3}
+                    >
+                        <AccessTime sx={{ width: 12.5 }} />
+                        <Typography variant="body2" component="p" marginLeft={0.5}>
+                        {gardentour.duration} hours
+                        <Rating
+                            name="read-only"
+                            value={tour.rating}
+                            readOnly
+                            precision={0.5}
+                            size="small"
+                        />
+                        <Typography variant="body2" component="p" marginLeft={0.5}>
+                            4.5
+                        </Typography>
+                        <Typography variant="body3" component="p" marginLeft={1.5}>
+                            (655 reviews)
+                        </Typography>
+                    </Box>
+                </Box>
+                <Typography variant="h6" component="h3" sx={{ marginTop: 1.5 }}>
+                    Welcome
+                </Typography>
+                </Themeprovider>
+            </Paper>
+            </Grid>
+        );
+    }
+
+export default GardenCard;
\ No newline at end of file
diff --git a/frontend/components/pages/GardenTour.js b/frontend/components/pages/GardenTour.js
new file mode 100644
index 0000000000..89ca21bd00
--- /dev/null
+++ b/frontend/components/pages/GardenTour.js
@@ -0,0 +1,39 @@
+import { Typography } from "@mui/material";
+import Container from "@mui/material/Container";
+import Box from "@mui/material/Box";
+import ImageCollage from "../components/ImageCollage";
+import CustomizedAccordions from "../components/Accordian";
+import Paper from "@mui/material/Paper"
+import BottomNavigation from "@mui/material/BottomNavigation"
+
+const Tour = () => <Container sx={{ width: 900 }}>hello</Container>;
+const Tour = () => (
+  <><Container sx={{ width: 900 }}>
+        <Typography variant="h3" component="h1" marginTop={3}>
+            Explore gardens
+            <Box marginTop={3} sx={{ display: "flex" }}>
+                <img src="Flower 3.png" alt="" width={325} />
+                <ImageCollage />
+            </Box>
+            <Box>
+                <Typography variant="h4" component="h1" marginTop={3}>
+                    Explore the World Gardens in Stockholm
+                </Typography>
+                <Typography variant="body1" component="p" marginTop={3}>
+                    About this garden tour (Lourem 40)
+                </Typography>
+            </Box>
+        </Box>
+    </Container><Box>
+            <Box marginBottom={10}></Box>
+            <Box>
+                <Box marginBottom={10}></Box>
+                <Typography variant="h6" component="h4" marginTop={3} marginBottom={2}>
+                    Frequently Asked Questions
+                </Typography>
+                <CustomizedAccordions />
+            </Box>
+            <Paper sx={{ position: "fixed", bottom: 0, left: 0, right: 0 }} elevation={3}>
+                <BottomNavigation showLabels />
+            </Paper>
+            export default GardenTour;export default Tour;</></>
\ No newline at end of file
diff --git a/frontend/components/pages/Home.js b/frontend/components/pages/Home.js
new file mode 100644
index 0000000000..91f8d3f892
--- /dev/null
+++ b/frontend/components/pages/Home.js
@@ -0,0 +1,25 @@
+const Home = () => (
+    <div className="App">
+        <SearchAppBar />
+        <Container sx={{ marginY: 5}}>
+            {MediaCapabilities.map((city) => (
+                <>
+                <Typography
+                variant="h4"
+                component="h2"
+                marginTop={5}
+                marginBottom={3}
+                >
+                    Top {city.name} Tours
+                    </Typography>
+                    <Grid container spacing={5}>
+                        {CanvasGradient.tours.map((tour, index) => {
+                            <GardenCard tour={tour} key={index} />
+                        ))}
+                        </Grid>
+                        }}
+                    </Grid>
+            ))}
+        </Container>
+    </div>
+)
diff --git a/frontend/components/pages/ImageCollage.js b/frontend/components/pages/ImageCollage.js
new file mode 100644
index 0000000000..0027292a49
--- /dev/null
+++ b/frontend/components/pages/ImageCollage.js
@@ -0,0 +1,2 @@
+const ImageCollage = () => <div></div>
+export default ImageCollage;
\ No newline at end of file
diff --git a/frontend/components/pages/LoginForm.jsx b/frontend/components/pages/LoginForm.jsx
new file mode 100644
index 0000000000..a406baa00f
--- /dev/null
+++ b/frontend/components/pages/LoginForm.jsx
@@ -0,0 +1,61 @@
+import { useState } from "react";
+
+const LoginForm = () => {
+  const [formData, setFormData] = useState({
+    email: "",
+    password: "",
+  });
+
+  const [error, setError] = useState("");
+
+  const handleSubmit = (e) => {
+    e.preventDefault();
+
+    if (!formData.email || !formData.password) {
+      setError("Please fill in both fields");
+      return;
+    }
+
+    setError("");
+
+    fetch("http://localhost:8080/users/login", {
+      method: "POST",
+      body: JSON.stringify({ email: formData.email, password: formData.password }),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    })
+      .then(() => {
+        // Reset form
+        e.target.reset()
+      })
+      .catch(error => {
+        console.log(error)
+      })
+
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <h1>LOG IN</h1>
+      {error && <div style={{ color: "red" }}>{error}</div>}
+      <label htmlFor="email">Email</label>
+      <input
+        onChange={(e) => setFormData({ ...formData, email: e.target.value })}
+        type="email"
+        name="email"
+        value={formData.email}
+      />
+      <label htmlFor="password">Password</label>
+      <input
+        onChange={(e) => setFormData({ ...formData, password: e.target.value })}
+        type="password"
+        name="password"
+        value={formData.password}
+      />
+      <button type="submit">Log In</button>
+    </form>
+  );
+};
+
+export default LoginForm;
\ No newline at end of file
diff --git a/frontend/components/pages/Modal.js b/frontend/components/pages/Modal.js
new file mode 100644
index 0000000000..27f5fda1da
--- /dev/null
+++ b/frontend/components/pages/Modal.js
@@ -0,0 +1,23 @@
+import * as React from "react";
+import Box from "@mui/material/Box;
+import Button from "@mui/material/Button";
+import Typography from "@mui/material/Modal";
+import Modal from "@mui/material/Modal";
+
+const style = {
+    poition: "absolute,
+    top: "50%"
+    left: "50%",
+    transform: "translate(-50%, -50%)",
+    width: 400,
+    bgcolor: "backgroound.paper",
+    border: "2px solid #000",
+    boxShadow: 24,
+    p: 4,
+};
+export default function BasicModal() {
+    const [open, setOpen] = React.useState(false);
+    const handleOpen = () => setOpen(true);
+    const handleClose = () => setOpen(false); 
+}
+}
\ No newline at end of file
diff --git a/frontend/components/pages/Nav.js b/frontend/components/pages/Nav.js
new file mode 100644
index 0000000000..3b1be5d2df
--- /dev/null
+++ b/frontend/components/pages/Nav.js
@@ -0,0 +1,19 @@
+import 'react' from 'react'
+import {Link, Navlink,} from 'react-router-dom'
+export const Nav = () => {
+    return(
+<nav>
+    <h1>
+    <Link to="/">/Link>Special Garden Group</link>
+    </h1>
+    <ul>
+        <li>
+        <NavLink to="/about"></About>"></NavLink>
+        </li>
+        <<li><
+        <NavLink to ="/contact">Contact</NavLinkLink>
+        </li<
+    </ul>
+</nav>
+)
+}
\ No newline at end of file
diff --git a/frontend/components/pages/SideBar.js b/frontend/components/pages/SideBar.js
new file mode 100644
index 0000000000..6d50b0b161
--- /dev/null
+++ b/frontend/components/pages/SideBar.js
@@ -0,0 +1,37 @@
+import { BsPlus, BsFillLIghtningFill, BsGearFill } from react-icons/fa';
+import { FaFire, FaPoo} from 'react-icons/fa';
+const SideBar = () => {
+    return {
+        <div className="fixed top-0 left-0 h-screen w-16 m-0">
+        flex flex-col">
+        bg-gray-900 text-white shadow-lg">
+        <i>A</i>
+        <i>B</i>
+        <i>C</i>
+        <i<D</i>
+        <i>E</i>
+<SideBarIcon icon ={<FaFire size = "28"/} />
+<SideBarIcon = {<BsPlus size = "32"/>}}
+<SideBarIcon = <BsFillLightningFillsize="20"/}/>
+<SideBarIcon = <FaPoo size = "20" />}/>
+        </div>
+    };
+};
+const SideBarIcon = ({icon,text='tooltip'})=> ();
+<div className = "sidebar-icon group">
+{icon}
+<span class = "sidebar-tooltip group-hover:scale-100">
+    {text}
+</span>
+</div>
+};
+
+constSideBar =()=> {
+    return(
+        <div className= "fixed" top-0 left-0h-screen w-16 m-0
+        flex flex-col
+        bg-gray-100 text-gray-900
+        dark:bg-gray-900 dark:text-white></div>
+    )
+}
+export default SideBar
\ No newline at end of file
diff --git a/frontend/components/pages/SignupForm.jsx b/frontend/components/pages/SignupForm.jsx
new file mode 100644
index 0000000000..8be5785b8d
--- /dev/null
+++ b/frontend/components/pages/SignupForm.jsx
@@ -0,0 +1,52 @@
+import { useState } from "react";
+
+const SignupForm = () => {
+  const [formData, setFormData] = useState({
+    email: "",
+    password: "",
+  });
+
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    console.log(formData);
+
+    fetch("http://localhost:8080/users", {
+      method: "POST",
+      body: JSON.stringify({ email: formData.email, password: formData.password }),
+      headers: {
+        "Content-Type": "application/json"
+      }
+    })
+      .then(() => {
+        // Reset form
+        e.target.reset()
+      })
+      .catch(error => {
+        console.log(error)
+      })
+
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <h1>SIGN UP</h1>
+      <label htmlFor="email">Email</label>
+      <input
+        onChange={(e) => setFormData({ ...formData, email: e.target.value })}
+        type="email"
+        name="email"
+      />
+
+      <label htmlFor="password">Password</label>
+      <input
+        onChange={(e) => setFormData({ ...formData, password: e.target.value })}
+        type="password"
+        name="password"
+      />
+
+      <button type="submit">Sign up</button>
+    </form>
+  );
+};
+
+export default SignupForm;
\ No newline at end of file
diff --git a/frontend/components/pages/Welcome.js b/frontend/components/pages/Welcome.js
new file mode 100644
index 0000000000..eb94813300
--- /dev/null
+++ b/frontend/components/pages/Welcome.js
@@ -0,0 +1,9 @@
+import React from 'react'
+export const Welcome = () => {
+    return (
+        <article>
+            <h1>Welcome to Special Garden Group</h1>
+            <p>...</p>
+        </article>
+    )
+}
\ No newline at end of file
diff --git a/frontend/components/pages/data.json b/frontend/components/pages/data.json
new file mode 100644
index 0000000000..6bc7442f46
--- /dev/null
+++ b/frontend/components/pages/data.json
@@ -0,0 +1,38 @@
+[
+[
+    {
+        "id": 1,
+        "name": "Garden desert",
+        "garden": {
+            "id": 1,
+            "name": "Desert-style garden",
+            "description": "A garden that features desert plants and minimal water usage",
+            "image": "Flower 1.png",
+            "duration": 5,
+            "numberOfReviews": 462,
+            "price": null,
+            "rating": 4.5
+        }
+    },
+    {
+        "id": 2,
+        "name": "Rose garden",
+        "description": "A beautiful garden filled with various types of roses",
+        "image": "Flower 2.png",
+        "duration": 3,
+        "numberOfReviews": 320,
+        "price": null,
+        "rating": 4.8
+    },
+    {
+        "id": 3,
+        "name": "Japanese garden",
+        "description": "A Japanese garden with traditional elements",
+        "image": "Flower 3.png",
+        "duration": 4,
+        "numberOfReviews": 210,
+        "price": null,
+        "rating": 4.8
+    }
+]
+]
\ No newline at end of file
diff --git a/frontend/components/pages/index.css b/frontend/components/pages/index.css
new file mode 100644
index 0000000000..9306eb2664
--- /dev/null
+++ b/frontend/components/pages/index.css
@@ -0,0 +1,497 @@
+
+@import "tailwindcss";
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* Base styles */
+body {
+  margin: 0;
+  font-family: 'Courier New', Courier, monospace;
+}
+
+#root {
+  display: flex;
+  height: 100%;
+  width: 100%;
+}
+
+#sidebar {
+  width: 22rem;
+  background-color: #f7f7f7;
+  border-right: solid 1px #e3e3e3;
+  display: flex;
+  flex-direction: column;
+}
+
+#detail {
+  flex: 1;
+  padding: 2rem 4rem;
+  width: 100%;
+}
+
+/* other styles from the original file have been omitted for brevity */
+
+/* Responsive styles */
+@media (max-width: 768px) {
+  #root {
+    flex-direction: column;
+  }
+
+  #sidebar {
+    width: 100%;
+    border-right: none;
+  }
+
+  #detail {
+    padding: 1rem;
+  }
+}
+
+@media (min-width: 769px) {
+  #root {
+    flex-direction: row;
+  }
+
+  #sidebar {
+    width: 22rem;
+    border-right: solid 1px #e3e3e3;
+  }
+}
+
+@layer components{
+    @ apply relative flex items-center justify-center
+} h-12 w-12 mt-2 mb-2 mx-auto;
+bg-gray-800 text-green-500
+hover; bg -green-600; hover:text-white;
+}
+rounded-3xl hover:rounded-xl;
+transition-allduration -300 ease-linear;
+cursor-pointer;
+
+.sidebar-tooltip {
+    @absolute w-auto p-2 m-2 min-w max left-14
+    rounded-md shadow-md
+    text-white bg-gray-900
+    text-xs font-bold
+    transition-all duration-100 scale-0 orgin-left}
+  
+    body{
+        margin:0;
+        font-family:'Courier New', Courier, monospace
+        main{
+            margin: 20px;
+            {
+                ul{
+                    padding: 0:
+                    margin: 0;
+                    list-style-type: none;
+                    {
+                        li{
+                            display: inline-block;
+                            margin-left: 10px;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+nav {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+a{
+    color: blue;
+    text-decoration: none:
+    article{
+        border: 1px solid red
+        margin-button 10px;
+        padding: 10px;
+    }
+    a.active{
+        text-decoration: underline;
+    }
+    html {
+        box-sizing: border-box;
+      }
+      *,
+      *:before,
+      *:after {
+        box-sizing: inherit;
+      }
+      
+      body {
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen",
+          "Ubuntu", "Cantarell", "Fira Sans", "Droid Sans", "Helvetica Neue",
+          sans-serif;
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+      }
+      
+      code {
+        font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New",
+          monospace;
+      }
+      
+      html,
+      body {
+        height: 100%;
+        margin: 0;
+        line-height: 1.5;
+        color: #121212;
+      }
+      textarea,
+      input,
+      button {
+        font-size: 1rem;
+        font-family: inherit;
+        border: none;
+        border-radius: 8px;
+        padding: 0.5rem 0.75rem;
+        box-shadow: 0 0px 1px hsla(0, 0%, 0%, 0.2), 0 1px 2px hsla(0, 0%, 0%, 0.2);
+        background-color: white;
+        line-height: 1.5;
+        margin: 0;
+      }
+      button {
+        color: #3992ff;
+        font-weight: 500;
+      }
+      
+      textarea:hover,
+      input:hover,
+      button:hover {
+        box-shadow: 0 0px 1px hsla(0, 0%, 0%, 0.6), 0 1px 2px hsla(0, 0%, 0%, 0.2);
+      }
+      
+      button:active {
+        box-shadow: 0 0px 1px hsla(0, 0%, 0%, 0.4);
+        transform: translateY(1px);
+      }
+      
+      #contact h1 {
+        display: flex;
+        align-items: flex-start;
+        gap: 1rem;
+      }
+      #contact h1 form {
+        display: flex;
+        align-items: center;
+        margin-top: 0.25rem;
+      }
+      #contact h1 form button {
+        box-shadow: none;
+        font-size: 1.5rem;
+        font-weight: 400;
+        padding: 0;
+      }
+      #contact h1 form button[value="true"] {
+        color: #a4a4a4;
+      }
+      #contact h1 form button[value="true"]:hover,
+      #contact h1 form button[value="false"] {
+        color: #eeb004;
+      }
+      
+      form[action$="destroy"] button {
+        color: #f44250;
+      }
+      
+      .sr-only {
+        position: absolute;
+        width: 1px;
+        height: 1px;
+        padding: 0;
+        margin: -1px;
+        overflow: hidden;
+        clip: rect(0, 0, 0, 0);
+        white-space: nowrap;
+        border-width: 0;
+      }
+      
+      #root {
+        display: flex;
+        height: 100%;
+        width: 100%;
+      }
+      
+      #sidebar {
+        width: 22rem;
+        background-color: #f7f7f7;
+        border-right: solid 1px #e3e3e3;
+        display: flex;
+        flex-direction: column;
+      }
+      
+      #sidebar > * {
+        padding-left: 2rem;
+        padding-right: 2rem;
+      }
+      
+      #sidebar h1 {
+        font-size: 1rem;
+        font-weight: 500;
+        display: flex;
+        align-items: center;
+        margin: 0;
+        padding: 1rem 2rem;
+        border-top: 1px solid #e3e3e3;
+        order: 1;
+        line-height: 1;
+      }
+      
+      #sidebar h1::before {
+        content: url("data:image/svg+xml,%3Csvg width='25' height='18' viewBox='0 0 25 18' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M19.4127 6.4904C18.6984 6.26581 18.3295 6.34153 17.5802 6.25965C16.4219 6.13331 15.9604 5.68062 15.7646 4.51554C15.6551 3.86516 15.7844 2.9129 15.5048 2.32334C14.9699 1.19921 13.7183 0.695046 12.461 0.982805C11.3994 1.22611 10.516 2.28708 10.4671 3.37612C10.4112 4.61957 11.1197 5.68054 12.3363 6.04667C12.9143 6.22097 13.5284 6.3087 14.132 6.35315C15.2391 6.43386 15.3241 7.04923 15.6236 7.55574C15.8124 7.87508 15.9954 8.18975 15.9954 9.14193C15.9954 10.0941 15.8112 10.4088 15.6236 10.7281C15.3241 11.2334 14.9547 11.5645 13.8477 11.6464C13.244 11.6908 12.6288 11.7786 12.0519 11.9528C10.8353 12.3201 10.1268 13.3799 10.1828 14.6234C10.2317 15.7124 11.115 16.7734 12.1766 17.0167C13.434 17.3056 14.6855 16.8003 15.2204 15.6762C15.5013 15.0866 15.6551 14.4187 15.7646 13.7683C15.9616 12.6032 16.423 12.1505 17.5802 12.0242C18.3295 11.9423 19.1049 12.0242 19.8071 11.6253C20.5491 11.0832 21.212 10.2696 21.212 9.14192C21.212 8.01428 20.4976 6.83197 19.4127 6.4904Z' fill='%23F44250'/%3E%3Cpath d='M7.59953 11.7459C6.12615 11.7459 4.92432 10.5547 4.92432 9.09441C4.92432 7.63407 6.12615 6.44287 7.59953 6.44287C9.0729 6.44287 10.2747 7.63407 10.2747 9.09441C10.2747 10.5536 9.07172 11.7459 7.59953 11.7459Z' fill='black'/%3E%3Cpath d='M2.64217 17.0965C1.18419 17.093 -0.0034949 15.8971 7.72743e-06 14.4356C0.00352588 12.9765 1.1994 11.7888 2.66089 11.7935C4.12004 11.797 5.30772 12.9929 5.30306 14.4544C5.29953 15.9123 4.10366 17.1 2.64217 17.0965Z' fill='black'/%3E%3Cpath d='M22.3677 17.0965C20.9051 17.1046 19.7046 15.9217 19.6963 14.4649C19.6882 13.0023 20.8712 11.8017 22.3279 11.7935C23.7906 11.7854 24.9911 12.9683 24.9993 14.4251C25.0075 15.8866 23.8245 17.0883 22.3677 17.0965Z' fill='black'/%3E%3C/svg%3E%0A");
+        margin-right: 0.5rem;
+        position: relative;
+        top: 1px;
+      }
+      
+      #sidebar > div {
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        padding-top: 1rem;
+        padding-bottom: 1rem;
+        border-bottom: 1px solid #e3e3e3;
+      }
+      
+      #sidebar > div form {
+        position: relative;
+      }
+      
+      #sidebar > div form input[type="search"] {
+        width: 100%;
+        padding-left: 2rem;
+        background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' class='h-6 w-6' fill='none' viewBox='0 0 24 24' stroke='%23999' stroke-width='2'%3E%3Cpath stroke-linecap='round' stroke-linejoin='round' d='M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z' /%3E%3C/svg%3E");
+        background-repeat: no-repeat;
+        background-position: 0.625rem 0.75rem;
+        background-size: 1rem;
+        position: relative;
+      }
+      
+      #sidebar > div form input[type="search"].loading {
+        background-image: none;
+      }
+      
+      #search-spinner {
+        width: 1rem;
+        height: 1rem;
+        background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' fill='none' viewBox='0 0 24 24'%3E%3Cpath stroke='%23000' strokeLinecap='round' strokeLinejoin='round' strokeWidth='2' d='M20 4v5h-.582m0 0a8.001 8.001 0 00-15.356 2m15.356-2H15M4 20v-5h.581m0 0a8.003 8.003 0 0015.357-2M4.581 15H9' /%3E%3C/svg%3E");
+        animation: spin 1s infinite linear;
+        position: absolute;
+        left: 0.625rem;
+        top: 0.75rem;
+      }
+      
+      @keyframes spin {
+        from {
+          transform: rotate(0deg);
+        }
+        to {
+          transform: rotate(360deg);
+        }
+      }
+      
+      #sidebar nav {
+        flex: 1;
+        overflow: auto;
+        padding-top: 1rem;
+      }
+      
+      #sidebar nav a span {
+        float: right;
+        color: #eeb004;
+      }
+      #sidebar nav a.active span {
+        color: inherit;
+      }
+      
+      i {
+        color: #818181;
+      }
+      #sidebar nav .active i {
+        color: inherit;
+      }
+      
+      #sidebar ul {
+        padding: 0;
+        margin: 0;
+        list-style: none;
+      }
+      
+      #sidebar li {
+        margin: 0.25rem 0;
+      }
+      
+      #sidebar nav a {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        overflow: hidden;
+      
+        white-space: pre;
+        padding: 0.5rem;
+        border-radius: 8px;
+        color: inherit;
+        text-decoration: none;
+        gap: 1rem;
+      }
+      
+      #sidebar nav a:hover {
+        background: #e3e3e3;
+      }
+      
+      #sidebar nav a.active {
+        background: hsl(224, 98%, 58%);
+        color: white;
+      }
+      
+      #sidebar nav a.pending {
+        color: hsl(224, 98%, 58%);
+      }
+      
+      #detail {
+        flex: 1;
+        padding: 2rem 4rem;
+        width: 100%;
+      }
+      
+      #detail.loading {
+        opacity: 0.25;
+        transition: opacity 200ms;
+        transition-delay: 200ms;
+      }
+      
+      #contact {
+        max-width: 40rem;
+        display: flex;
+      }
+      
+      #contact h1 {
+        font-size: 2rem;
+        font-weight: 700;
+        margin: 0;
+        line-height: 1.2;
+      }
+      
+      #contact h1 + p {
+        margin: 0;
+      }
+      
+      #contact h1 + p + p {
+        white-space: break-spaces;
+      }
+      
+      #contact h1:focus {
+        outline: none;
+        color: hsl(224, 98%, 58%);
+      }
+      
+      #contact a[href*="twitter"] {
+        display: flex;
+        font-size: 1.5rem;
+        color: #3992ff;
+        text-decoration: none;
+      }
+      #contact a[href*="twitter"]:hover {
+        text-decoration: underline;
+      }
+      
+      #contact img {
+        width: 12rem;
+        height: 12rem;
+        background: #c8c8c8;
+        margin-right: 2rem;
+        border-radius: 1.5rem;
+        object-fit: cover;
+      }
+      
+      #contact h1 ~ div {
+        display: flex;
+        gap: 0.5rem;
+        margin: 1rem 0;
+      }
+      
+      #contact-form {
+        display: flex;
+        max-width: 40rem;
+        flex-direction: column;
+        gap: 1rem;
+      }
+      #contact-form > p:first-child {
+        margin: 0;
+        padding: 0;
+      }
+      #contact-form > p:first-child > :nth-child(2) {
+        margin-right: 1rem;
+      }
+      #contact-form > p:first-child,
+      #contact-form label {
+        display: flex;
+      }
+      #contact-form p:first-child span,
+      #contact-form label span {
+        width: 8rem;
+      }
+      #contact-form p:first-child input,
+      #contact-form label input,
+      #contact-form label textarea {
+        flex-grow: 2;
+      }
+      
+      #contact-form-avatar {
+        margin-right: 2rem;
+      }
+      
+      #contact-form-avatar img {
+        width: 12rem;
+        height: 12rem;
+        background: hsla(0, 0%, 0%, 0.2);
+        border-radius: 1rem;
+      }
+      
+      #contact-form-avatar input {
+        box-sizing: border-box;
+        width: 100%;
+      }
+      
+      #contact-form p:last-child {
+        display: flex;
+        gap: 0.5rem;
+        margin: 0 0 0 8rem;
+      }
+      
+      #contact-form p:last-child button[type="button"] {
+        color: inherit;
+      }
+      
+      #zero-state {
+        margin: 2rem auto;
+        text-align: center;
+        color: #818181;
+      }
+      
+      #zero-state a {
+        color: inherit;
+      }
+      
+      #zero-state a:hover {
+        color: #121212;
+      }
+      
+      #zero-state:before {
+        display: block;
+        margin-bottom: 0.5rem;
+        content: url("data:image/svg+xml,%3Csvg width='50' height='33' viewBox='0 0 50 33' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M38.8262 11.1744C37.3975 10.7252 36.6597 10.8766 35.1611 10.7128C32.8444 10.4602 31.9215 9.55475 31.5299 7.22456C31.3108 5.92377 31.5695 4.01923 31.0102 2.8401C29.9404 0.591789 27.4373 -0.416556 24.9225 0.158973C22.7992 0.645599 21.0326 2.76757 20.9347 4.94569C20.8228 7.43263 22.2399 9.5546 24.6731 10.2869C25.8291 10.6355 27.0574 10.8109 28.2646 10.8998C30.4788 11.0613 30.6489 12.292 31.2479 13.3051C31.6255 13.9438 31.9914 14.5731 31.9914 16.4775C31.9914 18.3819 31.6231 19.0112 31.2479 19.6499C30.6489 20.6606 29.9101 21.3227 27.696 21.4865C26.4887 21.5754 25.2581 21.7508 24.1044 22.0994C21.6712 22.834 20.2542 24.9537 20.366 27.4406C20.4639 29.6187 22.2306 31.7407 24.3538 32.2273C26.8686 32.8052 29.3717 31.7945 30.4415 29.5462C31.0032 28.3671 31.3108 27.0312 31.5299 25.7304C31.9238 23.4002 32.8467 22.4948 35.1611 22.2421C36.6597 22.0784 38.2107 22.2421 39.615 21.4443C41.099 20.36 42.4248 18.7328 42.4248 16.4775C42.4248 14.2222 40.9961 11.8575 38.8262 11.1744Z' fill='%23E3E3E3'/%3E%3Cpath d='M15.1991 21.6854C12.2523 21.6854 9.84863 19.303 9.84863 16.3823C9.84863 13.4615 12.2523 11.0791 15.1991 11.0791C18.1459 11.0791 20.5497 13.4615 20.5497 16.3823C20.5497 19.3006 18.1436 21.6854 15.1991 21.6854Z' fill='%23E3E3E3'/%3E%3Cpath d='M5.28442 32.3871C2.36841 32.38 -0.00698992 29.9882 1.54551e-05 27.0652C0.00705187 24.1469 2.39884 21.7715 5.32187 21.7808C8.24022 21.7878 10.6156 24.1796 10.6063 27.1027C10.5992 30.0187 8.20746 32.3941 5.28442 32.3871Z' fill='%23E3E3E3'/%3E%3Cpath d='M44.736 32.387C41.8107 32.4033 39.4096 30.0373 39.3932 27.1237C39.3769 24.1984 41.7428 21.7973 44.6564 21.7808C47.5817 21.7645 49.9828 24.1305 49.9993 27.0441C50.0156 29.9671 47.6496 32.3705 44.736 32.387Z' fill='%23E3E3E3'/%3E%3C/svg%3E%0A");
+      }
+      
+      #error-page {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        width: 100%;
+      }
diff --git a/frontend/components/pages/newFile.js b/frontend/components/pages/newFile.js
new file mode 100644
index 0000000000..6959ea3430
--- /dev/null
+++ b/frontend/components/pages/newFile.js
@@ -0,0 +1,37 @@
+const headerTitle = document.getElementById("header-title")
+const btn = document.getElementByld("button")
+
+btn.onclick = () => {
+btn.style.backgroundColor = "black"
+btn.style.color = "green"
+alert("Hello customer")
+headerTitle.innerText ="Hello Hello!"
+};
+headerTitle.style.display="none"
+fetch('https://api.specialgardengroup.org/data')
+  .then(response => {
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`)
+    }
+    return response.json()
+  })
+  .then(data => {
+    console.log(data)
+  })
+  .catch(error => {
+    console.error('Fetch error:', error)
+  });
+const fetchData = async () => {
+    try {
+      const response = await fetch('https://api.specialgardengroup.org/data')
+      if (!response.ok) {
+        throw new Error(`HTTP error! Status: ${response.status}`)
+      }
+      const data = await response.json()
+      console.log(data)
+    } catch (error) {
+      console.error('An error occurred:', error)
+    }
+  }
+  
+  fetchData()
\ No newline at end of file
diff --git a/frontend/components/pages/rightclick.js b/frontend/components/pages/rightclick.js
new file mode 100644
index 0000000000..44612ccf7b
--- /dev/null
+++ b/frontend/components/pages/rightclick.js
@@ -0,0 +1,82 @@
+//function to prevent inspection of page through google inspector
+
+function detectConsoleAccess(event) {
+    const isConsoleShortcut =
+      event.altKey && event.metaKey && event.code === "KeyJ";
+    const isInspectorShortcut =
+      event.altKey && event.metaKey && event.code === "KeyI";
+    const isRightClick = event.which === 3 || event.button === 2;
+    const isControlClick = event.ctrlKey && !event.metaKey && event.button === 0;
+    const message = `This function has been disabled to prevent you from looking through the code!
+          
+        `;
+    if (isConsoleShortcut) {
+      event.preventDefault();
+      alert(message);
+    } else if (isInspectorShortcut) {
+      event.preventDefault();
+      alert(message);
+    } else if (isRightClick) {
+      event.preventDefault();
+      alert(message);
+    } else if (isControlClick) {
+      event.preventDefault();
+      alert(message);
+    }
+  }
+  
+  window.addEventListener("keydown", detectConsoleAccess);
+  
+  document.addEventListener(
+    "keydown",
+    function () {
+      if (keyCode == 123) {
+        alert(
+          `This function has been disabled to prevent you from looking through the code!
+          
+        `
+        );
+        return false;
+      } else if (ctrlKey && altKey == 73) {
+        alert(
+          `This function has been disabled to prevent you from looking through the code!
+          
+        `
+        );
+        return false;
+      } else if (event.ctrlKey && event.keyCode == 85) {
+        alert(
+          `This function has been disabled to prevent you from looking through the code!
+          
+        `
+        );
+        return false;
+      }
+    },
+    false
+  );
+  
+  if (document.addEventListener) {
+    document.addEventListener(
+      "contextmenu",
+      function (e) {
+        alert(
+          `This function has been disabled to prevent you from looking through the code!
+            
+          `
+        );
+        e.preventDefault();
+      },
+      false
+    );
+  } else {
+    document.attachEvent("oncontextmenu", function () {
+      alert(
+        `This function has been disabled to prevent you from looking through the code!
+          
+        `
+      );
+      window.event.returnValue = false;
+    });
+  }
+  
\ No newline at end of file
diff --git a/frontend/components/pages/script.js b/frontend/components/pages/script.js
new file mode 100644
index 0000000000..5c43197f16
--- /dev/null
+++ b/frontend/components/pages/script.js
@@ -0,0 +1,331 @@
+const apiKey = '548773e920254208b83a2e2bdadb8f0e';
+const apiUrl = 'https://api.openweathermap.org/data/2.5/weather';
+
+const locationInput = document.getElementById('locationInput');
+const searchButton = document.getElementById('searchButton');
+const locationElement = document.getElementById('location');
+const temperatureElement = document.getElementById('temperature');
+const descriptionElement = document.getElementById('description');
+
+searchButton.addEventListener('click', () => {
+    const location = locationInput.value;
+    if (location) {
+        fetchWeather(location);
+    }
+});
+
+function fetchWeather(location) {
+    const url = `${apiUrl}?q=${location}&appid=${apiKey}&units=metric`;
+
+    fetch(url)
+        .then(response => response.json())
+        .then(data => {
+            locationElement.textContent = data.name;
+            temperatureElement.textContent = `${Math.round(data.main.temp)}°C`;
+            descriptionElement.textContent = data.weather[0].description;
+        })
+        .catch(error => {
+            console.error('Error fetching weather data:', error);
+        });
+
+//All global varibles
+const tempToday = document.getElementById("tempToday");
+const tempTextCelsius = document.querySelector(".tempTextCelsius");
+const cityName = document.getElementById("cityName");
+const localTime = document.getElementById("localTime");
+const weatherDescription = document.getElementById("weatherDescription");
+const mainIcon = document.getElementById("mainIcon");
+
+const sunriseText = document.getElementById("sunriseText");
+const sunsetText = document.getElementById("sunsetText");
+
+const weatherFeature = document.getElementById("weatherFeature");
+const featureImage = document.querySelector(".feature-image");
+const backgroundTopGradient = document.getElementById("backgroundTopGradient");
+
+const searchMenuBtn = document.getElementById("searchMenuBtn");
+const closeSearchMenu = document.getElementById("closeSearchMenu");
+const searchBtn = document.getElementById("searchBtn");
+const inputField = document.getElementById("inputField");
+const switchFavoriteCity = document.getElementById("switchBtn");
+
+const weatherForecast = document.getElementById("weatherForecast");
+const forecastWeekdays = document.getElementById("forecastWeekdays");
+const forecastIcon = document.getElementById("forecastIcon");
+const forecastDescription = document.getElementById("forecastDescription");
+const forecastTemp = document.getElementById("forecastTemp");
+const forecastWind = document.getElementById("forecastWind");
+
+const cityText = document.querySelector(".cityText");
+const tempText = document.querySelector(".tempText");
+const describeText = document.querySelector(".describeText");
+
+//Variables we can use later to automate API-fethcing:
+let city = "London";
+
+const todaysWeatherFeature = (London) => {
+  fetch(
+    `https://api.openweathermap.org/data/2.5/weather?q=${city}&units=metric&APPID=548773e920254208b83a2e2bdadb8f0e`
+  )
+    .then((response) => {
+      return response.json();
+    })
+    .then((json) => {
+      //Get today's weather
+      let { icon } = json.weather[0];
+      cityName.innerText = `${json.name}`;
+      tempToday.innerText = `${json.main.temp.toFixed(0)}`;
+      tempTextCelsius.innerText = `°C`;
+      weatherDescription.innerText = `${json.weather[0].description}`;
+      mainIcon.innerHTML = `<img src="http://openweathermap.org/img/wn/${icon}@2x.png" alt="weather icon" class="main-icon">`;
+
+      // Get current time (hours/minutes) in time zome
+      const currentLocalTime = new Date((json.dt + json.timezone) * 1000);
+      const localTimeValue = currentLocalTime.toLocaleTimeString(["en-GB"], {
+        timeStyle: "short",
+        timeZone: "UTC",
+      });
+
+      //Modifying the HTML based on the output of current time in hours/minutes
+      localTime.innerHTML = `Time: ${localTimeValue}`;
+
+      // Get sunrise and sunset time with the city's timezone
+      const sunriseTime = new Date((json.sys.sunrise + json.timezone) * 1000); //Gives us the time in "human" form (as a date), mult. by 1000 to get it in ms.
+      sunriseTime.setMinutes(
+        sunriseTime.getMinutes() + sunriseTime.getTimezoneOffset()
+      );
+      const sunriseShort = sunriseTime.toLocaleTimeString(["en-GB"], {
+        timeStyle: "short",
+      }); //Transforms it into just the Hour/minutes. Select the short variant to get the time with minutes and not seconds.
+      const sunsetTime = new Date((json.sys.sunset + json.timezone) * 1000);
+      sunsetTime.setMinutes(
+        sunsetTime.getMinutes() + sunsetTime.getTimezoneOffset()
+      );
+      const sunsetShort = sunsetTime.toLocaleTimeString(["en-GB"], {
+        timeStyle: "short",
+      });
+
+      //Modifying the HTML based on our input:
+      sunriseText.innerHTML = `<p>sunrise</p>
+                                            <p class="time-data">${sunriseShort}</p>`;
+      sunsetText.innerHTML = `<p>sunset</p>
+                                        <p class="time-data">${sunsetShort}</p>`;
+
+      //Today's weather varible
+      const todaysWeather = json.weather[0].main;
+
+      //Get current local time with timezone
+      const getTime = new Date();
+      getTime.setMinutes(getTime.getMinutes() + getTime.getTimezoneOffset());
+      getTime.setSeconds(getTime.getSeconds() + json.timezone);
+
+      //Get time in hours to compare
+      const currentTime = getTime.getHours();
+      const sunriseTimeHour = sunriseTime.getHours();
+      const sunsetTimeHour = sunsetTime.getHours();
+
+      //Image feature
+      if (currentTime >= sunriseTimeHour && currentTime <= sunsetTimeHour) {
+        //During daytime => show image depending on weather
+        if (todaysWeather === "Clear") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1613931189161-1f4d2660bd1e?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDczNDI&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Clouds") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1424111113808-b7be56a9f3d6?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2NzcyNTczNTA&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Rain") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1424111113808-b7be56a9f3d6?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2NzcyNTczNTA&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Snow") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1610486549369-585a0e6d8cc4?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDc4NDE&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Thunderstorm") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1602088501827-7912e1b4a7bd?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDc5ODI&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Drizzle") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1554039362-6daf559ddb63?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDgyNDk&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Atmosphere" || todaysWeather === "Haze") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1543226549-10d29b2cfaf0?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDg0MTI&ixlib=rb-4.0.3&q=80')";
+        } else {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1424111113808-b7be56a9f3d6?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2NzcyNTczNTA&ixlib=rb-4.0.3&q=80')";
+        }
+      } else {
+        //During nighttime => show image depending on weather
+        if (todaysWeather === "Clear") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1620055374842-145f66ec4652?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDkxMTY&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Snow") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1602857731804-80e82120ff27?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDkzNzQ&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Rain") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1505144992585-d281c0e2cff8?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDk1OTA&ixlib=rb-4.0.3&q=80')";
+        } else if (todaysWeather === "Clouds") {
+          featureImage.style.backgroundImage =
+            "url('https://images.unsplash.com/photo-1518352724948-729151797553?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MDk1OTA&ixlib=rb-4.0.3&q=80')";
+        } else {
+          featureImage.style.backgroundImage =
+            "url(' https://images.unsplash.com/photo-1604083142449-79b1babd12d4?crop=entropy&cs=tinysrgb&fm=jpg&ixid=MnwzMjM4NDZ8MHwxfHJhbmRvbXx8fHx8fHx8fDE2Nzc0MTIwOTM&ixlib=rb-4.0.3&q=80')";
+        }
+      }
+
+      const gradientDayNight = () => {
+        //Remove all classes to be added later
+        const gradientStyle = [
+          "morning",
+          "midday",
+          "afternoon",
+          "duskSunset",
+          "evening",
+          "midnight",
+          "dawnSunrise",
+        ];
+        backgroundTopGradient.classList.remove(...gradientStyle);
+
+        if (currentTime > 7 && currentTime <= 11) {
+          backgroundTopGradient.classList.add("morning");
+        } else if (currentTime > 11 && currentTime <= 14) {
+          backgroundTopGradient.classList.add("midday");
+        } else if (currentTime > 14 && currentTime < 17) {
+          backgroundTopGradient.classList.add("afternoon");
+        } else if (currentTime >= 17 && currentTime <= 19) {
+          backgroundTopGradient.classList.add("duskSunset");
+        } else if (currentTime > 19 && currentTime <= 23) {
+          backgroundTopGradient.classList.add("evening");
+        } else if (currentTime > 23 || currentTime < 5) {
+          backgroundTopGradient.classList.add("midnight");
+        } else {
+          backgroundTopGradient.classList.add("dawnSunrise");
+      }
+    };
+    gradientDayNight();
+  });
+};
+
+const weatherForecastData = (London) => {
+  fetch(
+    `https://api.openweathermap.org/data/2.5/forecast?q=${city}&units=metric&APPID=${apiKey}`
+  )
+    .then((forecastResponse) => {
+      return forecastResponse.json();
+    })
+    .then((result) => {
+      if (result.cod !== "404") {
+        //If the user did NOT search for a city that does not exist
+
+        const todaysDate = new Date().toString().split(" ")[0]; //Today's date in text form
+        const filterData = result.list.filter((weatherDay) =>
+          weatherDay.dt_txt.includes("12:00")
+        ); //Filters out the data at 12:00 every day
+
+        filterData.forEach((date) => {
+          const weekDay = new Date(date.dt * 1000).toString().split(" ")[0]; //All the five days dates' convertet from numbers to text
+          if (weekDay !== todaysDate) {
+            let { icon } = date.weather[0];
+            forecastWeekdays.innerHTML += `<p>${weekDay}</p>`;
+            forecastIcon.innerHTML += `<img src="http://openweathermap.org/img/wn/${icon}@2x.png" alt="weather icon" class="weather-icons">`;
+            forecastTemp.innerHTML += `<p>${date.main.temp.toFixed(0)}°C</p>`;
+            forecastWind.innerHTML += `<p>${date.wind.speed}m/s</p>`;
+          }
+        });
+      } else {
+        //If the user DID search for a city that does not exist. Alerts user that the city cant be found. Then runs Stockholm again.
+        alert("Oops, city not found! Check your spelling please.");
+        todaysWeatherFeature("London");
+        weatherForecastData("London");
+      }
+    });
+  }
+};
+
+const toggleSearchField = () => {
+  //This just controls the toggling between opening and closing the search field
+  const searchToggler = document.getElementById("search-toggler");
+  searchToggler.classList.toggle("hidden");
+  closeSearchMenu.classList.toggle("hidden");
+  searchMenuBtn.classList.toggle("hidden");
+};
+
+const searchFunction = () => {
+  //This is for storing the user input from the search and pushing it into our fetching weather function later on
+
+  let searchedCity = inputField.value;
+
+  //Use the city searched and inject into ""fetchWeather""" function:
+  todaysWeatherFeature(searchedCity);
+  weatherForecastData(searchedCity);
+
+  //Clears field & hides the input field:
+  inputField.value = "";
+
+  //Reset the weather forecast:
+  forecastWeekdays.innerHTML = "";
+  forecastIcon.innerHTML = "";
+  forecastWind.innerHTML = "";
+  forecastTemp.innerHTML = "";
+};
+
+const getNextCity = () => {
+  //Change default favorite city
+  //Reset the weather forecast:
+  forecastWeekdays.innerHTML = "";
+  forecastIcon.innerHTML = "";
+  forecastTemp.innerHTML = "";
+  forecastWind.innerHTML = "";
+
+  if (city === "Stockholm") {
+    todaysWeatherFeature("Madrid");
+    weatherForecastData("Madrid");
+    city = "Madrid";
+  } else if (city === "Madrid") {
+    todaysWeatherFeature("Singapore");
+    weatherForecastData("Singapore");
+    city = "Singapore";
+  } else if (city === "Singapore") {
+    todaysWeatherFeature("San Francisco");
+    weatherForecastData("San Francisco");
+    city = "San Francisco";
+  } else if (city === "San Francisco") {
+    todaysWeatherFeature("Cairo");
+    weatherForecastData("Cairo");
+    city = "Cairo";
+  } else if (city === "Cairo") {
+    todaysWeatherFeature("Sidney");
+    weatherForecastData("Sidney");
+    city = "Sidney";
+  } else if (city === "Sidney") {
+    todaysWeatherFeature("Bogota");
+    weatherForecastData("Bogota");
+    city = "Bogota";
+  } else if (city === "Bogota") {
+    todaysWeatherFeature("Barcelona");
+    weatherForecastData("Barcelona");
+    city = "Barcelona";
+  } else {
+    todaysWeatherFeature("Stockholm");
+    weatherForecastData("Stockholm");
+    city = "Stockholm";
+  }
+};
+
+// Start:
+todaysWeatherFeature("Stockholm");
+weatherForecastData("Stockholm");
+
+//All global eventListeners
+//Eventlistener to invoke getNextCity function
+switchFavoriteCity.addEventListener("click", getNextCity);
+//Eventlistener to toggle search field:
+searchMenuBtn.addEventListener("click", toggleSearchField);
+closeSearchMenu.addEventListener("click", toggleSearchField);
+//Eventlistener to search through enter key also
+searchBtn.addEventListener("click", searchFunction);
+//Eventlistener to search through enter key also
+inputField.addEventListener("keyup", function (event) {
+  if (event.key == "Enter") {
+    searchFunction();
+  }
+});
diff --git a/frontend/components/pages/stores/appContentStore.jsx b/frontend/components/pages/stores/appContentStore.jsx
new file mode 100644
index 0000000000..f1abf0e20e
--- /dev/null
+++ b/frontend/components/pages/stores/appContentStore.jsx
@@ -0,0 +1,5 @@
+import {create} from "zustand"
+export const appContentStore = create(() => ({}))
+appContent:{
+    heading: "State-Management-Zustand-js-project-project-final-SGG"
+}
\ No newline at end of file
diff --git a/frontend/components/pages/stores/userStore.jsx b/frontend/components/pages/stores/userStore.jsx
new file mode 100644
index 0000000000..67e4a1797c
--- /dev/null
+++ b/frontend/components/pages/stores/userStore.jsx
@@ -0,0 +1,9 @@
+import { create } from "zustand"
+export const useUserStore = create ((set) =>({
+    isLoggedIn: false,
+    age: 25,
+    userName: "John Doe",
+    toggleLogin: () set ((state) => ({isLoggedIn:})) !state.isLoggedIn}))
+    incrementAge: () => set ((state) => ({age: state.age +1})),
+    setUserName: (newUserName) => set ({userName:})
+})
\ No newline at end of file
diff --git a/frontend/components/pages/style.css b/frontend/components/pages/style.css
new file mode 100644
index 0000000000..5778937375
--- /dev/null
+++ b/frontend/components/pages/style.css
@@ -0,0 +1,196 @@
+
+    input {
+        font-size: 20px;
+    }
+    
+    input:valid{
+        background-color: green;
+    
+    }
+    input:invalid{
+        background-color: red;
+    }
+    
+    label{
+        display: block;
+        margin-bottom: 20px;
+    }
+    body{
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif;
+        background: #f8fbfd;
+        color: #525f7f;
+        padding: 40px;
+    }
+    *{
+        box-sizing: border-box;
+    }
+    form{
+        border: 1px solid #e8e8fb;
+        border-radius: 4px;
+        padding: 20px;
+        max-width: 100%;
+    }
+    h2{
+        text-transform: uppercase;
+        font-size: 15px;
+        margin-top: 0;
+    } 
+    fieldset{
+        border: none;
+        padding: 0;
+        background: white;
+        border-radius: 4px;
+        box-shadow: 0 1px 3px 0 rgba(50, 50, 93, 0.15), 0 4px 6px 0 rgba(112, 157, 199, 0.15);
+    }
+    label{
+        display: flex;
+        border-bottom: 1px solid #f0f5fa;
+        align-items: center;
+    }
+    label:last-child{
+        border-bottom: none;
+    }
+    span{
+        width: 30%;
+        text-align: right;
+        margin-right: 15px;
+        flex-shrink: 0;
+    }
+    input{
+        width: 100%;
+        font-size: 15px;
+        padding: 5px 0;
+        appearance: none;
+        border: none;
+        outline: none;
+    }
+    select {
+        width: 100%;
+        margin: 10px 10px 10px 0;
+        appearance: none;
+        -webkit-appearance: none;
+        background-color: transparent;
+        border: none;
+        font-size: 15px;
+        color: #313b3f;
+        outline: none;
+    }
+    
+    button {
+        background: #666ee8;
+        border: none;
+        border-radius: 4px;
+        width: 100%;
+        font-size: 16px;
+        color: white;
+        font-weight: bold;
+        padding: 10px;
+        margin-top: 20px;
+    }
+    ::-webkit-input-placeholder {
+        /* Chrome/Opera/Safari */
+        color: #00b7c4;
+    }
+    ::-moz-placeholder {
+        /* Firefox 19+ */
+        color: #00b7c4;
+    }
+    :-ms-input-placeholder {
+        /* IE 10+ */
+        color: #00b7c4;
+    }
+    :-moz-placeholder {
+        /* Firefox 18- */
+        color: #00b7c4;
+    }
+    .radiobutton-container input:focus + .custom-radio {
+        outline: #333 auto 4px;
+    }
+    .checkbox-container {
+        display: block;
+        position: relative;
+        padding-left: 25px;
+        margin: 10px 5px;
+        font-size: 16px;
+        user-select: none;
+    }
+    .checkbox-container input {
+        position: absolute;
+        cursor: pointer;
+        height: 0;
+        width: 0;
+    }
+    .custom-checkbox {
+        position: absolute;
+        top: 0;
+        left: 0;
+        height: 19px;
+        width: 19px;
+        background-color: #eee;
+        border-radius: 4px;
+        cursor: pointer;
+    }
+    .checkbox-container:hover input ~ .custom-checkbox {
+        background-color: #ccc;
+    }
+    .custom-checkbox:after {
+        width: 3px;
+        height: 6px;
+        border: solid pink;
+        border-width: 0 3px 3px 0;
+        top: 5px;
+        left: 7px;
+        transform: rotate(45deg);
+        display: none;
+        content: "";
+        position: absolute;
+    }
+    .checkbox-container input:checked ~ .custom-checkbox:after {
+        display: block;
+    }
+    .checkbox-container input:focus + .custom-checkbox {
+        outline: #333 auto 4px;
+    }
+    .search-field {
+        height: 35px;
+        width: 100%;
+        margin-right: 5px;
+        margin-left: 5px;
+        border: 2px solid lightgrey;
+    }
+    .search-field:hover {
+        border: 2px solid grey;
+    }
+    .search-field::placeholder {
+        font-size: 16px;
+        background: none;
+        border: 2px solid lightgrey;
+    }
+    .search-button:hover {
+        border: 2px solid grey;
+    }
+    .wrapper-col {
+        display: flex;
+        flex-direction: column;
+    }
+    .radiobutton-container {
+        display: block;
+        position: relative;
+        padding-left: 25px;
+        margin: 10px 5px;
+        font-size: 16px;
+    }
+    .custom-radio:after {
+        content: "";
+        position: absolute;
+        top: 6px;
+        left: 6px;
+        width: 7px;
+        height: 7px;
+        background-color: #fff;
+        border-radius: 50%;
+        display: none;
+    }
+    .radiobutton-container input:checked ~ .custom-radio {
+        background-color: #444444;
+    }
diff --git a/frontend/components/pages/useDarkMode.jsx b/frontend/components/pages/useDarkMode.jsx
new file mode 100644
index 0000000000..598b4e7000
--- /dev/null
+++ b/frontend/components/pages/useDarkMode.jsx
@@ -0,0 +1,15 @@
+return[storedValue, setValue];
+};
+const use DarkMode =() => {
+    const [enabled, setEnabled]=useLocalStorage('dark-theme');
+    const isEnabled = typeof enabledState ===
+    'undefined' && enabled;
+    useEffect(()) => }
+    const className = 'dark';
+    const bodyClass = window.document.body.classList;
+    isEnabled ? bodyclass.add(className):bodyclass.remove(className);
+},[enabled, isEnabled]);
+return [enabled, setEnabled]
+};
+export default useDarkMode; 
+}
\ No newline at end of file
diff --git a/frontend/components/pages/views/login.ejs b/frontend/components/pages/views/login.ejs
new file mode 100644
index 0000000000..7beaa08b6f
--- /dev/null
+++ b/frontend/components/pages/views/login.ejs
@@ -0,0 +1,2 @@
+<h1>Sign in</h1>
+<a class="button facebook" href="/login/federated/facebook">Sign in with Facebook</a>
\ No newline at end of file
diff --git a/frontend/components/pages/weather.js b/frontend/components/pages/weather.js
new file mode 100644
index 0000000000..0527521e46
--- /dev/null
+++ b/frontend/components/pages/weather.js
@@ -0,0 +1,207 @@
+const API_KEY = "548773e920254208b83a2e2bdadb8f0e";
+const body = document.getElementById("body");
+https://pro.openweathermap.org/data/2.5/forecast/climate?lat={lat}&lon={lon}&appid={548773e}
+"weatherApiUrl": "https://pro.openweathermap.org/data/2.5/forecast/climate?lat={lat}&lon={lon}&appid={API key}",
+  "weatherApiUrlByCity": "https://pro.openweathermap.org/data/2.5/forecast/climate?q={city name},{country code}&appid={API key}",
+  "weatherApiUrlLondon": "https://pro.openweathermap.org/data/2.5/forecast/climate?q=London&appid={API key}",
+  "weatherApiUrlByCityId": "https://pro.openweathermap.org/data/2.5/forecast/climate?id={city ID}&appid={API key}",
+  "weatherApiUrlByCityIdExample": "https://pro.openweathermap.org/data/2.5/forecast/climate?id=2643743&appid={API key}",
+  "weatherApiUrlByZip": "https://pro.openweathermap.org/data/2.5/forecast/climate?zip={zip code},{country code}&appid={API key}",
+  "weatherApiUrlByZipExample": "https://pro.openweathermap.org/data/2.5/forecast/climate?zip=94040,us&appid={API key}",
+  "weatherApiUrlLondonCnt3": "https://api.openweathermap.org/data/2.5/forecast/climate?q=London&cnt=3",
+  "weatherApiUrlLondonExample": "https://api.openweathermap.org/data/2.5/forecast/climate?q=London",
+  "weatherApiUrlLondonMetric": "https://api.openweathermap.org/data/2.5/forecast/climate?q=London&units=metric",
+  "api.openweathermap.org/data/2.5/forecast/climate?q=London&units=imperial": "",
+  "weatherApiUrlByCityLang": "http://api.openweathermap.org/data/2.5/forecast/climate?id=524901&lang={lang}",
+  "weatherApiUrlByCityLangZhCn": "http://api.openweathermap.org/data/2.5/forecast/climate?id=524901&lang=zh_cn",
+  "api.openweathermap.org/data/2.5/forecast/climate?q=London,uk&callback=test": "",
+
+
+
+
+const shortDescription = document.getElementById("shortDescription");
+const temperature = document.getElementById("temperature");
+const sunrise = document.getElementById("sunrise");
+const sunset = document.getElementById("sunset");
+const description = document.getElementById("description");
+const forecast = document.getElementById("forecast");
+const icon = document.getElementById("icon");
+const errorMessage = document.getElementById("error");
+
+const chosenCity = document.getElementById("chosenCity");
+const searchButton = document.getElementById("citySearchButton");
+
+let city = "London";
+
+//Change description and styling
+//based on weather
+const pickTodaysDescription = (todaysDescription) => {
+  body.classList.remove(...body.classList);
+
+  if (todaysDescription === "Clouds") {
+    icon.src = "./assets/d2-cloud.svg";
+    body.classList.add("cloudy");
+    description.innerHTML = `Light a fire and get cosy. ${city} is looking grey today.`;
+  } else if (todaysDescription === "Clear") {
+    icon.src = "./assets/d2-sun.svg";
+    body.classList.add("sunny");
+    description.innerHTML = `Get your sunnies on. ${city} is looking rather great today.`;
+  } else if (
+    todaysDescription === "Rain" ||
+    todaysDescription === "Thunderstorm" ||
+    todaysDescription === "Drizzle" ||
+    todaysDescription === "Snow"
+  ) {
+    icon.src = "./assets/d2-rain.svg";
+    body.classList.add("rainy");
+    description.innerHTML = `Don't forget your umbrella. It's wet in ${city} today.`;
+  } else {
+    icon.src = "./assets/d2-unknown.svg";
+    body.classList.add("unknown");
+    description.innerHTML = `Be careful today in ${city}!`;
+  }
+};
+
+const capitalizeFirstLetter = (string) => {
+  return `${string.charAt(0).toUpperCase()}${string.slice(1)}`;
+};
+
+//Fetching the weather data for today
+const fetchWeather = (city) => {
+  fetch(
+    `https://api.openweathermap.org/data/2.5/weather?q=${city}&units=metric&APPID=${API_KEY}`
+  )
+    .then((response) => {
+      return response.json();
+    })
+    .then((json) => {
+      const sunriseTime = new Date((json.sys.sunrise + json.timezone) * 1000); //Gives us the time in "human" form (as a date), mult. by 1000 to get it in ms.
+      sunriseTime.setMinutes(
+        sunriseTime.getMinutes() + sunriseTime.getTimezoneOffset()
+      );
+
+      const sunsetTime = new Date((json.sys.sunset + json.timezone) * 1000);
+      sunsetTime.setMinutes(
+        sunsetTime.getMinutes() + sunsetTime.getTimezoneOffset()
+      );
+      console.log(sunriseTime);
+
+      if (json.cod === "404") {
+        errorMessage.innerHTML =
+          "Can't find what you're looking for. Try another city, <br> or add the country as well: 'Stockholm, Sweden'!";
+      } else {
+        errorMessage.innerHTML = "";
+        const todaysWeather = {
+          temperature: json.main.temp.toFixed(),
+          weather: json.weather[0],
+          sunrise: sunriseTime.toLocaleTimeString([], {
+            hour: "2-digit",
+            minute: "2-digit",
+          }),
+          sunset: sunsetTime.toLocaleTimeString([], {
+            hour: "2-digit",
+            minute: "2-digit",
+          }),
+        };
+        shortDescription.innerHTML = todaysWeather.weather.description;
+        temperature.innerHTML = `${todaysWeather.temperature} °C`;
+        sunrise.innerHTML = `sunrise ${todaysWeather.sunrise}`;
+        sunset.innerHTML = `sunset ${todaysWeather.sunset}`;
+
+        pickTodaysDescription(todaysWeather.weather.main);
+      }
+    });
+};
+
+let dates = {};
+
+const convertDate = (date) => {
+  //Get the correct day
+  const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const wholeDate = new Date(date);
+  const dayName = dayNames[wholeDate.getDay()];
+  return dayName;
+};
+
+//Fetching forecast
+const fetchForecast = (city) => {
+  fetch(
+  `https://api.openweathermap.org/data/2.5/forecast?q=${city}&units=metric&APPID=${API_KEY}`
+  )
+    .then((response) => {
+      return response.json();
+    })
+    .then((json) => {
+      if (json.list) {
+        json.list.forEach((weather) => {
+          const date = weather.dt_txt.split(" ")[0];
+          if (dates[date]) {
+            dates[date].push(weather);
+          } else {
+            dates[date] = [weather];
+          }
+        });
+
+        //Emptying the forecast before populating it
+        forecast.innerHTML = "";
+
+        //Getting weather values
+        Object.entries(dates).forEach((item, index) => {
+          dates = {};
+          const date = item[0];
+          const weatherValues = item[1];
+          const temps = weatherValues.map((value) => value.main.temp);
+
+          const sum = temps.reduce((a, b) => a + b, 0);
+          let averageTemp = sum / temps.length || 0;
+
+          if (index === 0) {
+            return;
+          }
+
+          let fixedTemp = averageTemp.toFixed();
+          if (fixedTemp === "-0") {
+            fixedTemp = "0";
+          }
+
+          const day = convertDate(date);
+
+          try {
+            forecast.innerHTML += `
+              <div>
+                <p>${day}</p>
+                <p>${fixedTemp} °C</p>
+              </div>
+            `;
+          } catch (error) {
+            console.log(`Next day of forecast will come soon`);
+          }
+        });
+      } else {
+        console.log("No forecast available");
+      }
+    });
+};
+
+//Fetch again with new city input
+const changeCity = () => {
+  city = capitalizeFirstLetter(chosenCity.value);
+  fetchWeather(city);
+  fetchForecast(city);
+  chosenCity.value = "";
+};
+
+//Listening to enter press when search for city
+chosenCity.addEventListener("keyup", (event) => {
+  if (event.key === "Enter") {
+    changeCity();
+  }
+});
+
+searchButton.addEventListener("click", () => {
+  changeCity();
+});
+
+//Fetch Stockholm data on page load
+fetchWeather(city);
+fetchForecast(city);
diff --git a/frontend/components/style.css b/frontend/components/style.css
new file mode 100644
index 0000000000..f1d8c73cdc
--- /dev/null
+++ b/frontend/components/style.css
@@ -0,0 +1 @@
+@import "tailwindcss";
diff --git a/frontend/components/useDarkMode.jsx b/frontend/components/useDarkMode.jsx
new file mode 100644
index 0000000000..598b4e7000
--- /dev/null
+++ b/frontend/components/useDarkMode.jsx
@@ -0,0 +1,15 @@
+return[storedValue, setValue];
+};
+const use DarkMode =() => {
+    const [enabled, setEnabled]=useLocalStorage('dark-theme');
+    const isEnabled = typeof enabledState ===
+    'undefined' && enabled;
+    useEffect(()) => }
+    const className = 'dark';
+    const bodyClass = window.document.body.classList;
+    isEnabled ? bodyclass.add(className):bodyclass.remove(className);
+},[enabled, isEnabled]);
+return [enabled, setEnabled]
+};
+export default useDarkMode; 
+}
\ No newline at end of file
diff --git a/frontend/dist/assets/index-BYbkx6M0.css b/frontend/dist/assets/index-BYbkx6M0.css
new file mode 100644
index 0000000000..555ee0118c
--- /dev/null
+++ b/frontend/dist/assets/index-BYbkx6M0.css
@@ -0,0 +1 @@
+import "@fontsource/roboto/300.css"; import "@fontsource/roboto/400.css"; import "@fontsource/roboto/500.css"; import "@fontsource/roboto/700.css"; <link rel="preconnect" href="https://fonts.googleapis.com" /> <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin /> <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap" /> <link rel="stylesheet" href="https://fonts.googleapis.com/icon?family=Material+Icons" />{}
diff --git a/frontend/dist/assets/index-DPwCqAy9.js b/frontend/dist/assets/index-DPwCqAy9.js
new file mode 100644
index 0000000000..7ae1a9288c
--- /dev/null
+++ b/frontend/dist/assets/index-DPwCqAy9.js
@@ -0,0 +1,40 @@
+(function(){const H=document.createElement("link").relList;if(H&&H.supports&&H.supports("modulepreload"))return;for(const A of document.querySelectorAll('link[rel="modulepreload"]'))Ne(A);new MutationObserver(A=>{for(const Y of A)if(Y.type==="childList")for(const ce of Y.addedNodes)ce.tagName==="LINK"&&ce.rel==="modulepreload"&&Ne(ce)}).observe(document,{childList:!0,subtree:!0});function m(A){const Y={};return A.integrity&&(Y.integrity=A.integrity),A.referrerPolicy&&(Y.referrerPolicy=A.referrerPolicy),A.crossOrigin==="use-credentials"?Y.credentials="include":A.crossOrigin==="anonymous"?Y.credentials="omit":Y.credentials="same-origin",Y}function Ne(A){if(A.ep)return;A.ep=!0;const Y=m(A);fetch(A.href,Y)}})();function Oa(T){return T&&T.__esModule&&Object.prototype.hasOwnProperty.call(T,"default")?T.default:T}var _o={exports:{}},yr={},Co={exports:{}},M={};/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var _a;function Tf(){if(_a)return M;_a=1;var T=Symbol.for("react.element"),H=Symbol.for("react.portal"),m=Symbol.for("react.fragment"),Ne=Symbol.for("react.strict_mode"),A=Symbol.for("react.profiler"),Y=Symbol.for("react.provider"),ce=Symbol.for("react.context"),fe=Symbol.for("react.forward_ref"),W=Symbol.for("react.suspense"),_e=Symbol.for("react.memo"),ye=Symbol.for("react.lazy"),ee=Symbol.iterator;function Z(c){return c===null||typeof c!="object"?null:(c=ee&&c[ee]||c["@@iterator"],typeof c=="function"?c:null)}var We={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},$e=Object.assign,J={};function $(c,v,O){this.props=c,this.context=v,this.refs=J,this.updater=O||We}$.prototype.isReactComponent={},$.prototype.setState=function(c,v){if(typeof c!="object"&&typeof c!="function"&&c!=null)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,c,v,"setState")},$.prototype.forceUpdate=function(c){this.updater.enqueueForceUpdate(this,c,"forceUpdate")};function vt(){}vt.prototype=$.prototype;function st(c,v,O){this.props=c,this.context=v,this.refs=J,this.updater=O||We}var qe=st.prototype=new vt;qe.constructor=st,$e(qe,$.prototype),qe.isPureReactComponent=!0;var ge=Array.isArray,be=Object.prototype.hasOwnProperty,Ce={current:null},ze={key:!0,ref:!0,__self:!0,__source:!0};function Qe(c,v,O){var D,j={},F=null,Q=null;if(v!=null)for(D in v.ref!==void 0&&(Q=v.ref),v.key!==void 0&&(F=""+v.key),v)be.call(v,D)&&!ze.hasOwnProperty(D)&&(j[D]=v[D]);var V=arguments.length-2;if(V===1)j.children=O;else if(1<V){for(var q=Array(V),Ue=0;Ue<V;Ue++)q[Ue]=arguments[Ue+2];j.children=q}if(c&&c.defaultProps)for(D in V=c.defaultProps,V)j[D]===void 0&&(j[D]=V[D]);return{$$typeof:T,type:c,key:F,ref:Q,props:j,_owner:Ce.current}}function Pt(c,v){return{$$typeof:T,type:c.type,key:v,ref:c.ref,props:c.props,_owner:c._owner}}function yt(c){return typeof c=="object"&&c!==null&&c.$$typeof===T}function Kt(c){var v={"=":"=0",":":"=2"};return"$"+c.replace(/[=:]/g,function(O){return v[O]})}var at=/\/+/g;function Fe(c,v){return typeof c=="object"&&c!==null&&c.key!=null?Kt(""+c.key):v.toString(36)}function et(c,v,O,D,j){var F=typeof c;(F==="undefined"||F==="boolean")&&(c=null);var Q=!1;if(c===null)Q=!0;else switch(F){case"string":case"number":Q=!0;break;case"object":switch(c.$$typeof){case T:case H:Q=!0}}if(Q)return Q=c,j=j(Q),c=D===""?"."+Fe(Q,0):D,ge(j)?(O="",c!=null&&(O=c.replace(at,"$&/")+"/"),et(j,v,O,"",function(Ue){return Ue})):j!=null&&(yt(j)&&(j=Pt(j,O+(!j.key||Q&&Q.key===j.key?"":(""+j.key).replace(at,"$&/")+"/")+c)),v.push(j)),1;if(Q=0,D=D===""?".":D+":",ge(c))for(var V=0;V<c.length;V++){F=c[V];var q=D+Fe(F,V);Q+=et(F,v,O,q,j)}else if(q=Z(c),typeof q=="function")for(c=q.call(c),V=0;!(F=c.next()).done;)F=F.value,q=D+Fe(F,V++),Q+=et(F,v,O,q,j);else if(F==="object")throw v=String(c),Error("Objects are not valid as a React child (found: "+(v==="[object Object]"?"object with keys {"+Object.keys(c).join(", ")+"}":v)+"). If you meant to render a collection of children, use an array instead.");return Q}function ct(c,v,O){if(c==null)return c;var D=[],j=0;return et(c,D,"","",function(F){return v.call(O,F,j++)}),D}function Le(c){if(c._status===-1){var v=c._result;v=v(),v.then(function(O){(c._status===0||c._status===-1)&&(c._status=1,c._result=O)},function(O){(c._status===0||c._status===-1)&&(c._status=2,c._result=O)}),c._status===-1&&(c._status=0,c._result=v)}if(c._status===1)return c._result.default;throw c._result}var re={current:null},S={transition:null},L={ReactCurrentDispatcher:re,ReactCurrentBatchConfig:S,ReactCurrentOwner:Ce};function _(){throw Error("act(...) is not supported in production builds of React.")}return M.Children={map:ct,forEach:function(c,v,O){ct(c,function(){v.apply(this,arguments)},O)},count:function(c){var v=0;return ct(c,function(){v++}),v},toArray:function(c){return ct(c,function(v){return v})||[]},only:function(c){if(!yt(c))throw Error("React.Children.only expected to receive a single React element child.");return c}},M.Component=$,M.Fragment=m,M.Profiler=A,M.PureComponent=st,M.StrictMode=Ne,M.Suspense=W,M.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=L,M.act=_,M.cloneElement=function(c,v,O){if(c==null)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+c+".");var D=$e({},c.props),j=c.key,F=c.ref,Q=c._owner;if(v!=null){if(v.ref!==void 0&&(F=v.ref,Q=Ce.current),v.key!==void 0&&(j=""+v.key),c.type&&c.type.defaultProps)var V=c.type.defaultProps;for(q in v)be.call(v,q)&&!ze.hasOwnProperty(q)&&(D[q]=v[q]===void 0&&V!==void 0?V[q]:v[q])}var q=arguments.length-2;if(q===1)D.children=O;else if(1<q){V=Array(q);for(var Ue=0;Ue<q;Ue++)V[Ue]=arguments[Ue+2];D.children=V}return{$$typeof:T,type:c.type,key:j,ref:F,props:D,_owner:Q}},M.createContext=function(c){return c={$$typeof:ce,_currentValue:c,_currentValue2:c,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null},c.Provider={$$typeof:Y,_context:c},c.Consumer=c},M.createElement=Qe,M.createFactory=function(c){var v=Qe.bind(null,c);return v.type=c,v},M.createRef=function(){return{current:null}},M.forwardRef=function(c){return{$$typeof:fe,render:c}},M.isValidElement=yt,M.lazy=function(c){return{$$typeof:ye,_payload:{_status:-1,_result:c},_init:Le}},M.memo=function(c,v){return{$$typeof:_e,type:c,compare:v===void 0?null:v}},M.startTransition=function(c){var v=S.transition;S.transition={};try{c()}finally{S.transition=v}},M.unstable_act=_,M.useCallback=function(c,v){return re.current.useCallback(c,v)},M.useContext=function(c){return re.current.useContext(c)},M.useDebugValue=function(){},M.useDeferredValue=function(c){return re.current.useDeferredValue(c)},M.useEffect=function(c,v){return re.current.useEffect(c,v)},M.useId=function(){return re.current.useId()},M.useImperativeHandle=function(c,v,O){return re.current.useImperativeHandle(c,v,O)},M.useInsertionEffect=function(c,v){return re.current.useInsertionEffect(c,v)},M.useLayoutEffect=function(c,v){return re.current.useLayoutEffect(c,v)},M.useMemo=function(c,v){return re.current.useMemo(c,v)},M.useReducer=function(c,v,O){return re.current.useReducer(c,v,O)},M.useRef=function(c){return re.current.useRef(c)},M.useState=function(c){return re.current.useState(c)},M.useSyncExternalStore=function(c,v,O){return re.current.useSyncExternalStore(c,v,O)},M.useTransition=function(){return re.current.useTransition()},M.version="18.3.1",M}var Ca;function zo(){return Ca||(Ca=1,Co.exports=Tf()),Co.exports}/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var xa;function Rf(){if(xa)return yr;xa=1;var T=zo(),H=Symbol.for("react.element"),m=Symbol.for("react.fragment"),Ne=Object.prototype.hasOwnProperty,A=T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,Y={key:!0,ref:!0,__self:!0,__source:!0};function ce(fe,W,_e){var ye,ee={},Z=null,We=null;_e!==void 0&&(Z=""+_e),W.key!==void 0&&(Z=""+W.key),W.ref!==void 0&&(We=W.ref);for(ye in W)Ne.call(W,ye)&&!Y.hasOwnProperty(ye)&&(ee[ye]=W[ye]);if(fe&&fe.defaultProps)for(ye in W=fe.defaultProps,W)ee[ye]===void 0&&(ee[ye]=W[ye]);return{$$typeof:H,type:fe,key:Z,ref:We,props:ee,_owner:A.current}}return yr.Fragment=m,yr.jsx=ce,yr.jsxs=ce,yr}var Pa;function Of(){return Pa||(Pa=1,_o.exports=Rf()),_o.exports}var je=Of(),Mf=zo();const Df=Oa(Mf);var zl={},xo={exports:{}},Ie={},Po={exports:{}},No={};/**
+ * @license React
+ * scheduler.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var Na;function If(){return Na||(Na=1,(function(T){function H(S,L){var _=S.length;S.push(L);e:for(;0<_;){var c=_-1>>>1,v=S[c];if(0<A(v,L))S[c]=L,S[_]=v,_=c;else break e}}function m(S){return S.length===0?null:S[0]}function Ne(S){if(S.length===0)return null;var L=S[0],_=S.pop();if(_!==L){S[0]=_;e:for(var c=0,v=S.length,O=v>>>1;c<O;){var D=2*(c+1)-1,j=S[D],F=D+1,Q=S[F];if(0>A(j,_))F<v&&0>A(Q,j)?(S[c]=Q,S[F]=_,c=F):(S[c]=j,S[D]=_,c=D);else if(F<v&&0>A(Q,_))S[c]=Q,S[F]=_,c=F;else break e}}return L}function A(S,L){var _=S.sortIndex-L.sortIndex;return _!==0?_:S.id-L.id}if(typeof performance=="object"&&typeof performance.now=="function"){var Y=performance;T.unstable_now=function(){return Y.now()}}else{var ce=Date,fe=ce.now();T.unstable_now=function(){return ce.now()-fe}}var W=[],_e=[],ye=1,ee=null,Z=3,We=!1,$e=!1,J=!1,$=typeof setTimeout=="function"?setTimeout:null,vt=typeof clearTimeout=="function"?clearTimeout:null,st=typeof setImmediate<"u"?setImmediate:null;typeof navigator<"u"&&navigator.scheduling!==void 0&&navigator.scheduling.isInputPending!==void 0&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function qe(S){for(var L=m(_e);L!==null;){if(L.callback===null)Ne(_e);else if(L.startTime<=S)Ne(_e),L.sortIndex=L.expirationTime,H(W,L);else break;L=m(_e)}}function ge(S){if(J=!1,qe(S),!$e)if(m(W)!==null)$e=!0,Le(be);else{var L=m(_e);L!==null&&re(ge,L.startTime-S)}}function be(S,L){$e=!1,J&&(J=!1,vt(Qe),Qe=-1),We=!0;var _=Z;try{for(qe(L),ee=m(W);ee!==null&&(!(ee.expirationTime>L)||S&&!Kt());){var c=ee.callback;if(typeof c=="function"){ee.callback=null,Z=ee.priorityLevel;var v=c(ee.expirationTime<=L);L=T.unstable_now(),typeof v=="function"?ee.callback=v:ee===m(W)&&Ne(W),qe(L)}else Ne(W);ee=m(W)}if(ee!==null)var O=!0;else{var D=m(_e);D!==null&&re(ge,D.startTime-L),O=!1}return O}finally{ee=null,Z=_,We=!1}}var Ce=!1,ze=null,Qe=-1,Pt=5,yt=-1;function Kt(){return!(T.unstable_now()-yt<Pt)}function at(){if(ze!==null){var S=T.unstable_now();yt=S;var L=!0;try{L=ze(!0,S)}finally{L?Fe():(Ce=!1,ze=null)}}else Ce=!1}var Fe;if(typeof st=="function")Fe=function(){st(at)};else if(typeof MessageChannel<"u"){var et=new MessageChannel,ct=et.port2;et.port1.onmessage=at,Fe=function(){ct.postMessage(null)}}else Fe=function(){$(at,0)};function Le(S){ze=S,Ce||(Ce=!0,Fe())}function re(S,L){Qe=$(function(){S(T.unstable_now())},L)}T.unstable_IdlePriority=5,T.unstable_ImmediatePriority=1,T.unstable_LowPriority=4,T.unstable_NormalPriority=3,T.unstable_Profiling=null,T.unstable_UserBlockingPriority=2,T.unstable_cancelCallback=function(S){S.callback=null},T.unstable_continueExecution=function(){$e||We||($e=!0,Le(be))},T.unstable_forceFrameRate=function(S){0>S||125<S?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):Pt=0<S?Math.floor(1e3/S):5},T.unstable_getCurrentPriorityLevel=function(){return Z},T.unstable_getFirstCallbackNode=function(){return m(W)},T.unstable_next=function(S){switch(Z){case 1:case 2:case 3:var L=3;break;default:L=Z}var _=Z;Z=L;try{return S()}finally{Z=_}},T.unstable_pauseExecution=function(){},T.unstable_requestPaint=function(){},T.unstable_runWithPriority=function(S,L){switch(S){case 1:case 2:case 3:case 4:case 5:break;default:S=3}var _=Z;Z=S;try{return L()}finally{Z=_}},T.unstable_scheduleCallback=function(S,L,_){var c=T.unstable_now();switch(typeof _=="object"&&_!==null?(_=_.delay,_=typeof _=="number"&&0<_?c+_:c):_=c,S){case 1:var v=-1;break;case 2:v=250;break;case 5:v=1073741823;break;case 4:v=1e4;break;default:v=5e3}return v=_+v,S={id:ye++,callback:L,priorityLevel:S,startTime:_,expirationTime:v,sortIndex:-1},_>c?(S.sortIndex=_,H(_e,S),m(W)===null&&S===m(_e)&&(J?(vt(Qe),Qe=-1):J=!0,re(ge,_-c))):(S.sortIndex=v,H(W,S),$e||We||($e=!0,Le(be))),S},T.unstable_shouldYield=Kt,T.unstable_wrapCallback=function(S){var L=Z;return function(){var _=Z;Z=L;try{return S.apply(this,arguments)}finally{Z=_}}}})(No)),No}var za;function jf(){return za||(za=1,Po.exports=If()),Po.exports}/**
+ * @license React
+ * react-dom.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */var La;function Ff(){if(La)return Ie;La=1;var T=zo(),H=jf();function m(e){for(var t="https://reactjs.org/docs/error-decoder.html?invariant="+e,n=1;n<arguments.length;n++)t+="&args[]="+encodeURIComponent(arguments[n]);return"Minified React error #"+e+"; visit "+t+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var Ne=new Set,A={};function Y(e,t){ce(e,t),ce(e+"Capture",t)}function ce(e,t){for(A[e]=t,e=0;e<t.length;e++)Ne.add(t[e])}var fe=!(typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"),W=Object.prototype.hasOwnProperty,_e=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,ye={},ee={};function Z(e){return W.call(ee,e)?!0:W.call(ye,e)?!1:_e.test(e)?ee[e]=!0:(ye[e]=!0,!1)}function We(e,t,n,r){if(n!==null&&n.type===0)return!1;switch(typeof t){case"function":case"symbol":return!0;case"boolean":return r?!1:n!==null?!n.acceptsBooleans:(e=e.toLowerCase().slice(0,5),e!=="data-"&&e!=="aria-");default:return!1}}function $e(e,t,n,r){if(t===null||typeof t>"u"||We(e,t,n,r))return!0;if(r)return!1;if(n!==null)switch(n.type){case 3:return!t;case 4:return t===!1;case 5:return isNaN(t);case 6:return isNaN(t)||1>t}return!1}function J(e,t,n,r,l,u,o){this.acceptsBooleans=t===2||t===3||t===4,this.attributeName=r,this.attributeNamespace=l,this.mustUseProperty=n,this.propertyName=e,this.type=t,this.sanitizeURL=u,this.removeEmptyString=o}var $={};"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(e){$[e]=new J(e,0,!1,e,null,!1,!1)}),[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(e){var t=e[0];$[t]=new J(t,1,!1,e[1],null,!1,!1)}),["contentEditable","draggable","spellCheck","value"].forEach(function(e){$[e]=new J(e,2,!1,e.toLowerCase(),null,!1,!1)}),["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(e){$[e]=new J(e,2,!1,e,null,!1,!1)}),"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(e){$[e]=new J(e,3,!1,e.toLowerCase(),null,!1,!1)}),["checked","multiple","muted","selected"].forEach(function(e){$[e]=new J(e,3,!0,e,null,!1,!1)}),["capture","download"].forEach(function(e){$[e]=new J(e,4,!1,e,null,!1,!1)}),["cols","rows","size","span"].forEach(function(e){$[e]=new J(e,6,!1,e,null,!1,!1)}),["rowSpan","start"].forEach(function(e){$[e]=new J(e,5,!1,e.toLowerCase(),null,!1,!1)});var vt=/[\-:]([a-z])/g;function st(e){return e[1].toUpperCase()}"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(e){var t=e.replace(vt,st);$[t]=new J(t,1,!1,e,null,!1,!1)}),"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(e){var t=e.replace(vt,st);$[t]=new J(t,1,!1,e,"http://www.w3.org/1999/xlink",!1,!1)}),["xml:base","xml:lang","xml:space"].forEach(function(e){var t=e.replace(vt,st);$[t]=new J(t,1,!1,e,"http://www.w3.org/XML/1998/namespace",!1,!1)}),["tabIndex","crossOrigin"].forEach(function(e){$[e]=new J(e,1,!1,e.toLowerCase(),null,!1,!1)}),$.xlinkHref=new J("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1),["src","href","action","formAction"].forEach(function(e){$[e]=new J(e,1,!1,e.toLowerCase(),null,!0,!0)});function qe(e,t,n,r){var l=$.hasOwnProperty(t)?$[t]:null;(l!==null?l.type!==0:r||!(2<t.length)||t[0]!=="o"&&t[0]!=="O"||t[1]!=="n"&&t[1]!=="N")&&($e(t,n,l,r)&&(n=null),r||l===null?Z(t)&&(n===null?e.removeAttribute(t):e.setAttribute(t,""+n)):l.mustUseProperty?e[l.propertyName]=n===null?l.type===3?!1:"":n:(t=l.attributeName,r=l.attributeNamespace,n===null?e.removeAttribute(t):(l=l.type,n=l===3||l===4&&n===!0?"":""+n,r?e.setAttributeNS(r,t,n):e.setAttribute(t,n))))}var ge=T.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,be=Symbol.for("react.element"),Ce=Symbol.for("react.portal"),ze=Symbol.for("react.fragment"),Qe=Symbol.for("react.strict_mode"),Pt=Symbol.for("react.profiler"),yt=Symbol.for("react.provider"),Kt=Symbol.for("react.context"),at=Symbol.for("react.forward_ref"),Fe=Symbol.for("react.suspense"),et=Symbol.for("react.suspense_list"),ct=Symbol.for("react.memo"),Le=Symbol.for("react.lazy"),re=Symbol.for("react.offscreen"),S=Symbol.iterator;function L(e){return e===null||typeof e!="object"?null:(e=S&&e[S]||e["@@iterator"],typeof e=="function"?e:null)}var _=Object.assign,c;function v(e){if(c===void 0)try{throw Error()}catch(n){var t=n.stack.trim().match(/\n( *(at )?)/);c=t&&t[1]||""}return`
+`+c+e}var O=!1;function D(e,t){if(!e||O)return"";O=!0;var n=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(t)if(t=function(){throw Error()},Object.defineProperty(t.prototype,"props",{set:function(){throw Error()}}),typeof Reflect=="object"&&Reflect.construct){try{Reflect.construct(t,[])}catch(p){var r=p}Reflect.construct(e,[],t)}else{try{t.call()}catch(p){r=p}e.call(t.prototype)}else{try{throw Error()}catch(p){r=p}e()}}catch(p){if(p&&r&&typeof p.stack=="string"){for(var l=p.stack.split(`
+`),u=r.stack.split(`
+`),o=l.length-1,i=u.length-1;1<=o&&0<=i&&l[o]!==u[i];)i--;for(;1<=o&&0<=i;o--,i--)if(l[o]!==u[i]){if(o!==1||i!==1)do if(o--,i--,0>i||l[o]!==u[i]){var s=`
+`+l[o].replace(" at new "," at ");return e.displayName&&s.includes("<anonymous>")&&(s=s.replace("<anonymous>",e.displayName)),s}while(1<=o&&0<=i);break}}}finally{O=!1,Error.prepareStackTrace=n}return(e=e?e.displayName||e.name:"")?v(e):""}function j(e){switch(e.tag){case 5:return v(e.type);case 16:return v("Lazy");case 13:return v("Suspense");case 19:return v("SuspenseList");case 0:case 2:case 15:return e=D(e.type,!1),e;case 11:return e=D(e.type.render,!1),e;case 1:return e=D(e.type,!0),e;default:return""}}function F(e){if(e==null)return null;if(typeof e=="function")return e.displayName||e.name||null;if(typeof e=="string")return e;switch(e){case ze:return"Fragment";case Ce:return"Portal";case Pt:return"Profiler";case Qe:return"StrictMode";case Fe:return"Suspense";case et:return"SuspenseList"}if(typeof e=="object")switch(e.$$typeof){case Kt:return(e.displayName||"Context")+".Consumer";case yt:return(e._context.displayName||"Context")+".Provider";case at:var t=e.render;return e=e.displayName,e||(e=t.displayName||t.name||"",e=e!==""?"ForwardRef("+e+")":"ForwardRef"),e;case ct:return t=e.displayName||null,t!==null?t:F(e.type)||"Memo";case Le:t=e._payload,e=e._init;try{return F(e(t))}catch{}}return null}function Q(e){var t=e.type;switch(e.tag){case 24:return"Cache";case 9:return(t.displayName||"Context")+".Consumer";case 10:return(t._context.displayName||"Context")+".Provider";case 18:return"DehydratedFragment";case 11:return e=t.render,e=e.displayName||e.name||"",t.displayName||(e!==""?"ForwardRef("+e+")":"ForwardRef");case 7:return"Fragment";case 5:return t;case 4:return"Portal";case 3:return"Root";case 6:return"Text";case 16:return F(t);case 8:return t===Qe?"StrictMode":"Mode";case 22:return"Offscreen";case 12:return"Profiler";case 21:return"Scope";case 13:return"Suspense";case 19:return"SuspenseList";case 25:return"TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if(typeof t=="function")return t.displayName||t.name||null;if(typeof t=="string")return t}return null}function V(e){switch(typeof e){case"boolean":case"number":case"string":case"undefined":return e;case"object":return e;default:return""}}function q(e){var t=e.type;return(e=e.nodeName)&&e.toLowerCase()==="input"&&(t==="checkbox"||t==="radio")}function Ue(e){var t=q(e)?"checked":"value",n=Object.getOwnPropertyDescriptor(e.constructor.prototype,t),r=""+e[t];if(!e.hasOwnProperty(t)&&typeof n<"u"&&typeof n.get=="function"&&typeof n.set=="function"){var l=n.get,u=n.set;return Object.defineProperty(e,t,{configurable:!0,get:function(){return l.call(this)},set:function(o){r=""+o,u.call(this,o)}}),Object.defineProperty(e,t,{enumerable:n.enumerable}),{getValue:function(){return r},setValue:function(o){r=""+o},stopTracking:function(){e._valueTracker=null,delete e[t]}}}}function gr(e){e._valueTracker||(e._valueTracker=Ue(e))}function Lo(e){if(!e)return!1;var t=e._valueTracker;if(!t)return!0;var n=t.getValue(),r="";return e&&(r=q(e)?e.checked?"true":"false":e.value),e=r,e!==n?(t.setValue(e),!0):!1}function wr(e){if(e=e||(typeof document<"u"?document:void 0),typeof e>"u")return null;try{return e.activeElement||e.body}catch{return e.body}}function Ll(e,t){var n=t.checked;return _({},t,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:n??e._wrapperState.initialChecked})}function To(e,t){var n=t.defaultValue==null?"":t.defaultValue,r=t.checked!=null?t.checked:t.defaultChecked;n=V(t.value!=null?t.value:n),e._wrapperState={initialChecked:r,initialValue:n,controlled:t.type==="checkbox"||t.type==="radio"?t.checked!=null:t.value!=null}}function Ro(e,t){t=t.checked,t!=null&&qe(e,"checked",t,!1)}function Tl(e,t){Ro(e,t);var n=V(t.value),r=t.type;if(n!=null)r==="number"?(n===0&&e.value===""||e.value!=n)&&(e.value=""+n):e.value!==""+n&&(e.value=""+n);else if(r==="submit"||r==="reset"){e.removeAttribute("value");return}t.hasOwnProperty("value")?Rl(e,t.type,n):t.hasOwnProperty("defaultValue")&&Rl(e,t.type,V(t.defaultValue)),t.checked==null&&t.defaultChecked!=null&&(e.defaultChecked=!!t.defaultChecked)}function Oo(e,t,n){if(t.hasOwnProperty("value")||t.hasOwnProperty("defaultValue")){var r=t.type;if(!(r!=="submit"&&r!=="reset"||t.value!==void 0&&t.value!==null))return;t=""+e._wrapperState.initialValue,n||t===e.value||(e.value=t),e.defaultValue=t}n=e.name,n!==""&&(e.name=""),e.defaultChecked=!!e._wrapperState.initialChecked,n!==""&&(e.name=n)}function Rl(e,t,n){(t!=="number"||wr(e.ownerDocument)!==e)&&(n==null?e.defaultValue=""+e._wrapperState.initialValue:e.defaultValue!==""+n&&(e.defaultValue=""+n))}var On=Array.isArray;function on(e,t,n,r){if(e=e.options,t){t={};for(var l=0;l<n.length;l++)t["$"+n[l]]=!0;for(n=0;n<e.length;n++)l=t.hasOwnProperty("$"+e[n].value),e[n].selected!==l&&(e[n].selected=l),l&&r&&(e[n].defaultSelected=!0)}else{for(n=""+V(n),t=null,l=0;l<e.length;l++){if(e[l].value===n){e[l].selected=!0,r&&(e[l].defaultSelected=!0);return}t!==null||e[l].disabled||(t=e[l])}t!==null&&(t.selected=!0)}}function Ol(e,t){if(t.dangerouslySetInnerHTML!=null)throw Error(m(91));return _({},t,{value:void 0,defaultValue:void 0,children:""+e._wrapperState.initialValue})}function Mo(e,t){var n=t.value;if(n==null){if(n=t.children,t=t.defaultValue,n!=null){if(t!=null)throw Error(m(92));if(On(n)){if(1<n.length)throw Error(m(93));n=n[0]}t=n}t==null&&(t=""),n=t}e._wrapperState={initialValue:V(n)}}function Do(e,t){var n=V(t.value),r=V(t.defaultValue);n!=null&&(n=""+n,n!==e.value&&(e.value=n),t.defaultValue==null&&e.defaultValue!==n&&(e.defaultValue=n)),r!=null&&(e.defaultValue=""+r)}function Io(e){var t=e.textContent;t===e._wrapperState.initialValue&&t!==""&&t!==null&&(e.value=t)}function jo(e){switch(e){case"svg":return"http://www.w3.org/2000/svg";case"math":return"http://www.w3.org/1998/Math/MathML";default:return"http://www.w3.org/1999/xhtml"}}function Ml(e,t){return e==null||e==="http://www.w3.org/1999/xhtml"?jo(t):e==="http://www.w3.org/2000/svg"&&t==="foreignObject"?"http://www.w3.org/1999/xhtml":e}var Sr,Fo=(function(e){return typeof MSApp<"u"&&MSApp.execUnsafeLocalFunction?function(t,n,r,l){MSApp.execUnsafeLocalFunction(function(){return e(t,n,r,l)})}:e})(function(e,t){if(e.namespaceURI!=="http://www.w3.org/2000/svg"||"innerHTML"in e)e.innerHTML=t;else{for(Sr=Sr||document.createElement("div"),Sr.innerHTML="<svg>"+t.valueOf().toString()+"</svg>",t=Sr.firstChild;e.firstChild;)e.removeChild(e.firstChild);for(;t.firstChild;)e.appendChild(t.firstChild)}});function Mn(e,t){if(t){var n=e.firstChild;if(n&&n===e.lastChild&&n.nodeType===3){n.nodeValue=t;return}}e.textContent=t}var Dn={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},Ma=["Webkit","ms","Moz","O"];Object.keys(Dn).forEach(function(e){Ma.forEach(function(t){t=t+e.charAt(0).toUpperCase()+e.substring(1),Dn[t]=Dn[e]})});function Uo(e,t,n){return t==null||typeof t=="boolean"||t===""?"":n||typeof t!="number"||t===0||Dn.hasOwnProperty(e)&&Dn[e]?(""+t).trim():t+"px"}function Ao(e,t){e=e.style;for(var n in t)if(t.hasOwnProperty(n)){var r=n.indexOf("--")===0,l=Uo(n,t[n],r);n==="float"&&(n="cssFloat"),r?e.setProperty(n,l):e[n]=l}}var Da=_({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});function Dl(e,t){if(t){if(Da[e]&&(t.children!=null||t.dangerouslySetInnerHTML!=null))throw Error(m(137,e));if(t.dangerouslySetInnerHTML!=null){if(t.children!=null)throw Error(m(60));if(typeof t.dangerouslySetInnerHTML!="object"||!("__html"in t.dangerouslySetInnerHTML))throw Error(m(61))}if(t.style!=null&&typeof t.style!="object")throw Error(m(62))}}function Il(e,t){if(e.indexOf("-")===-1)return typeof t.is=="string";switch(e){case"annotation-xml":case"color-profile":case"font-face":case"font-face-src":case"font-face-uri":case"font-face-format":case"font-face-name":case"missing-glyph":return!1;default:return!0}}var jl=null;function Fl(e){return e=e.target||e.srcElement||window,e.correspondingUseElement&&(e=e.correspondingUseElement),e.nodeType===3?e.parentNode:e}var Ul=null,sn=null,an=null;function Vo(e){if(e=nr(e)){if(typeof Ul!="function")throw Error(m(280));var t=e.stateNode;t&&(t=Wr(t),Ul(e.stateNode,e.type,t))}}function Bo(e){sn?an?an.push(e):an=[e]:sn=e}function Ho(){if(sn){var e=sn,t=an;if(an=sn=null,Vo(e),t)for(e=0;e<t.length;e++)Vo(t[e])}}function Wo(e,t){return e(t)}function $o(){}var Al=!1;function Qo(e,t,n){if(Al)return e(t,n);Al=!0;try{return Wo(e,t,n)}finally{Al=!1,(sn!==null||an!==null)&&($o(),Ho())}}function In(e,t){var n=e.stateNode;if(n===null)return null;var r=Wr(n);if(r===null)return null;n=r[t];e:switch(t){case"onClick":case"onClickCapture":case"onDoubleClick":case"onDoubleClickCapture":case"onMouseDown":case"onMouseDownCapture":case"onMouseMove":case"onMouseMoveCapture":case"onMouseUp":case"onMouseUpCapture":case"onMouseEnter":(r=!r.disabled)||(e=e.type,r=!(e==="button"||e==="input"||e==="select"||e==="textarea")),e=!r;break e;default:e=!1}if(e)return null;if(n&&typeof n!="function")throw Error(m(231,t,typeof n));return n}var Vl=!1;if(fe)try{var jn={};Object.defineProperty(jn,"passive",{get:function(){Vl=!0}}),window.addEventListener("test",jn,jn),window.removeEventListener("test",jn,jn)}catch{Vl=!1}function Ia(e,t,n,r,l,u,o,i,s){var p=Array.prototype.slice.call(arguments,3);try{t.apply(n,p)}catch(y){this.onError(y)}}var Fn=!1,kr=null,Er=!1,Bl=null,ja={onError:function(e){Fn=!0,kr=e}};function Fa(e,t,n,r,l,u,o,i,s){Fn=!1,kr=null,Ia.apply(ja,arguments)}function Ua(e,t,n,r,l,u,o,i,s){if(Fa.apply(this,arguments),Fn){if(Fn){var p=kr;Fn=!1,kr=null}else throw Error(m(198));Er||(Er=!0,Bl=p)}}function Yt(e){var t=e,n=e;if(e.alternate)for(;t.return;)t=t.return;else{e=t;do t=e,(t.flags&4098)!==0&&(n=t.return),e=t.return;while(e)}return t.tag===3?n:null}function Ko(e){if(e.tag===13){var t=e.memoizedState;if(t===null&&(e=e.alternate,e!==null&&(t=e.memoizedState)),t!==null)return t.dehydrated}return null}function Yo(e){if(Yt(e)!==e)throw Error(m(188))}function Aa(e){var t=e.alternate;if(!t){if(t=Yt(e),t===null)throw Error(m(188));return t!==e?null:e}for(var n=e,r=t;;){var l=n.return;if(l===null)break;var u=l.alternate;if(u===null){if(r=l.return,r!==null){n=r;continue}break}if(l.child===u.child){for(u=l.child;u;){if(u===n)return Yo(l),e;if(u===r)return Yo(l),t;u=u.sibling}throw Error(m(188))}if(n.return!==r.return)n=l,r=u;else{for(var o=!1,i=l.child;i;){if(i===n){o=!0,n=l,r=u;break}if(i===r){o=!0,r=l,n=u;break}i=i.sibling}if(!o){for(i=u.child;i;){if(i===n){o=!0,n=u,r=l;break}if(i===r){o=!0,r=u,n=l;break}i=i.sibling}if(!o)throw Error(m(189))}}if(n.alternate!==r)throw Error(m(190))}if(n.tag!==3)throw Error(m(188));return n.stateNode.current===n?e:t}function Xo(e){return e=Aa(e),e!==null?Go(e):null}function Go(e){if(e.tag===5||e.tag===6)return e;for(e=e.child;e!==null;){var t=Go(e);if(t!==null)return t;e=e.sibling}return null}var Zo=H.unstable_scheduleCallback,Jo=H.unstable_cancelCallback,Va=H.unstable_shouldYield,Ba=H.unstable_requestPaint,ue=H.unstable_now,Ha=H.unstable_getCurrentPriorityLevel,Hl=H.unstable_ImmediatePriority,qo=H.unstable_UserBlockingPriority,_r=H.unstable_NormalPriority,Wa=H.unstable_LowPriority,bo=H.unstable_IdlePriority,Cr=null,ft=null;function $a(e){if(ft&&typeof ft.onCommitFiberRoot=="function")try{ft.onCommitFiberRoot(Cr,e,void 0,(e.current.flags&128)===128)}catch{}}var tt=Math.clz32?Math.clz32:Ya,Qa=Math.log,Ka=Math.LN2;function Ya(e){return e>>>=0,e===0?32:31-(Qa(e)/Ka|0)|0}var xr=64,Pr=4194304;function Un(e){switch(e&-e){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return e&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return e&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;default:return e}}function Nr(e,t){var n=e.pendingLanes;if(n===0)return 0;var r=0,l=e.suspendedLanes,u=e.pingedLanes,o=n&268435455;if(o!==0){var i=o&~l;i!==0?r=Un(i):(u&=o,u!==0&&(r=Un(u)))}else o=n&~l,o!==0?r=Un(o):u!==0&&(r=Un(u));if(r===0)return 0;if(t!==0&&t!==r&&(t&l)===0&&(l=r&-r,u=t&-t,l>=u||l===16&&(u&4194240)!==0))return t;if((r&4)!==0&&(r|=n&16),t=e.entangledLanes,t!==0)for(e=e.entanglements,t&=r;0<t;)n=31-tt(t),l=1<<n,r|=e[n],t&=~l;return r}function Xa(e,t){switch(e){case 1:case 2:case 4:return t+250;case 8:case 16:case 32:case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return t+5e3;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return-1;case 134217728:case 268435456:case 536870912:case 1073741824:return-1;default:return-1}}function Ga(e,t){for(var n=e.suspendedLanes,r=e.pingedLanes,l=e.expirationTimes,u=e.pendingLanes;0<u;){var o=31-tt(u),i=1<<o,s=l[o];s===-1?((i&n)===0||(i&r)!==0)&&(l[o]=Xa(i,t)):s<=t&&(e.expiredLanes|=i),u&=~i}}function Wl(e){return e=e.pendingLanes&-1073741825,e!==0?e:e&1073741824?1073741824:0}function ei(){var e=xr;return xr<<=1,(xr&4194240)===0&&(xr=64),e}function $l(e){for(var t=[],n=0;31>n;n++)t.push(e);return t}function An(e,t,n){e.pendingLanes|=t,t!==536870912&&(e.suspendedLanes=0,e.pingedLanes=0),e=e.eventTimes,t=31-tt(t),e[t]=n}function Za(e,t){var n=e.pendingLanes&~t;e.pendingLanes=t,e.suspendedLanes=0,e.pingedLanes=0,e.expiredLanes&=t,e.mutableReadLanes&=t,e.entangledLanes&=t,t=e.entanglements;var r=e.eventTimes;for(e=e.expirationTimes;0<n;){var l=31-tt(n),u=1<<l;t[l]=0,r[l]=-1,e[l]=-1,n&=~u}}function Ql(e,t){var n=e.entangledLanes|=t;for(e=e.entanglements;n;){var r=31-tt(n),l=1<<r;l&t|e[r]&t&&(e[r]|=t),n&=~l}}var B=0;function ti(e){return e&=-e,1<e?4<e?(e&268435455)!==0?16:536870912:4:1}var ni,Kl,ri,li,ui,Yl=!1,zr=[],Nt=null,zt=null,Lt=null,Vn=new Map,Bn=new Map,Tt=[],Ja="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");function oi(e,t){switch(e){case"focusin":case"focusout":Nt=null;break;case"dragenter":case"dragleave":zt=null;break;case"mouseover":case"mouseout":Lt=null;break;case"pointerover":case"pointerout":Vn.delete(t.pointerId);break;case"gotpointercapture":case"lostpointercapture":Bn.delete(t.pointerId)}}function Hn(e,t,n,r,l,u){return e===null||e.nativeEvent!==u?(e={blockedOn:t,domEventName:n,eventSystemFlags:r,nativeEvent:u,targetContainers:[l]},t!==null&&(t=nr(t),t!==null&&Kl(t)),e):(e.eventSystemFlags|=r,t=e.targetContainers,l!==null&&t.indexOf(l)===-1&&t.push(l),e)}function qa(e,t,n,r,l){switch(t){case"focusin":return Nt=Hn(Nt,e,t,n,r,l),!0;case"dragenter":return zt=Hn(zt,e,t,n,r,l),!0;case"mouseover":return Lt=Hn(Lt,e,t,n,r,l),!0;case"pointerover":var u=l.pointerId;return Vn.set(u,Hn(Vn.get(u)||null,e,t,n,r,l)),!0;case"gotpointercapture":return u=l.pointerId,Bn.set(u,Hn(Bn.get(u)||null,e,t,n,r,l)),!0}return!1}function ii(e){var t=Xt(e.target);if(t!==null){var n=Yt(t);if(n!==null){if(t=n.tag,t===13){if(t=Ko(n),t!==null){e.blockedOn=t,ui(e.priority,function(){ri(n)});return}}else if(t===3&&n.stateNode.current.memoizedState.isDehydrated){e.blockedOn=n.tag===3?n.stateNode.containerInfo:null;return}}}e.blockedOn=null}function Lr(e){if(e.blockedOn!==null)return!1;for(var t=e.targetContainers;0<t.length;){var n=Gl(e.domEventName,e.eventSystemFlags,t[0],e.nativeEvent);if(n===null){n=e.nativeEvent;var r=new n.constructor(n.type,n);jl=r,n.target.dispatchEvent(r),jl=null}else return t=nr(n),t!==null&&Kl(t),e.blockedOn=n,!1;t.shift()}return!0}function si(e,t,n){Lr(e)&&n.delete(t)}function ba(){Yl=!1,Nt!==null&&Lr(Nt)&&(Nt=null),zt!==null&&Lr(zt)&&(zt=null),Lt!==null&&Lr(Lt)&&(Lt=null),Vn.forEach(si),Bn.forEach(si)}function Wn(e,t){e.blockedOn===t&&(e.blockedOn=null,Yl||(Yl=!0,H.unstable_scheduleCallback(H.unstable_NormalPriority,ba)))}function $n(e){function t(l){return Wn(l,e)}if(0<zr.length){Wn(zr[0],e);for(var n=1;n<zr.length;n++){var r=zr[n];r.blockedOn===e&&(r.blockedOn=null)}}for(Nt!==null&&Wn(Nt,e),zt!==null&&Wn(zt,e),Lt!==null&&Wn(Lt,e),Vn.forEach(t),Bn.forEach(t),n=0;n<Tt.length;n++)r=Tt[n],r.blockedOn===e&&(r.blockedOn=null);for(;0<Tt.length&&(n=Tt[0],n.blockedOn===null);)ii(n),n.blockedOn===null&&Tt.shift()}var cn=ge.ReactCurrentBatchConfig,Tr=!0;function ec(e,t,n,r){var l=B,u=cn.transition;cn.transition=null;try{B=1,Xl(e,t,n,r)}finally{B=l,cn.transition=u}}function tc(e,t,n,r){var l=B,u=cn.transition;cn.transition=null;try{B=4,Xl(e,t,n,r)}finally{B=l,cn.transition=u}}function Xl(e,t,n,r){if(Tr){var l=Gl(e,t,n,r);if(l===null)du(e,t,r,Rr,n),oi(e,r);else if(qa(l,e,t,n,r))r.stopPropagation();else if(oi(e,r),t&4&&-1<Ja.indexOf(e)){for(;l!==null;){var u=nr(l);if(u!==null&&ni(u),u=Gl(e,t,n,r),u===null&&du(e,t,r,Rr,n),u===l)break;l=u}l!==null&&r.stopPropagation()}else du(e,t,r,null,n)}}var Rr=null;function Gl(e,t,n,r){if(Rr=null,e=Fl(r),e=Xt(e),e!==null)if(t=Yt(e),t===null)e=null;else if(n=t.tag,n===13){if(e=Ko(t),e!==null)return e;e=null}else if(n===3){if(t.stateNode.current.memoizedState.isDehydrated)return t.tag===3?t.stateNode.containerInfo:null;e=null}else t!==e&&(e=null);return Rr=e,null}function ai(e){switch(e){case"cancel":case"click":case"close":case"contextmenu":case"copy":case"cut":case"auxclick":case"dblclick":case"dragend":case"dragstart":case"drop":case"focusin":case"focusout":case"input":case"invalid":case"keydown":case"keypress":case"keyup":case"mousedown":case"mouseup":case"paste":case"pause":case"play":case"pointercancel":case"pointerdown":case"pointerup":case"ratechange":case"reset":case"resize":case"seeked":case"submit":case"touchcancel":case"touchend":case"touchstart":case"volumechange":case"change":case"selectionchange":case"textInput":case"compositionstart":case"compositionend":case"compositionupdate":case"beforeblur":case"afterblur":case"beforeinput":case"blur":case"fullscreenchange":case"focus":case"hashchange":case"popstate":case"select":case"selectstart":return 1;case"drag":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"mousemove":case"mouseout":case"mouseover":case"pointermove":case"pointerout":case"pointerover":case"scroll":case"toggle":case"touchmove":case"wheel":case"mouseenter":case"mouseleave":case"pointerenter":case"pointerleave":return 4;case"message":switch(Ha()){case Hl:return 1;case qo:return 4;case _r:case Wa:return 16;case bo:return 536870912;default:return 16}default:return 16}}var Rt=null,Zl=null,Or=null;function ci(){if(Or)return Or;var e,t=Zl,n=t.length,r,l="value"in Rt?Rt.value:Rt.textContent,u=l.length;for(e=0;e<n&&t[e]===l[e];e++);var o=n-e;for(r=1;r<=o&&t[n-r]===l[u-r];r++);return Or=l.slice(e,1<r?1-r:void 0)}function Mr(e){var t=e.keyCode;return"charCode"in e?(e=e.charCode,e===0&&t===13&&(e=13)):e=t,e===10&&(e=13),32<=e||e===13?e:0}function Dr(){return!0}function fi(){return!1}function Ae(e){function t(n,r,l,u,o){this._reactName=n,this._targetInst=l,this.type=r,this.nativeEvent=u,this.target=o,this.currentTarget=null;for(var i in e)e.hasOwnProperty(i)&&(n=e[i],this[i]=n?n(u):u[i]);return this.isDefaultPrevented=(u.defaultPrevented!=null?u.defaultPrevented:u.returnValue===!1)?Dr:fi,this.isPropagationStopped=fi,this}return _(t.prototype,{preventDefault:function(){this.defaultPrevented=!0;var n=this.nativeEvent;n&&(n.preventDefault?n.preventDefault():typeof n.returnValue!="unknown"&&(n.returnValue=!1),this.isDefaultPrevented=Dr)},stopPropagation:function(){var n=this.nativeEvent;n&&(n.stopPropagation?n.stopPropagation():typeof n.cancelBubble!="unknown"&&(n.cancelBubble=!0),this.isPropagationStopped=Dr)},persist:function(){},isPersistent:Dr}),t}var fn={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(e){return e.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},Jl=Ae(fn),Qn=_({},fn,{view:0,detail:0}),nc=Ae(Qn),ql,bl,Kn,Ir=_({},Qn,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:tu,button:0,buttons:0,relatedTarget:function(e){return e.relatedTarget===void 0?e.fromElement===e.srcElement?e.toElement:e.fromElement:e.relatedTarget},movementX:function(e){return"movementX"in e?e.movementX:(e!==Kn&&(Kn&&e.type==="mousemove"?(ql=e.screenX-Kn.screenX,bl=e.screenY-Kn.screenY):bl=ql=0,Kn=e),ql)},movementY:function(e){return"movementY"in e?e.movementY:bl}}),di=Ae(Ir),rc=_({},Ir,{dataTransfer:0}),lc=Ae(rc),uc=_({},Qn,{relatedTarget:0}),eu=Ae(uc),oc=_({},fn,{animationName:0,elapsedTime:0,pseudoElement:0}),ic=Ae(oc),sc=_({},fn,{clipboardData:function(e){return"clipboardData"in e?e.clipboardData:window.clipboardData}}),ac=Ae(sc),cc=_({},fn,{data:0}),pi=Ae(cc),fc={Esc:"Escape",Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},dc={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},pc={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function mc(e){var t=this.nativeEvent;return t.getModifierState?t.getModifierState(e):(e=pc[e])?!!t[e]:!1}function tu(){return mc}var hc=_({},Qn,{key:function(e){if(e.key){var t=fc[e.key]||e.key;if(t!=="Unidentified")return t}return e.type==="keypress"?(e=Mr(e),e===13?"Enter":String.fromCharCode(e)):e.type==="keydown"||e.type==="keyup"?dc[e.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:tu,charCode:function(e){return e.type==="keypress"?Mr(e):0},keyCode:function(e){return e.type==="keydown"||e.type==="keyup"?e.keyCode:0},which:function(e){return e.type==="keypress"?Mr(e):e.type==="keydown"||e.type==="keyup"?e.keyCode:0}}),vc=Ae(hc),yc=_({},Ir,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),mi=Ae(yc),gc=_({},Qn,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:tu}),wc=Ae(gc),Sc=_({},fn,{propertyName:0,elapsedTime:0,pseudoElement:0}),kc=Ae(Sc),Ec=_({},Ir,{deltaX:function(e){return"deltaX"in e?e.deltaX:"wheelDeltaX"in e?-e.wheelDeltaX:0},deltaY:function(e){return"deltaY"in e?e.deltaY:"wheelDeltaY"in e?-e.wheelDeltaY:"wheelDelta"in e?-e.wheelDelta:0},deltaZ:0,deltaMode:0}),_c=Ae(Ec),Cc=[9,13,27,32],nu=fe&&"CompositionEvent"in window,Yn=null;fe&&"documentMode"in document&&(Yn=document.documentMode);var xc=fe&&"TextEvent"in window&&!Yn,hi=fe&&(!nu||Yn&&8<Yn&&11>=Yn),vi=" ",yi=!1;function gi(e,t){switch(e){case"keyup":return Cc.indexOf(t.keyCode)!==-1;case"keydown":return t.keyCode!==229;case"keypress":case"mousedown":case"focusout":return!0;default:return!1}}function wi(e){return e=e.detail,typeof e=="object"&&"data"in e?e.data:null}var dn=!1;function Pc(e,t){switch(e){case"compositionend":return wi(t);case"keypress":return t.which!==32?null:(yi=!0,vi);case"textInput":return e=t.data,e===vi&&yi?null:e;default:return null}}function Nc(e,t){if(dn)return e==="compositionend"||!nu&&gi(e,t)?(e=ci(),Or=Zl=Rt=null,dn=!1,e):null;switch(e){case"paste":return null;case"keypress":if(!(t.ctrlKey||t.altKey||t.metaKey)||t.ctrlKey&&t.altKey){if(t.char&&1<t.char.length)return t.char;if(t.which)return String.fromCharCode(t.which)}return null;case"compositionend":return hi&&t.locale!=="ko"?null:t.data;default:return null}}var zc={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function Si(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t==="input"?!!zc[e.type]:t==="textarea"}function ki(e,t,n,r){Bo(r),t=Vr(t,"onChange"),0<t.length&&(n=new Jl("onChange","change",null,n,r),e.push({event:n,listeners:t}))}var Xn=null,Gn=null;function Lc(e){Ai(e,0)}function jr(e){var t=yn(e);if(Lo(t))return e}function Tc(e,t){if(e==="change")return t}var Ei=!1;if(fe){var ru;if(fe){var lu="oninput"in document;if(!lu){var _i=document.createElement("div");_i.setAttribute("oninput","return;"),lu=typeof _i.oninput=="function"}ru=lu}else ru=!1;Ei=ru&&(!document.documentMode||9<document.documentMode)}function Ci(){Xn&&(Xn.detachEvent("onpropertychange",xi),Gn=Xn=null)}function xi(e){if(e.propertyName==="value"&&jr(Gn)){var t=[];ki(t,Gn,e,Fl(e)),Qo(Lc,t)}}function Rc(e,t,n){e==="focusin"?(Ci(),Xn=t,Gn=n,Xn.attachEvent("onpropertychange",xi)):e==="focusout"&&Ci()}function Oc(e){if(e==="selectionchange"||e==="keyup"||e==="keydown")return jr(Gn)}function Mc(e,t){if(e==="click")return jr(t)}function Dc(e,t){if(e==="input"||e==="change")return jr(t)}function Ic(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}var nt=typeof Object.is=="function"?Object.is:Ic;function Zn(e,t){if(nt(e,t))return!0;if(typeof e!="object"||e===null||typeof t!="object"||t===null)return!1;var n=Object.keys(e),r=Object.keys(t);if(n.length!==r.length)return!1;for(r=0;r<n.length;r++){var l=n[r];if(!W.call(t,l)||!nt(e[l],t[l]))return!1}return!0}function Pi(e){for(;e&&e.firstChild;)e=e.firstChild;return e}function Ni(e,t){var n=Pi(e);e=0;for(var r;n;){if(n.nodeType===3){if(r=e+n.textContent.length,e<=t&&r>=t)return{node:n,offset:t-e};e=r}e:{for(;n;){if(n.nextSibling){n=n.nextSibling;break e}n=n.parentNode}n=void 0}n=Pi(n)}}function zi(e,t){return e&&t?e===t?!0:e&&e.nodeType===3?!1:t&&t.nodeType===3?zi(e,t.parentNode):"contains"in e?e.contains(t):e.compareDocumentPosition?!!(e.compareDocumentPosition(t)&16):!1:!1}function Li(){for(var e=window,t=wr();t instanceof e.HTMLIFrameElement;){try{var n=typeof t.contentWindow.location.href=="string"}catch{n=!1}if(n)e=t.contentWindow;else break;t=wr(e.document)}return t}function uu(e){var t=e&&e.nodeName&&e.nodeName.toLowerCase();return t&&(t==="input"&&(e.type==="text"||e.type==="search"||e.type==="tel"||e.type==="url"||e.type==="password")||t==="textarea"||e.contentEditable==="true")}function jc(e){var t=Li(),n=e.focusedElem,r=e.selectionRange;if(t!==n&&n&&n.ownerDocument&&zi(n.ownerDocument.documentElement,n)){if(r!==null&&uu(n)){if(t=r.start,e=r.end,e===void 0&&(e=t),"selectionStart"in n)n.selectionStart=t,n.selectionEnd=Math.min(e,n.value.length);else if(e=(t=n.ownerDocument||document)&&t.defaultView||window,e.getSelection){e=e.getSelection();var l=n.textContent.length,u=Math.min(r.start,l);r=r.end===void 0?u:Math.min(r.end,l),!e.extend&&u>r&&(l=r,r=u,u=l),l=Ni(n,u);var o=Ni(n,r);l&&o&&(e.rangeCount!==1||e.anchorNode!==l.node||e.anchorOffset!==l.offset||e.focusNode!==o.node||e.focusOffset!==o.offset)&&(t=t.createRange(),t.setStart(l.node,l.offset),e.removeAllRanges(),u>r?(e.addRange(t),e.extend(o.node,o.offset)):(t.setEnd(o.node,o.offset),e.addRange(t)))}}for(t=[],e=n;e=e.parentNode;)e.nodeType===1&&t.push({element:e,left:e.scrollLeft,top:e.scrollTop});for(typeof n.focus=="function"&&n.focus(),n=0;n<t.length;n++)e=t[n],e.element.scrollLeft=e.left,e.element.scrollTop=e.top}}var Fc=fe&&"documentMode"in document&&11>=document.documentMode,pn=null,ou=null,Jn=null,iu=!1;function Ti(e,t,n){var r=n.window===n?n.document:n.nodeType===9?n:n.ownerDocument;iu||pn==null||pn!==wr(r)||(r=pn,"selectionStart"in r&&uu(r)?r={start:r.selectionStart,end:r.selectionEnd}:(r=(r.ownerDocument&&r.ownerDocument.defaultView||window).getSelection(),r={anchorNode:r.anchorNode,anchorOffset:r.anchorOffset,focusNode:r.focusNode,focusOffset:r.focusOffset}),Jn&&Zn(Jn,r)||(Jn=r,r=Vr(ou,"onSelect"),0<r.length&&(t=new Jl("onSelect","select",null,t,n),e.push({event:t,listeners:r}),t.target=pn)))}function Fr(e,t){var n={};return n[e.toLowerCase()]=t.toLowerCase(),n["Webkit"+e]="webkit"+t,n["Moz"+e]="moz"+t,n}var mn={animationend:Fr("Animation","AnimationEnd"),animationiteration:Fr("Animation","AnimationIteration"),animationstart:Fr("Animation","AnimationStart"),transitionend:Fr("Transition","TransitionEnd")},su={},Ri={};fe&&(Ri=document.createElement("div").style,"AnimationEvent"in window||(delete mn.animationend.animation,delete mn.animationiteration.animation,delete mn.animationstart.animation),"TransitionEvent"in window||delete mn.transitionend.transition);function Ur(e){if(su[e])return su[e];if(!mn[e])return e;var t=mn[e],n;for(n in t)if(t.hasOwnProperty(n)&&n in Ri)return su[e]=t[n];return e}var Oi=Ur("animationend"),Mi=Ur("animationiteration"),Di=Ur("animationstart"),Ii=Ur("transitionend"),ji=new Map,Fi="abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");function Ot(e,t){ji.set(e,t),Y(t,[e])}for(var au=0;au<Fi.length;au++){var cu=Fi[au],Uc=cu.toLowerCase(),Ac=cu[0].toUpperCase()+cu.slice(1);Ot(Uc,"on"+Ac)}Ot(Oi,"onAnimationEnd"),Ot(Mi,"onAnimationIteration"),Ot(Di,"onAnimationStart"),Ot("dblclick","onDoubleClick"),Ot("focusin","onFocus"),Ot("focusout","onBlur"),Ot(Ii,"onTransitionEnd"),ce("onMouseEnter",["mouseout","mouseover"]),ce("onMouseLeave",["mouseout","mouseover"]),ce("onPointerEnter",["pointerout","pointerover"]),ce("onPointerLeave",["pointerout","pointerover"]),Y("onChange","change click focusin focusout input keydown keyup selectionchange".split(" ")),Y("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" ")),Y("onBeforeInput",["compositionend","keypress","textInput","paste"]),Y("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" ")),Y("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" ")),Y("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var qn="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),Vc=new Set("cancel close invalid load scroll toggle".split(" ").concat(qn));function Ui(e,t,n){var r=e.type||"unknown-event";e.currentTarget=n,Ua(r,t,void 0,e),e.currentTarget=null}function Ai(e,t){t=(t&4)!==0;for(var n=0;n<e.length;n++){var r=e[n],l=r.event;r=r.listeners;e:{var u=void 0;if(t)for(var o=r.length-1;0<=o;o--){var i=r[o],s=i.instance,p=i.currentTarget;if(i=i.listener,s!==u&&l.isPropagationStopped())break e;Ui(l,i,p),u=s}else for(o=0;o<r.length;o++){if(i=r[o],s=i.instance,p=i.currentTarget,i=i.listener,s!==u&&l.isPropagationStopped())break e;Ui(l,i,p),u=s}}}if(Er)throw e=Bl,Er=!1,Bl=null,e}function X(e,t){var n=t[gu];n===void 0&&(n=t[gu]=new Set);var r=e+"__bubble";n.has(r)||(Vi(t,e,2,!1),n.add(r))}function fu(e,t,n){var r=0;t&&(r|=4),Vi(n,e,r,t)}var Ar="_reactListening"+Math.random().toString(36).slice(2);function bn(e){if(!e[Ar]){e[Ar]=!0,Ne.forEach(function(n){n!=="selectionchange"&&(Vc.has(n)||fu(n,!1,e),fu(n,!0,e))});var t=e.nodeType===9?e:e.ownerDocument;t===null||t[Ar]||(t[Ar]=!0,fu("selectionchange",!1,t))}}function Vi(e,t,n,r){switch(ai(t)){case 1:var l=ec;break;case 4:l=tc;break;default:l=Xl}n=l.bind(null,t,n,e),l=void 0,!Vl||t!=="touchstart"&&t!=="touchmove"&&t!=="wheel"||(l=!0),r?l!==void 0?e.addEventListener(t,n,{capture:!0,passive:l}):e.addEventListener(t,n,!0):l!==void 0?e.addEventListener(t,n,{passive:l}):e.addEventListener(t,n,!1)}function du(e,t,n,r,l){var u=r;if((t&1)===0&&(t&2)===0&&r!==null)e:for(;;){if(r===null)return;var o=r.tag;if(o===3||o===4){var i=r.stateNode.containerInfo;if(i===l||i.nodeType===8&&i.parentNode===l)break;if(o===4)for(o=r.return;o!==null;){var s=o.tag;if((s===3||s===4)&&(s=o.stateNode.containerInfo,s===l||s.nodeType===8&&s.parentNode===l))return;o=o.return}for(;i!==null;){if(o=Xt(i),o===null)return;if(s=o.tag,s===5||s===6){r=u=o;continue e}i=i.parentNode}}r=r.return}Qo(function(){var p=u,y=Fl(n),g=[];e:{var h=ji.get(e);if(h!==void 0){var k=Jl,C=e;switch(e){case"keypress":if(Mr(n)===0)break e;case"keydown":case"keyup":k=vc;break;case"focusin":C="focus",k=eu;break;case"focusout":C="blur",k=eu;break;case"beforeblur":case"afterblur":k=eu;break;case"click":if(n.button===2)break e;case"auxclick":case"dblclick":case"mousedown":case"mousemove":case"mouseup":case"mouseout":case"mouseover":case"contextmenu":k=di;break;case"drag":case"dragend":case"dragenter":case"dragexit":case"dragleave":case"dragover":case"dragstart":case"drop":k=lc;break;case"touchcancel":case"touchend":case"touchmove":case"touchstart":k=wc;break;case Oi:case Mi:case Di:k=ic;break;case Ii:k=kc;break;case"scroll":k=nc;break;case"wheel":k=_c;break;case"copy":case"cut":case"paste":k=ac;break;case"gotpointercapture":case"lostpointercapture":case"pointercancel":case"pointerdown":case"pointermove":case"pointerout":case"pointerover":case"pointerup":k=mi}var x=(t&4)!==0,oe=!x&&e==="scroll",f=x?h!==null?h+"Capture":null:h;x=[];for(var a=p,d;a!==null;){d=a;var w=d.stateNode;if(d.tag===5&&w!==null&&(d=w,f!==null&&(w=In(a,f),w!=null&&x.push(er(a,w,d)))),oe)break;a=a.return}0<x.length&&(h=new k(h,C,null,n,y),g.push({event:h,listeners:x}))}}if((t&7)===0){e:{if(h=e==="mouseover"||e==="pointerover",k=e==="mouseout"||e==="pointerout",h&&n!==jl&&(C=n.relatedTarget||n.fromElement)&&(Xt(C)||C[gt]))break e;if((k||h)&&(h=y.window===y?y:(h=y.ownerDocument)?h.defaultView||h.parentWindow:window,k?(C=n.relatedTarget||n.toElement,k=p,C=C?Xt(C):null,C!==null&&(oe=Yt(C),C!==oe||C.tag!==5&&C.tag!==6)&&(C=null)):(k=null,C=p),k!==C)){if(x=di,w="onMouseLeave",f="onMouseEnter",a="mouse",(e==="pointerout"||e==="pointerover")&&(x=mi,w="onPointerLeave",f="onPointerEnter",a="pointer"),oe=k==null?h:yn(k),d=C==null?h:yn(C),h=new x(w,a+"leave",k,n,y),h.target=oe,h.relatedTarget=d,w=null,Xt(y)===p&&(x=new x(f,a+"enter",C,n,y),x.target=d,x.relatedTarget=oe,w=x),oe=w,k&&C)t:{for(x=k,f=C,a=0,d=x;d;d=hn(d))a++;for(d=0,w=f;w;w=hn(w))d++;for(;0<a-d;)x=hn(x),a--;for(;0<d-a;)f=hn(f),d--;for(;a--;){if(x===f||f!==null&&x===f.alternate)break t;x=hn(x),f=hn(f)}x=null}else x=null;k!==null&&Bi(g,h,k,x,!1),C!==null&&oe!==null&&Bi(g,oe,C,x,!0)}}e:{if(h=p?yn(p):window,k=h.nodeName&&h.nodeName.toLowerCase(),k==="select"||k==="input"&&h.type==="file")var P=Tc;else if(Si(h))if(Ei)P=Dc;else{P=Oc;var N=Rc}else(k=h.nodeName)&&k.toLowerCase()==="input"&&(h.type==="checkbox"||h.type==="radio")&&(P=Mc);if(P&&(P=P(e,p))){ki(g,P,n,y);break e}N&&N(e,h,p),e==="focusout"&&(N=h._wrapperState)&&N.controlled&&h.type==="number"&&Rl(h,"number",h.value)}switch(N=p?yn(p):window,e){case"focusin":(Si(N)||N.contentEditable==="true")&&(pn=N,ou=p,Jn=null);break;case"focusout":Jn=ou=pn=null;break;case"mousedown":iu=!0;break;case"contextmenu":case"mouseup":case"dragend":iu=!1,Ti(g,n,y);break;case"selectionchange":if(Fc)break;case"keydown":case"keyup":Ti(g,n,y)}var z;if(nu)e:{switch(e){case"compositionstart":var R="onCompositionStart";break e;case"compositionend":R="onCompositionEnd";break e;case"compositionupdate":R="onCompositionUpdate";break e}R=void 0}else dn?gi(e,n)&&(R="onCompositionEnd"):e==="keydown"&&n.keyCode===229&&(R="onCompositionStart");R&&(hi&&n.locale!=="ko"&&(dn||R!=="onCompositionStart"?R==="onCompositionEnd"&&dn&&(z=ci()):(Rt=y,Zl="value"in Rt?Rt.value:Rt.textContent,dn=!0)),N=Vr(p,R),0<N.length&&(R=new pi(R,e,null,n,y),g.push({event:R,listeners:N}),z?R.data=z:(z=wi(n),z!==null&&(R.data=z)))),(z=xc?Pc(e,n):Nc(e,n))&&(p=Vr(p,"onBeforeInput"),0<p.length&&(y=new pi("onBeforeInput","beforeinput",null,n,y),g.push({event:y,listeners:p}),y.data=z))}Ai(g,t)})}function er(e,t,n){return{instance:e,listener:t,currentTarget:n}}function Vr(e,t){for(var n=t+"Capture",r=[];e!==null;){var l=e,u=l.stateNode;l.tag===5&&u!==null&&(l=u,u=In(e,n),u!=null&&r.unshift(er(e,u,l)),u=In(e,t),u!=null&&r.push(er(e,u,l))),e=e.return}return r}function hn(e){if(e===null)return null;do e=e.return;while(e&&e.tag!==5);return e||null}function Bi(e,t,n,r,l){for(var u=t._reactName,o=[];n!==null&&n!==r;){var i=n,s=i.alternate,p=i.stateNode;if(s!==null&&s===r)break;i.tag===5&&p!==null&&(i=p,l?(s=In(n,u),s!=null&&o.unshift(er(n,s,i))):l||(s=In(n,u),s!=null&&o.push(er(n,s,i)))),n=n.return}o.length!==0&&e.push({event:t,listeners:o})}var Bc=/\r\n?/g,Hc=/\u0000|\uFFFD/g;function Hi(e){return(typeof e=="string"?e:""+e).replace(Bc,`
+`).replace(Hc,"")}function Br(e,t,n){if(t=Hi(t),Hi(e)!==t&&n)throw Error(m(425))}function Hr(){}var pu=null,mu=null;function hu(e,t){return e==="textarea"||e==="noscript"||typeof t.children=="string"||typeof t.children=="number"||typeof t.dangerouslySetInnerHTML=="object"&&t.dangerouslySetInnerHTML!==null&&t.dangerouslySetInnerHTML.__html!=null}var vu=typeof setTimeout=="function"?setTimeout:void 0,Wc=typeof clearTimeout=="function"?clearTimeout:void 0,Wi=typeof Promise=="function"?Promise:void 0,$c=typeof queueMicrotask=="function"?queueMicrotask:typeof Wi<"u"?function(e){return Wi.resolve(null).then(e).catch(Qc)}:vu;function Qc(e){setTimeout(function(){throw e})}function yu(e,t){var n=t,r=0;do{var l=n.nextSibling;if(e.removeChild(n),l&&l.nodeType===8)if(n=l.data,n==="/$"){if(r===0){e.removeChild(l),$n(t);return}r--}else n!=="$"&&n!=="$?"&&n!=="$!"||r++;n=l}while(n);$n(t)}function Mt(e){for(;e!=null;e=e.nextSibling){var t=e.nodeType;if(t===1||t===3)break;if(t===8){if(t=e.data,t==="$"||t==="$!"||t==="$?")break;if(t==="/$")return null}}return e}function $i(e){e=e.previousSibling;for(var t=0;e;){if(e.nodeType===8){var n=e.data;if(n==="$"||n==="$!"||n==="$?"){if(t===0)return e;t--}else n==="/$"&&t++}e=e.previousSibling}return null}var vn=Math.random().toString(36).slice(2),dt="__reactFiber$"+vn,tr="__reactProps$"+vn,gt="__reactContainer$"+vn,gu="__reactEvents$"+vn,Kc="__reactListeners$"+vn,Yc="__reactHandles$"+vn;function Xt(e){var t=e[dt];if(t)return t;for(var n=e.parentNode;n;){if(t=n[gt]||n[dt]){if(n=t.alternate,t.child!==null||n!==null&&n.child!==null)for(e=$i(e);e!==null;){if(n=e[dt])return n;e=$i(e)}return t}e=n,n=e.parentNode}return null}function nr(e){return e=e[dt]||e[gt],!e||e.tag!==5&&e.tag!==6&&e.tag!==13&&e.tag!==3?null:e}function yn(e){if(e.tag===5||e.tag===6)return e.stateNode;throw Error(m(33))}function Wr(e){return e[tr]||null}var wu=[],gn=-1;function Dt(e){return{current:e}}function G(e){0>gn||(e.current=wu[gn],wu[gn]=null,gn--)}function K(e,t){gn++,wu[gn]=e.current,e.current=t}var It={},we=Dt(It),Te=Dt(!1),Gt=It;function wn(e,t){var n=e.type.contextTypes;if(!n)return It;var r=e.stateNode;if(r&&r.__reactInternalMemoizedUnmaskedChildContext===t)return r.__reactInternalMemoizedMaskedChildContext;var l={},u;for(u in n)l[u]=t[u];return r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=t,e.__reactInternalMemoizedMaskedChildContext=l),l}function Re(e){return e=e.childContextTypes,e!=null}function $r(){G(Te),G(we)}function Qi(e,t,n){if(we.current!==It)throw Error(m(168));K(we,t),K(Te,n)}function Ki(e,t,n){var r=e.stateNode;if(t=t.childContextTypes,typeof r.getChildContext!="function")return n;r=r.getChildContext();for(var l in r)if(!(l in t))throw Error(m(108,Q(e)||"Unknown",l));return _({},n,r)}function Qr(e){return e=(e=e.stateNode)&&e.__reactInternalMemoizedMergedChildContext||It,Gt=we.current,K(we,e),K(Te,Te.current),!0}function Yi(e,t,n){var r=e.stateNode;if(!r)throw Error(m(169));n?(e=Ki(e,t,Gt),r.__reactInternalMemoizedMergedChildContext=e,G(Te),G(we),K(we,e)):G(Te),K(Te,n)}var wt=null,Kr=!1,Su=!1;function Xi(e){wt===null?wt=[e]:wt.push(e)}function Xc(e){Kr=!0,Xi(e)}function jt(){if(!Su&&wt!==null){Su=!0;var e=0,t=B;try{var n=wt;for(B=1;e<n.length;e++){var r=n[e];do r=r(!0);while(r!==null)}wt=null,Kr=!1}catch(l){throw wt!==null&&(wt=wt.slice(e+1)),Zo(Hl,jt),l}finally{B=t,Su=!1}}return null}var Sn=[],kn=0,Yr=null,Xr=0,Ke=[],Ye=0,Zt=null,St=1,kt="";function Jt(e,t){Sn[kn++]=Xr,Sn[kn++]=Yr,Yr=e,Xr=t}function Gi(e,t,n){Ke[Ye++]=St,Ke[Ye++]=kt,Ke[Ye++]=Zt,Zt=e;var r=St;e=kt;var l=32-tt(r)-1;r&=~(1<<l),n+=1;var u=32-tt(t)+l;if(30<u){var o=l-l%5;u=(r&(1<<o)-1).toString(32),r>>=o,l-=o,St=1<<32-tt(t)+l|n<<l|r,kt=u+e}else St=1<<u|n<<l|r,kt=e}function ku(e){e.return!==null&&(Jt(e,1),Gi(e,1,0))}function Eu(e){for(;e===Yr;)Yr=Sn[--kn],Sn[kn]=null,Xr=Sn[--kn],Sn[kn]=null;for(;e===Zt;)Zt=Ke[--Ye],Ke[Ye]=null,kt=Ke[--Ye],Ke[Ye]=null,St=Ke[--Ye],Ke[Ye]=null}var Ve=null,Be=null,b=!1,rt=null;function Zi(e,t){var n=Je(5,null,null,0);n.elementType="DELETED",n.stateNode=t,n.return=e,t=e.deletions,t===null?(e.deletions=[n],e.flags|=16):t.push(n)}function Ji(e,t){switch(e.tag){case 5:var n=e.type;return t=t.nodeType!==1||n.toLowerCase()!==t.nodeName.toLowerCase()?null:t,t!==null?(e.stateNode=t,Ve=e,Be=Mt(t.firstChild),!0):!1;case 6:return t=e.pendingProps===""||t.nodeType!==3?null:t,t!==null?(e.stateNode=t,Ve=e,Be=null,!0):!1;case 13:return t=t.nodeType!==8?null:t,t!==null?(n=Zt!==null?{id:St,overflow:kt}:null,e.memoizedState={dehydrated:t,treeContext:n,retryLane:1073741824},n=Je(18,null,null,0),n.stateNode=t,n.return=e,e.child=n,Ve=e,Be=null,!0):!1;default:return!1}}function _u(e){return(e.mode&1)!==0&&(e.flags&128)===0}function Cu(e){if(b){var t=Be;if(t){var n=t;if(!Ji(e,t)){if(_u(e))throw Error(m(418));t=Mt(n.nextSibling);var r=Ve;t&&Ji(e,t)?Zi(r,n):(e.flags=e.flags&-4097|2,b=!1,Ve=e)}}else{if(_u(e))throw Error(m(418));e.flags=e.flags&-4097|2,b=!1,Ve=e}}}function qi(e){for(e=e.return;e!==null&&e.tag!==5&&e.tag!==3&&e.tag!==13;)e=e.return;Ve=e}function Gr(e){if(e!==Ve)return!1;if(!b)return qi(e),b=!0,!1;var t;if((t=e.tag!==3)&&!(t=e.tag!==5)&&(t=e.type,t=t!=="head"&&t!=="body"&&!hu(e.type,e.memoizedProps)),t&&(t=Be)){if(_u(e))throw bi(),Error(m(418));for(;t;)Zi(e,t),t=Mt(t.nextSibling)}if(qi(e),e.tag===13){if(e=e.memoizedState,e=e!==null?e.dehydrated:null,!e)throw Error(m(317));e:{for(e=e.nextSibling,t=0;e;){if(e.nodeType===8){var n=e.data;if(n==="/$"){if(t===0){Be=Mt(e.nextSibling);break e}t--}else n!=="$"&&n!=="$!"&&n!=="$?"||t++}e=e.nextSibling}Be=null}}else Be=Ve?Mt(e.stateNode.nextSibling):null;return!0}function bi(){for(var e=Be;e;)e=Mt(e.nextSibling)}function En(){Be=Ve=null,b=!1}function xu(e){rt===null?rt=[e]:rt.push(e)}var Gc=ge.ReactCurrentBatchConfig;function rr(e,t,n){if(e=n.ref,e!==null&&typeof e!="function"&&typeof e!="object"){if(n._owner){if(n=n._owner,n){if(n.tag!==1)throw Error(m(309));var r=n.stateNode}if(!r)throw Error(m(147,e));var l=r,u=""+e;return t!==null&&t.ref!==null&&typeof t.ref=="function"&&t.ref._stringRef===u?t.ref:(t=function(o){var i=l.refs;o===null?delete i[u]:i[u]=o},t._stringRef=u,t)}if(typeof e!="string")throw Error(m(284));if(!n._owner)throw Error(m(290,e))}return e}function Zr(e,t){throw e=Object.prototype.toString.call(t),Error(m(31,e==="[object Object]"?"object with keys {"+Object.keys(t).join(", ")+"}":e))}function es(e){var t=e._init;return t(e._payload)}function ts(e){function t(f,a){if(e){var d=f.deletions;d===null?(f.deletions=[a],f.flags|=16):d.push(a)}}function n(f,a){if(!e)return null;for(;a!==null;)t(f,a),a=a.sibling;return null}function r(f,a){for(f=new Map;a!==null;)a.key!==null?f.set(a.key,a):f.set(a.index,a),a=a.sibling;return f}function l(f,a){return f=$t(f,a),f.index=0,f.sibling=null,f}function u(f,a,d){return f.index=d,e?(d=f.alternate,d!==null?(d=d.index,d<a?(f.flags|=2,a):d):(f.flags|=2,a)):(f.flags|=1048576,a)}function o(f){return e&&f.alternate===null&&(f.flags|=2),f}function i(f,a,d,w){return a===null||a.tag!==6?(a=yo(d,f.mode,w),a.return=f,a):(a=l(a,d),a.return=f,a)}function s(f,a,d,w){var P=d.type;return P===ze?y(f,a,d.props.children,w,d.key):a!==null&&(a.elementType===P||typeof P=="object"&&P!==null&&P.$$typeof===Le&&es(P)===a.type)?(w=l(a,d.props),w.ref=rr(f,a,d),w.return=f,w):(w=Sl(d.type,d.key,d.props,null,f.mode,w),w.ref=rr(f,a,d),w.return=f,w)}function p(f,a,d,w){return a===null||a.tag!==4||a.stateNode.containerInfo!==d.containerInfo||a.stateNode.implementation!==d.implementation?(a=go(d,f.mode,w),a.return=f,a):(a=l(a,d.children||[]),a.return=f,a)}function y(f,a,d,w,P){return a===null||a.tag!==7?(a=un(d,f.mode,w,P),a.return=f,a):(a=l(a,d),a.return=f,a)}function g(f,a,d){if(typeof a=="string"&&a!==""||typeof a=="number")return a=yo(""+a,f.mode,d),a.return=f,a;if(typeof a=="object"&&a!==null){switch(a.$$typeof){case be:return d=Sl(a.type,a.key,a.props,null,f.mode,d),d.ref=rr(f,null,a),d.return=f,d;case Ce:return a=go(a,f.mode,d),a.return=f,a;case Le:var w=a._init;return g(f,w(a._payload),d)}if(On(a)||L(a))return a=un(a,f.mode,d,null),a.return=f,a;Zr(f,a)}return null}function h(f,a,d,w){var P=a!==null?a.key:null;if(typeof d=="string"&&d!==""||typeof d=="number")return P!==null?null:i(f,a,""+d,w);if(typeof d=="object"&&d!==null){switch(d.$$typeof){case be:return d.key===P?s(f,a,d,w):null;case Ce:return d.key===P?p(f,a,d,w):null;case Le:return P=d._init,h(f,a,P(d._payload),w)}if(On(d)||L(d))return P!==null?null:y(f,a,d,w,null);Zr(f,d)}return null}function k(f,a,d,w,P){if(typeof w=="string"&&w!==""||typeof w=="number")return f=f.get(d)||null,i(a,f,""+w,P);if(typeof w=="object"&&w!==null){switch(w.$$typeof){case be:return f=f.get(w.key===null?d:w.key)||null,s(a,f,w,P);case Ce:return f=f.get(w.key===null?d:w.key)||null,p(a,f,w,P);case Le:var N=w._init;return k(f,a,d,N(w._payload),P)}if(On(w)||L(w))return f=f.get(d)||null,y(a,f,w,P,null);Zr(a,w)}return null}function C(f,a,d,w){for(var P=null,N=null,z=a,R=a=0,me=null;z!==null&&R<d.length;R++){z.index>R?(me=z,z=null):me=z.sibling;var U=h(f,z,d[R],w);if(U===null){z===null&&(z=me);break}e&&z&&U.alternate===null&&t(f,z),a=u(U,a,R),N===null?P=U:N.sibling=U,N=U,z=me}if(R===d.length)return n(f,z),b&&Jt(f,R),P;if(z===null){for(;R<d.length;R++)z=g(f,d[R],w),z!==null&&(a=u(z,a,R),N===null?P=z:N.sibling=z,N=z);return b&&Jt(f,R),P}for(z=r(f,z);R<d.length;R++)me=k(z,f,R,d[R],w),me!==null&&(e&&me.alternate!==null&&z.delete(me.key===null?R:me.key),a=u(me,a,R),N===null?P=me:N.sibling=me,N=me);return e&&z.forEach(function(Qt){return t(f,Qt)}),b&&Jt(f,R),P}function x(f,a,d,w){var P=L(d);if(typeof P!="function")throw Error(m(150));if(d=P.call(d),d==null)throw Error(m(151));for(var N=P=null,z=a,R=a=0,me=null,U=d.next();z!==null&&!U.done;R++,U=d.next()){z.index>R?(me=z,z=null):me=z.sibling;var Qt=h(f,z,U.value,w);if(Qt===null){z===null&&(z=me);break}e&&z&&Qt.alternate===null&&t(f,z),a=u(Qt,a,R),N===null?P=Qt:N.sibling=Qt,N=Qt,z=me}if(U.done)return n(f,z),b&&Jt(f,R),P;if(z===null){for(;!U.done;R++,U=d.next())U=g(f,U.value,w),U!==null&&(a=u(U,a,R),N===null?P=U:N.sibling=U,N=U);return b&&Jt(f,R),P}for(z=r(f,z);!U.done;R++,U=d.next())U=k(z,f,R,U.value,w),U!==null&&(e&&U.alternate!==null&&z.delete(U.key===null?R:U.key),a=u(U,a,R),N===null?P=U:N.sibling=U,N=U);return e&&z.forEach(function(Lf){return t(f,Lf)}),b&&Jt(f,R),P}function oe(f,a,d,w){if(typeof d=="object"&&d!==null&&d.type===ze&&d.key===null&&(d=d.props.children),typeof d=="object"&&d!==null){switch(d.$$typeof){case be:e:{for(var P=d.key,N=a;N!==null;){if(N.key===P){if(P=d.type,P===ze){if(N.tag===7){n(f,N.sibling),a=l(N,d.props.children),a.return=f,f=a;break e}}else if(N.elementType===P||typeof P=="object"&&P!==null&&P.$$typeof===Le&&es(P)===N.type){n(f,N.sibling),a=l(N,d.props),a.ref=rr(f,N,d),a.return=f,f=a;break e}n(f,N);break}else t(f,N);N=N.sibling}d.type===ze?(a=un(d.props.children,f.mode,w,d.key),a.return=f,f=a):(w=Sl(d.type,d.key,d.props,null,f.mode,w),w.ref=rr(f,a,d),w.return=f,f=w)}return o(f);case Ce:e:{for(N=d.key;a!==null;){if(a.key===N)if(a.tag===4&&a.stateNode.containerInfo===d.containerInfo&&a.stateNode.implementation===d.implementation){n(f,a.sibling),a=l(a,d.children||[]),a.return=f,f=a;break e}else{n(f,a);break}else t(f,a);a=a.sibling}a=go(d,f.mode,w),a.return=f,f=a}return o(f);case Le:return N=d._init,oe(f,a,N(d._payload),w)}if(On(d))return C(f,a,d,w);if(L(d))return x(f,a,d,w);Zr(f,d)}return typeof d=="string"&&d!==""||typeof d=="number"?(d=""+d,a!==null&&a.tag===6?(n(f,a.sibling),a=l(a,d),a.return=f,f=a):(n(f,a),a=yo(d,f.mode,w),a.return=f,f=a),o(f)):n(f,a)}return oe}var _n=ts(!0),ns=ts(!1),Jr=Dt(null),qr=null,Cn=null,Pu=null;function Nu(){Pu=Cn=qr=null}function zu(e){var t=Jr.current;G(Jr),e._currentValue=t}function Lu(e,t,n){for(;e!==null;){var r=e.alternate;if((e.childLanes&t)!==t?(e.childLanes|=t,r!==null&&(r.childLanes|=t)):r!==null&&(r.childLanes&t)!==t&&(r.childLanes|=t),e===n)break;e=e.return}}function xn(e,t){qr=e,Pu=Cn=null,e=e.dependencies,e!==null&&e.firstContext!==null&&((e.lanes&t)!==0&&(Oe=!0),e.firstContext=null)}function Xe(e){var t=e._currentValue;if(Pu!==e)if(e={context:e,memoizedValue:t,next:null},Cn===null){if(qr===null)throw Error(m(308));Cn=e,qr.dependencies={lanes:0,firstContext:e}}else Cn=Cn.next=e;return t}var qt=null;function Tu(e){qt===null?qt=[e]:qt.push(e)}function rs(e,t,n,r){var l=t.interleaved;return l===null?(n.next=n,Tu(t)):(n.next=l.next,l.next=n),t.interleaved=n,Et(e,r)}function Et(e,t){e.lanes|=t;var n=e.alternate;for(n!==null&&(n.lanes|=t),n=e,e=e.return;e!==null;)e.childLanes|=t,n=e.alternate,n!==null&&(n.childLanes|=t),n=e,e=e.return;return n.tag===3?n.stateNode:null}var Ft=!1;function Ru(e){e.updateQueue={baseState:e.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null}}function ls(e,t){e=e.updateQueue,t.updateQueue===e&&(t.updateQueue={baseState:e.baseState,firstBaseUpdate:e.firstBaseUpdate,lastBaseUpdate:e.lastBaseUpdate,shared:e.shared,effects:e.effects})}function _t(e,t){return{eventTime:e,lane:t,tag:0,payload:null,callback:null,next:null}}function Ut(e,t,n){var r=e.updateQueue;if(r===null)return null;if(r=r.shared,(I&2)!==0){var l=r.pending;return l===null?t.next=t:(t.next=l.next,l.next=t),r.pending=t,Et(e,n)}return l=r.interleaved,l===null?(t.next=t,Tu(r)):(t.next=l.next,l.next=t),r.interleaved=t,Et(e,n)}function br(e,t,n){if(t=t.updateQueue,t!==null&&(t=t.shared,(n&4194240)!==0)){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,Ql(e,n)}}function us(e,t){var n=e.updateQueue,r=e.alternate;if(r!==null&&(r=r.updateQueue,n===r)){var l=null,u=null;if(n=n.firstBaseUpdate,n!==null){do{var o={eventTime:n.eventTime,lane:n.lane,tag:n.tag,payload:n.payload,callback:n.callback,next:null};u===null?l=u=o:u=u.next=o,n=n.next}while(n!==null);u===null?l=u=t:u=u.next=t}else l=u=t;n={baseState:r.baseState,firstBaseUpdate:l,lastBaseUpdate:u,shared:r.shared,effects:r.effects},e.updateQueue=n;return}e=n.lastBaseUpdate,e===null?n.firstBaseUpdate=t:e.next=t,n.lastBaseUpdate=t}function el(e,t,n,r){var l=e.updateQueue;Ft=!1;var u=l.firstBaseUpdate,o=l.lastBaseUpdate,i=l.shared.pending;if(i!==null){l.shared.pending=null;var s=i,p=s.next;s.next=null,o===null?u=p:o.next=p,o=s;var y=e.alternate;y!==null&&(y=y.updateQueue,i=y.lastBaseUpdate,i!==o&&(i===null?y.firstBaseUpdate=p:i.next=p,y.lastBaseUpdate=s))}if(u!==null){var g=l.baseState;o=0,y=p=s=null,i=u;do{var h=i.lane,k=i.eventTime;if((r&h)===h){y!==null&&(y=y.next={eventTime:k,lane:0,tag:i.tag,payload:i.payload,callback:i.callback,next:null});e:{var C=e,x=i;switch(h=t,k=n,x.tag){case 1:if(C=x.payload,typeof C=="function"){g=C.call(k,g,h);break e}g=C;break e;case 3:C.flags=C.flags&-65537|128;case 0:if(C=x.payload,h=typeof C=="function"?C.call(k,g,h):C,h==null)break e;g=_({},g,h);break e;case 2:Ft=!0}}i.callback!==null&&i.lane!==0&&(e.flags|=64,h=l.effects,h===null?l.effects=[i]:h.push(i))}else k={eventTime:k,lane:h,tag:i.tag,payload:i.payload,callback:i.callback,next:null},y===null?(p=y=k,s=g):y=y.next=k,o|=h;if(i=i.next,i===null){if(i=l.shared.pending,i===null)break;h=i,i=h.next,h.next=null,l.lastBaseUpdate=h,l.shared.pending=null}}while(!0);if(y===null&&(s=g),l.baseState=s,l.firstBaseUpdate=p,l.lastBaseUpdate=y,t=l.shared.interleaved,t!==null){l=t;do o|=l.lane,l=l.next;while(l!==t)}else u===null&&(l.shared.lanes=0);tn|=o,e.lanes=o,e.memoizedState=g}}function os(e,t,n){if(e=t.effects,t.effects=null,e!==null)for(t=0;t<e.length;t++){var r=e[t],l=r.callback;if(l!==null){if(r.callback=null,r=n,typeof l!="function")throw Error(m(191,l));l.call(r)}}}var lr={},pt=Dt(lr),ur=Dt(lr),or=Dt(lr);function bt(e){if(e===lr)throw Error(m(174));return e}function Ou(e,t){switch(K(or,t),K(ur,e),K(pt,lr),e=t.nodeType,e){case 9:case 11:t=(t=t.documentElement)?t.namespaceURI:Ml(null,"");break;default:e=e===8?t.parentNode:t,t=e.namespaceURI||null,e=e.tagName,t=Ml(t,e)}G(pt),K(pt,t)}function Pn(){G(pt),G(ur),G(or)}function is(e){bt(or.current);var t=bt(pt.current),n=Ml(t,e.type);t!==n&&(K(ur,e),K(pt,n))}function Mu(e){ur.current===e&&(G(pt),G(ur))}var te=Dt(0);function tl(e){for(var t=e;t!==null;){if(t.tag===13){var n=t.memoizedState;if(n!==null&&(n=n.dehydrated,n===null||n.data==="$?"||n.data==="$!"))return t}else if(t.tag===19&&t.memoizedProps.revealOrder!==void 0){if((t.flags&128)!==0)return t}else if(t.child!==null){t.child.return=t,t=t.child;continue}if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return null;t=t.return}t.sibling.return=t.return,t=t.sibling}return null}var Du=[];function Iu(){for(var e=0;e<Du.length;e++)Du[e]._workInProgressVersionPrimary=null;Du.length=0}var nl=ge.ReactCurrentDispatcher,ju=ge.ReactCurrentBatchConfig,en=0,ne=null,se=null,de=null,rl=!1,ir=!1,sr=0,Zc=0;function Se(){throw Error(m(321))}function Fu(e,t){if(t===null)return!1;for(var n=0;n<t.length&&n<e.length;n++)if(!nt(e[n],t[n]))return!1;return!0}function Uu(e,t,n,r,l,u){if(en=u,ne=t,t.memoizedState=null,t.updateQueue=null,t.lanes=0,nl.current=e===null||e.memoizedState===null?ef:tf,e=n(r,l),ir){u=0;do{if(ir=!1,sr=0,25<=u)throw Error(m(301));u+=1,de=se=null,t.updateQueue=null,nl.current=nf,e=n(r,l)}while(ir)}if(nl.current=ol,t=se!==null&&se.next!==null,en=0,de=se=ne=null,rl=!1,t)throw Error(m(300));return e}function Au(){var e=sr!==0;return sr=0,e}function mt(){var e={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};return de===null?ne.memoizedState=de=e:de=de.next=e,de}function Ge(){if(se===null){var e=ne.alternate;e=e!==null?e.memoizedState:null}else e=se.next;var t=de===null?ne.memoizedState:de.next;if(t!==null)de=t,se=e;else{if(e===null)throw Error(m(310));se=e,e={memoizedState:se.memoizedState,baseState:se.baseState,baseQueue:se.baseQueue,queue:se.queue,next:null},de===null?ne.memoizedState=de=e:de=de.next=e}return de}function ar(e,t){return typeof t=="function"?t(e):t}function Vu(e){var t=Ge(),n=t.queue;if(n===null)throw Error(m(311));n.lastRenderedReducer=e;var r=se,l=r.baseQueue,u=n.pending;if(u!==null){if(l!==null){var o=l.next;l.next=u.next,u.next=o}r.baseQueue=l=u,n.pending=null}if(l!==null){u=l.next,r=r.baseState;var i=o=null,s=null,p=u;do{var y=p.lane;if((en&y)===y)s!==null&&(s=s.next={lane:0,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null}),r=p.hasEagerState?p.eagerState:e(r,p.action);else{var g={lane:y,action:p.action,hasEagerState:p.hasEagerState,eagerState:p.eagerState,next:null};s===null?(i=s=g,o=r):s=s.next=g,ne.lanes|=y,tn|=y}p=p.next}while(p!==null&&p!==u);s===null?o=r:s.next=i,nt(r,t.memoizedState)||(Oe=!0),t.memoizedState=r,t.baseState=o,t.baseQueue=s,n.lastRenderedState=r}if(e=n.interleaved,e!==null){l=e;do u=l.lane,ne.lanes|=u,tn|=u,l=l.next;while(l!==e)}else l===null&&(n.lanes=0);return[t.memoizedState,n.dispatch]}function Bu(e){var t=Ge(),n=t.queue;if(n===null)throw Error(m(311));n.lastRenderedReducer=e;var r=n.dispatch,l=n.pending,u=t.memoizedState;if(l!==null){n.pending=null;var o=l=l.next;do u=e(u,o.action),o=o.next;while(o!==l);nt(u,t.memoizedState)||(Oe=!0),t.memoizedState=u,t.baseQueue===null&&(t.baseState=u),n.lastRenderedState=u}return[u,r]}function ss(){}function as(e,t){var n=ne,r=Ge(),l=t(),u=!nt(r.memoizedState,l);if(u&&(r.memoizedState=l,Oe=!0),r=r.queue,Hu(ds.bind(null,n,r,e),[e]),r.getSnapshot!==t||u||de!==null&&de.memoizedState.tag&1){if(n.flags|=2048,cr(9,fs.bind(null,n,r,l,t),void 0,null),pe===null)throw Error(m(349));(en&30)!==0||cs(n,t,l)}return l}function cs(e,t,n){e.flags|=16384,e={getSnapshot:t,value:n},t=ne.updateQueue,t===null?(t={lastEffect:null,stores:null},ne.updateQueue=t,t.stores=[e]):(n=t.stores,n===null?t.stores=[e]:n.push(e))}function fs(e,t,n,r){t.value=n,t.getSnapshot=r,ps(t)&&ms(e)}function ds(e,t,n){return n(function(){ps(t)&&ms(e)})}function ps(e){var t=e.getSnapshot;e=e.value;try{var n=t();return!nt(e,n)}catch{return!0}}function ms(e){var t=Et(e,1);t!==null&&it(t,e,1,-1)}function hs(e){var t=mt();return typeof e=="function"&&(e=e()),t.memoizedState=t.baseState=e,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:ar,lastRenderedState:e},t.queue=e,e=e.dispatch=bc.bind(null,ne,e),[t.memoizedState,e]}function cr(e,t,n,r){return e={tag:e,create:t,destroy:n,deps:r,next:null},t=ne.updateQueue,t===null?(t={lastEffect:null,stores:null},ne.updateQueue=t,t.lastEffect=e.next=e):(n=t.lastEffect,n===null?t.lastEffect=e.next=e:(r=n.next,n.next=e,e.next=r,t.lastEffect=e)),e}function vs(){return Ge().memoizedState}function ll(e,t,n,r){var l=mt();ne.flags|=e,l.memoizedState=cr(1|t,n,void 0,r===void 0?null:r)}function ul(e,t,n,r){var l=Ge();r=r===void 0?null:r;var u=void 0;if(se!==null){var o=se.memoizedState;if(u=o.destroy,r!==null&&Fu(r,o.deps)){l.memoizedState=cr(t,n,u,r);return}}ne.flags|=e,l.memoizedState=cr(1|t,n,u,r)}function ys(e,t){return ll(8390656,8,e,t)}function Hu(e,t){return ul(2048,8,e,t)}function gs(e,t){return ul(4,2,e,t)}function ws(e,t){return ul(4,4,e,t)}function Ss(e,t){if(typeof t=="function")return e=e(),t(e),function(){t(null)};if(t!=null)return e=e(),t.current=e,function(){t.current=null}}function ks(e,t,n){return n=n!=null?n.concat([e]):null,ul(4,4,Ss.bind(null,t,e),n)}function Wu(){}function Es(e,t){var n=Ge();t=t===void 0?null:t;var r=n.memoizedState;return r!==null&&t!==null&&Fu(t,r[1])?r[0]:(n.memoizedState=[e,t],e)}function _s(e,t){var n=Ge();t=t===void 0?null:t;var r=n.memoizedState;return r!==null&&t!==null&&Fu(t,r[1])?r[0]:(e=e(),n.memoizedState=[e,t],e)}function Cs(e,t,n){return(en&21)===0?(e.baseState&&(e.baseState=!1,Oe=!0),e.memoizedState=n):(nt(n,t)||(n=ei(),ne.lanes|=n,tn|=n,e.baseState=!0),t)}function Jc(e,t){var n=B;B=n!==0&&4>n?n:4,e(!0);var r=ju.transition;ju.transition={};try{e(!1),t()}finally{B=n,ju.transition=r}}function xs(){return Ge().memoizedState}function qc(e,t,n){var r=Ht(e);if(n={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null},Ps(e))Ns(t,n);else if(n=rs(e,t,n,r),n!==null){var l=Pe();it(n,e,r,l),zs(n,t,r)}}function bc(e,t,n){var r=Ht(e),l={lane:r,action:n,hasEagerState:!1,eagerState:null,next:null};if(Ps(e))Ns(t,l);else{var u=e.alternate;if(e.lanes===0&&(u===null||u.lanes===0)&&(u=t.lastRenderedReducer,u!==null))try{var o=t.lastRenderedState,i=u(o,n);if(l.hasEagerState=!0,l.eagerState=i,nt(i,o)){var s=t.interleaved;s===null?(l.next=l,Tu(t)):(l.next=s.next,s.next=l),t.interleaved=l;return}}catch{}finally{}n=rs(e,t,l,r),n!==null&&(l=Pe(),it(n,e,r,l),zs(n,t,r))}}function Ps(e){var t=e.alternate;return e===ne||t!==null&&t===ne}function Ns(e,t){ir=rl=!0;var n=e.pending;n===null?t.next=t:(t.next=n.next,n.next=t),e.pending=t}function zs(e,t,n){if((n&4194240)!==0){var r=t.lanes;r&=e.pendingLanes,n|=r,t.lanes=n,Ql(e,n)}}var ol={readContext:Xe,useCallback:Se,useContext:Se,useEffect:Se,useImperativeHandle:Se,useInsertionEffect:Se,useLayoutEffect:Se,useMemo:Se,useReducer:Se,useRef:Se,useState:Se,useDebugValue:Se,useDeferredValue:Se,useTransition:Se,useMutableSource:Se,useSyncExternalStore:Se,useId:Se,unstable_isNewReconciler:!1},ef={readContext:Xe,useCallback:function(e,t){return mt().memoizedState=[e,t===void 0?null:t],e},useContext:Xe,useEffect:ys,useImperativeHandle:function(e,t,n){return n=n!=null?n.concat([e]):null,ll(4194308,4,Ss.bind(null,t,e),n)},useLayoutEffect:function(e,t){return ll(4194308,4,e,t)},useInsertionEffect:function(e,t){return ll(4,2,e,t)},useMemo:function(e,t){var n=mt();return t=t===void 0?null:t,e=e(),n.memoizedState=[e,t],e},useReducer:function(e,t,n){var r=mt();return t=n!==void 0?n(t):t,r.memoizedState=r.baseState=t,e={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:e,lastRenderedState:t},r.queue=e,e=e.dispatch=qc.bind(null,ne,e),[r.memoizedState,e]},useRef:function(e){var t=mt();return e={current:e},t.memoizedState=e},useState:hs,useDebugValue:Wu,useDeferredValue:function(e){return mt().memoizedState=e},useTransition:function(){var e=hs(!1),t=e[0];return e=Jc.bind(null,e[1]),mt().memoizedState=e,[t,e]},useMutableSource:function(){},useSyncExternalStore:function(e,t,n){var r=ne,l=mt();if(b){if(n===void 0)throw Error(m(407));n=n()}else{if(n=t(),pe===null)throw Error(m(349));(en&30)!==0||cs(r,t,n)}l.memoizedState=n;var u={value:n,getSnapshot:t};return l.queue=u,ys(ds.bind(null,r,u,e),[e]),r.flags|=2048,cr(9,fs.bind(null,r,u,n,t),void 0,null),n},useId:function(){var e=mt(),t=pe.identifierPrefix;if(b){var n=kt,r=St;n=(r&~(1<<32-tt(r)-1)).toString(32)+n,t=":"+t+"R"+n,n=sr++,0<n&&(t+="H"+n.toString(32)),t+=":"}else n=Zc++,t=":"+t+"r"+n.toString(32)+":";return e.memoizedState=t},unstable_isNewReconciler:!1},tf={readContext:Xe,useCallback:Es,useContext:Xe,useEffect:Hu,useImperativeHandle:ks,useInsertionEffect:gs,useLayoutEffect:ws,useMemo:_s,useReducer:Vu,useRef:vs,useState:function(){return Vu(ar)},useDebugValue:Wu,useDeferredValue:function(e){var t=Ge();return Cs(t,se.memoizedState,e)},useTransition:function(){var e=Vu(ar)[0],t=Ge().memoizedState;return[e,t]},useMutableSource:ss,useSyncExternalStore:as,useId:xs,unstable_isNewReconciler:!1},nf={readContext:Xe,useCallback:Es,useContext:Xe,useEffect:Hu,useImperativeHandle:ks,useInsertionEffect:gs,useLayoutEffect:ws,useMemo:_s,useReducer:Bu,useRef:vs,useState:function(){return Bu(ar)},useDebugValue:Wu,useDeferredValue:function(e){var t=Ge();return se===null?t.memoizedState=e:Cs(t,se.memoizedState,e)},useTransition:function(){var e=Bu(ar)[0],t=Ge().memoizedState;return[e,t]},useMutableSource:ss,useSyncExternalStore:as,useId:xs,unstable_isNewReconciler:!1};function lt(e,t){if(e&&e.defaultProps){t=_({},t),e=e.defaultProps;for(var n in e)t[n]===void 0&&(t[n]=e[n]);return t}return t}function $u(e,t,n,r){t=e.memoizedState,n=n(r,t),n=n==null?t:_({},t,n),e.memoizedState=n,e.lanes===0&&(e.updateQueue.baseState=n)}var il={isMounted:function(e){return(e=e._reactInternals)?Yt(e)===e:!1},enqueueSetState:function(e,t,n){e=e._reactInternals;var r=Pe(),l=Ht(e),u=_t(r,l);u.payload=t,n!=null&&(u.callback=n),t=Ut(e,u,l),t!==null&&(it(t,e,l,r),br(t,e,l))},enqueueReplaceState:function(e,t,n){e=e._reactInternals;var r=Pe(),l=Ht(e),u=_t(r,l);u.tag=1,u.payload=t,n!=null&&(u.callback=n),t=Ut(e,u,l),t!==null&&(it(t,e,l,r),br(t,e,l))},enqueueForceUpdate:function(e,t){e=e._reactInternals;var n=Pe(),r=Ht(e),l=_t(n,r);l.tag=2,t!=null&&(l.callback=t),t=Ut(e,l,r),t!==null&&(it(t,e,r,n),br(t,e,r))}};function Ls(e,t,n,r,l,u,o){return e=e.stateNode,typeof e.shouldComponentUpdate=="function"?e.shouldComponentUpdate(r,u,o):t.prototype&&t.prototype.isPureReactComponent?!Zn(n,r)||!Zn(l,u):!0}function Ts(e,t,n){var r=!1,l=It,u=t.contextType;return typeof u=="object"&&u!==null?u=Xe(u):(l=Re(t)?Gt:we.current,r=t.contextTypes,u=(r=r!=null)?wn(e,l):It),t=new t(n,u),e.memoizedState=t.state!==null&&t.state!==void 0?t.state:null,t.updater=il,e.stateNode=t,t._reactInternals=e,r&&(e=e.stateNode,e.__reactInternalMemoizedUnmaskedChildContext=l,e.__reactInternalMemoizedMaskedChildContext=u),t}function Rs(e,t,n,r){e=t.state,typeof t.componentWillReceiveProps=="function"&&t.componentWillReceiveProps(n,r),typeof t.UNSAFE_componentWillReceiveProps=="function"&&t.UNSAFE_componentWillReceiveProps(n,r),t.state!==e&&il.enqueueReplaceState(t,t.state,null)}function Qu(e,t,n,r){var l=e.stateNode;l.props=n,l.state=e.memoizedState,l.refs={},Ru(e);var u=t.contextType;typeof u=="object"&&u!==null?l.context=Xe(u):(u=Re(t)?Gt:we.current,l.context=wn(e,u)),l.state=e.memoizedState,u=t.getDerivedStateFromProps,typeof u=="function"&&($u(e,t,u,n),l.state=e.memoizedState),typeof t.getDerivedStateFromProps=="function"||typeof l.getSnapshotBeforeUpdate=="function"||typeof l.UNSAFE_componentWillMount!="function"&&typeof l.componentWillMount!="function"||(t=l.state,typeof l.componentWillMount=="function"&&l.componentWillMount(),typeof l.UNSAFE_componentWillMount=="function"&&l.UNSAFE_componentWillMount(),t!==l.state&&il.enqueueReplaceState(l,l.state,null),el(e,n,l,r),l.state=e.memoizedState),typeof l.componentDidMount=="function"&&(e.flags|=4194308)}function Nn(e,t){try{var n="",r=t;do n+=j(r),r=r.return;while(r);var l=n}catch(u){l=`
+Error generating stack: `+u.message+`
+`+u.stack}return{value:e,source:t,stack:l,digest:null}}function Ku(e,t,n){return{value:e,source:null,stack:n??null,digest:t??null}}function Yu(e,t){try{console.error(t.value)}catch(n){setTimeout(function(){throw n})}}var rf=typeof WeakMap=="function"?WeakMap:Map;function Os(e,t,n){n=_t(-1,n),n.tag=3,n.payload={element:null};var r=t.value;return n.callback=function(){ml||(ml=!0,so=r),Yu(e,t)},n}function Ms(e,t,n){n=_t(-1,n),n.tag=3;var r=e.type.getDerivedStateFromError;if(typeof r=="function"){var l=t.value;n.payload=function(){return r(l)},n.callback=function(){Yu(e,t)}}var u=e.stateNode;return u!==null&&typeof u.componentDidCatch=="function"&&(n.callback=function(){Yu(e,t),typeof r!="function"&&(Vt===null?Vt=new Set([this]):Vt.add(this));var o=t.stack;this.componentDidCatch(t.value,{componentStack:o!==null?o:""})}),n}function Ds(e,t,n){var r=e.pingCache;if(r===null){r=e.pingCache=new rf;var l=new Set;r.set(t,l)}else l=r.get(t),l===void 0&&(l=new Set,r.set(t,l));l.has(n)||(l.add(n),e=gf.bind(null,e,t,n),t.then(e,e))}function Is(e){do{var t;if((t=e.tag===13)&&(t=e.memoizedState,t=t!==null?t.dehydrated!==null:!0),t)return e;e=e.return}while(e!==null);return null}function js(e,t,n,r,l){return(e.mode&1)===0?(e===t?e.flags|=65536:(e.flags|=128,n.flags|=131072,n.flags&=-52805,n.tag===1&&(n.alternate===null?n.tag=17:(t=_t(-1,1),t.tag=2,Ut(n,t,1))),n.lanes|=1),e):(e.flags|=65536,e.lanes=l,e)}var lf=ge.ReactCurrentOwner,Oe=!1;function xe(e,t,n,r){t.child=e===null?ns(t,null,n,r):_n(t,e.child,n,r)}function Fs(e,t,n,r,l){n=n.render;var u=t.ref;return xn(t,l),r=Uu(e,t,n,r,u,l),n=Au(),e!==null&&!Oe?(t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~l,Ct(e,t,l)):(b&&n&&ku(t),t.flags|=1,xe(e,t,r,l),t.child)}function Us(e,t,n,r,l){if(e===null){var u=n.type;return typeof u=="function"&&!vo(u)&&u.defaultProps===void 0&&n.compare===null&&n.defaultProps===void 0?(t.tag=15,t.type=u,As(e,t,u,r,l)):(e=Sl(n.type,null,r,t,t.mode,l),e.ref=t.ref,e.return=t,t.child=e)}if(u=e.child,(e.lanes&l)===0){var o=u.memoizedProps;if(n=n.compare,n=n!==null?n:Zn,n(o,r)&&e.ref===t.ref)return Ct(e,t,l)}return t.flags|=1,e=$t(u,r),e.ref=t.ref,e.return=t,t.child=e}function As(e,t,n,r,l){if(e!==null){var u=e.memoizedProps;if(Zn(u,r)&&e.ref===t.ref)if(Oe=!1,t.pendingProps=r=u,(e.lanes&l)!==0)(e.flags&131072)!==0&&(Oe=!0);else return t.lanes=e.lanes,Ct(e,t,l)}return Xu(e,t,n,r,l)}function Vs(e,t,n){var r=t.pendingProps,l=r.children,u=e!==null?e.memoizedState:null;if(r.mode==="hidden")if((t.mode&1)===0)t.memoizedState={baseLanes:0,cachePool:null,transitions:null},K(Ln,He),He|=n;else{if((n&1073741824)===0)return e=u!==null?u.baseLanes|n:n,t.lanes=t.childLanes=1073741824,t.memoizedState={baseLanes:e,cachePool:null,transitions:null},t.updateQueue=null,K(Ln,He),He|=e,null;t.memoizedState={baseLanes:0,cachePool:null,transitions:null},r=u!==null?u.baseLanes:n,K(Ln,He),He|=r}else u!==null?(r=u.baseLanes|n,t.memoizedState=null):r=n,K(Ln,He),He|=r;return xe(e,t,l,n),t.child}function Bs(e,t){var n=t.ref;(e===null&&n!==null||e!==null&&e.ref!==n)&&(t.flags|=512,t.flags|=2097152)}function Xu(e,t,n,r,l){var u=Re(n)?Gt:we.current;return u=wn(t,u),xn(t,l),n=Uu(e,t,n,r,u,l),r=Au(),e!==null&&!Oe?(t.updateQueue=e.updateQueue,t.flags&=-2053,e.lanes&=~l,Ct(e,t,l)):(b&&r&&ku(t),t.flags|=1,xe(e,t,n,l),t.child)}function Hs(e,t,n,r,l){if(Re(n)){var u=!0;Qr(t)}else u=!1;if(xn(t,l),t.stateNode===null)al(e,t),Ts(t,n,r),Qu(t,n,r,l),r=!0;else if(e===null){var o=t.stateNode,i=t.memoizedProps;o.props=i;var s=o.context,p=n.contextType;typeof p=="object"&&p!==null?p=Xe(p):(p=Re(n)?Gt:we.current,p=wn(t,p));var y=n.getDerivedStateFromProps,g=typeof y=="function"||typeof o.getSnapshotBeforeUpdate=="function";g||typeof o.UNSAFE_componentWillReceiveProps!="function"&&typeof o.componentWillReceiveProps!="function"||(i!==r||s!==p)&&Rs(t,o,r,p),Ft=!1;var h=t.memoizedState;o.state=h,el(t,r,o,l),s=t.memoizedState,i!==r||h!==s||Te.current||Ft?(typeof y=="function"&&($u(t,n,y,r),s=t.memoizedState),(i=Ft||Ls(t,n,i,r,h,s,p))?(g||typeof o.UNSAFE_componentWillMount!="function"&&typeof o.componentWillMount!="function"||(typeof o.componentWillMount=="function"&&o.componentWillMount(),typeof o.UNSAFE_componentWillMount=="function"&&o.UNSAFE_componentWillMount()),typeof o.componentDidMount=="function"&&(t.flags|=4194308)):(typeof o.componentDidMount=="function"&&(t.flags|=4194308),t.memoizedProps=r,t.memoizedState=s),o.props=r,o.state=s,o.context=p,r=i):(typeof o.componentDidMount=="function"&&(t.flags|=4194308),r=!1)}else{o=t.stateNode,ls(e,t),i=t.memoizedProps,p=t.type===t.elementType?i:lt(t.type,i),o.props=p,g=t.pendingProps,h=o.context,s=n.contextType,typeof s=="object"&&s!==null?s=Xe(s):(s=Re(n)?Gt:we.current,s=wn(t,s));var k=n.getDerivedStateFromProps;(y=typeof k=="function"||typeof o.getSnapshotBeforeUpdate=="function")||typeof o.UNSAFE_componentWillReceiveProps!="function"&&typeof o.componentWillReceiveProps!="function"||(i!==g||h!==s)&&Rs(t,o,r,s),Ft=!1,h=t.memoizedState,o.state=h,el(t,r,o,l);var C=t.memoizedState;i!==g||h!==C||Te.current||Ft?(typeof k=="function"&&($u(t,n,k,r),C=t.memoizedState),(p=Ft||Ls(t,n,p,r,h,C,s)||!1)?(y||typeof o.UNSAFE_componentWillUpdate!="function"&&typeof o.componentWillUpdate!="function"||(typeof o.componentWillUpdate=="function"&&o.componentWillUpdate(r,C,s),typeof o.UNSAFE_componentWillUpdate=="function"&&o.UNSAFE_componentWillUpdate(r,C,s)),typeof o.componentDidUpdate=="function"&&(t.flags|=4),typeof o.getSnapshotBeforeUpdate=="function"&&(t.flags|=1024)):(typeof o.componentDidUpdate!="function"||i===e.memoizedProps&&h===e.memoizedState||(t.flags|=4),typeof o.getSnapshotBeforeUpdate!="function"||i===e.memoizedProps&&h===e.memoizedState||(t.flags|=1024),t.memoizedProps=r,t.memoizedState=C),o.props=r,o.state=C,o.context=s,r=p):(typeof o.componentDidUpdate!="function"||i===e.memoizedProps&&h===e.memoizedState||(t.flags|=4),typeof o.getSnapshotBeforeUpdate!="function"||i===e.memoizedProps&&h===e.memoizedState||(t.flags|=1024),r=!1)}return Gu(e,t,n,r,u,l)}function Gu(e,t,n,r,l,u){Bs(e,t);var o=(t.flags&128)!==0;if(!r&&!o)return l&&Yi(t,n,!1),Ct(e,t,u);r=t.stateNode,lf.current=t;var i=o&&typeof n.getDerivedStateFromError!="function"?null:r.render();return t.flags|=1,e!==null&&o?(t.child=_n(t,e.child,null,u),t.child=_n(t,null,i,u)):xe(e,t,i,u),t.memoizedState=r.state,l&&Yi(t,n,!0),t.child}function Ws(e){var t=e.stateNode;t.pendingContext?Qi(e,t.pendingContext,t.pendingContext!==t.context):t.context&&Qi(e,t.context,!1),Ou(e,t.containerInfo)}function $s(e,t,n,r,l){return En(),xu(l),t.flags|=256,xe(e,t,n,r),t.child}var Zu={dehydrated:null,treeContext:null,retryLane:0};function Ju(e){return{baseLanes:e,cachePool:null,transitions:null}}function Qs(e,t,n){var r=t.pendingProps,l=te.current,u=!1,o=(t.flags&128)!==0,i;if((i=o)||(i=e!==null&&e.memoizedState===null?!1:(l&2)!==0),i?(u=!0,t.flags&=-129):(e===null||e.memoizedState!==null)&&(l|=1),K(te,l&1),e===null)return Cu(t),e=t.memoizedState,e!==null&&(e=e.dehydrated,e!==null)?((t.mode&1)===0?t.lanes=1:e.data==="$!"?t.lanes=8:t.lanes=1073741824,null):(o=r.children,e=r.fallback,u?(r=t.mode,u=t.child,o={mode:"hidden",children:o},(r&1)===0&&u!==null?(u.childLanes=0,u.pendingProps=o):u=kl(o,r,0,null),e=un(e,r,n,null),u.return=t,e.return=t,u.sibling=e,t.child=u,t.child.memoizedState=Ju(n),t.memoizedState=Zu,e):qu(t,o));if(l=e.memoizedState,l!==null&&(i=l.dehydrated,i!==null))return uf(e,t,o,r,i,l,n);if(u){u=r.fallback,o=t.mode,l=e.child,i=l.sibling;var s={mode:"hidden",children:r.children};return(o&1)===0&&t.child!==l?(r=t.child,r.childLanes=0,r.pendingProps=s,t.deletions=null):(r=$t(l,s),r.subtreeFlags=l.subtreeFlags&14680064),i!==null?u=$t(i,u):(u=un(u,o,n,null),u.flags|=2),u.return=t,r.return=t,r.sibling=u,t.child=r,r=u,u=t.child,o=e.child.memoizedState,o=o===null?Ju(n):{baseLanes:o.baseLanes|n,cachePool:null,transitions:o.transitions},u.memoizedState=o,u.childLanes=e.childLanes&~n,t.memoizedState=Zu,r}return u=e.child,e=u.sibling,r=$t(u,{mode:"visible",children:r.children}),(t.mode&1)===0&&(r.lanes=n),r.return=t,r.sibling=null,e!==null&&(n=t.deletions,n===null?(t.deletions=[e],t.flags|=16):n.push(e)),t.child=r,t.memoizedState=null,r}function qu(e,t){return t=kl({mode:"visible",children:t},e.mode,0,null),t.return=e,e.child=t}function sl(e,t,n,r){return r!==null&&xu(r),_n(t,e.child,null,n),e=qu(t,t.pendingProps.children),e.flags|=2,t.memoizedState=null,e}function uf(e,t,n,r,l,u,o){if(n)return t.flags&256?(t.flags&=-257,r=Ku(Error(m(422))),sl(e,t,o,r)):t.memoizedState!==null?(t.child=e.child,t.flags|=128,null):(u=r.fallback,l=t.mode,r=kl({mode:"visible",children:r.children},l,0,null),u=un(u,l,o,null),u.flags|=2,r.return=t,u.return=t,r.sibling=u,t.child=r,(t.mode&1)!==0&&_n(t,e.child,null,o),t.child.memoizedState=Ju(o),t.memoizedState=Zu,u);if((t.mode&1)===0)return sl(e,t,o,null);if(l.data==="$!"){if(r=l.nextSibling&&l.nextSibling.dataset,r)var i=r.dgst;return r=i,u=Error(m(419)),r=Ku(u,r,void 0),sl(e,t,o,r)}if(i=(o&e.childLanes)!==0,Oe||i){if(r=pe,r!==null){switch(o&-o){case 4:l=2;break;case 16:l=8;break;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:l=32;break;case 536870912:l=268435456;break;default:l=0}l=(l&(r.suspendedLanes|o))!==0?0:l,l!==0&&l!==u.retryLane&&(u.retryLane=l,Et(e,l),it(r,e,l,-1))}return ho(),r=Ku(Error(m(421))),sl(e,t,o,r)}return l.data==="$?"?(t.flags|=128,t.child=e.child,t=wf.bind(null,e),l._reactRetry=t,null):(e=u.treeContext,Be=Mt(l.nextSibling),Ve=t,b=!0,rt=null,e!==null&&(Ke[Ye++]=St,Ke[Ye++]=kt,Ke[Ye++]=Zt,St=e.id,kt=e.overflow,Zt=t),t=qu(t,r.children),t.flags|=4096,t)}function Ks(e,t,n){e.lanes|=t;var r=e.alternate;r!==null&&(r.lanes|=t),Lu(e.return,t,n)}function bu(e,t,n,r,l){var u=e.memoizedState;u===null?e.memoizedState={isBackwards:t,rendering:null,renderingStartTime:0,last:r,tail:n,tailMode:l}:(u.isBackwards=t,u.rendering=null,u.renderingStartTime=0,u.last=r,u.tail=n,u.tailMode=l)}function Ys(e,t,n){var r=t.pendingProps,l=r.revealOrder,u=r.tail;if(xe(e,t,r.children,n),r=te.current,(r&2)!==0)r=r&1|2,t.flags|=128;else{if(e!==null&&(e.flags&128)!==0)e:for(e=t.child;e!==null;){if(e.tag===13)e.memoizedState!==null&&Ks(e,n,t);else if(e.tag===19)Ks(e,n,t);else if(e.child!==null){e.child.return=e,e=e.child;continue}if(e===t)break e;for(;e.sibling===null;){if(e.return===null||e.return===t)break e;e=e.return}e.sibling.return=e.return,e=e.sibling}r&=1}if(K(te,r),(t.mode&1)===0)t.memoizedState=null;else switch(l){case"forwards":for(n=t.child,l=null;n!==null;)e=n.alternate,e!==null&&tl(e)===null&&(l=n),n=n.sibling;n=l,n===null?(l=t.child,t.child=null):(l=n.sibling,n.sibling=null),bu(t,!1,l,n,u);break;case"backwards":for(n=null,l=t.child,t.child=null;l!==null;){if(e=l.alternate,e!==null&&tl(e)===null){t.child=l;break}e=l.sibling,l.sibling=n,n=l,l=e}bu(t,!0,n,null,u);break;case"together":bu(t,!1,null,null,void 0);break;default:t.memoizedState=null}return t.child}function al(e,t){(t.mode&1)===0&&e!==null&&(e.alternate=null,t.alternate=null,t.flags|=2)}function Ct(e,t,n){if(e!==null&&(t.dependencies=e.dependencies),tn|=t.lanes,(n&t.childLanes)===0)return null;if(e!==null&&t.child!==e.child)throw Error(m(153));if(t.child!==null){for(e=t.child,n=$t(e,e.pendingProps),t.child=n,n.return=t;e.sibling!==null;)e=e.sibling,n=n.sibling=$t(e,e.pendingProps),n.return=t;n.sibling=null}return t.child}function of(e,t,n){switch(t.tag){case 3:Ws(t),En();break;case 5:is(t);break;case 1:Re(t.type)&&Qr(t);break;case 4:Ou(t,t.stateNode.containerInfo);break;case 10:var r=t.type._context,l=t.memoizedProps.value;K(Jr,r._currentValue),r._currentValue=l;break;case 13:if(r=t.memoizedState,r!==null)return r.dehydrated!==null?(K(te,te.current&1),t.flags|=128,null):(n&t.child.childLanes)!==0?Qs(e,t,n):(K(te,te.current&1),e=Ct(e,t,n),e!==null?e.sibling:null);K(te,te.current&1);break;case 19:if(r=(n&t.childLanes)!==0,(e.flags&128)!==0){if(r)return Ys(e,t,n);t.flags|=128}if(l=t.memoizedState,l!==null&&(l.rendering=null,l.tail=null,l.lastEffect=null),K(te,te.current),r)break;return null;case 22:case 23:return t.lanes=0,Vs(e,t,n)}return Ct(e,t,n)}var Xs,eo,Gs,Zs;Xs=function(e,t){for(var n=t.child;n!==null;){if(n.tag===5||n.tag===6)e.appendChild(n.stateNode);else if(n.tag!==4&&n.child!==null){n.child.return=n,n=n.child;continue}if(n===t)break;for(;n.sibling===null;){if(n.return===null||n.return===t)return;n=n.return}n.sibling.return=n.return,n=n.sibling}},eo=function(){},Gs=function(e,t,n,r){var l=e.memoizedProps;if(l!==r){e=t.stateNode,bt(pt.current);var u=null;switch(n){case"input":l=Ll(e,l),r=Ll(e,r),u=[];break;case"select":l=_({},l,{value:void 0}),r=_({},r,{value:void 0}),u=[];break;case"textarea":l=Ol(e,l),r=Ol(e,r),u=[];break;default:typeof l.onClick!="function"&&typeof r.onClick=="function"&&(e.onclick=Hr)}Dl(n,r);var o;n=null;for(p in l)if(!r.hasOwnProperty(p)&&l.hasOwnProperty(p)&&l[p]!=null)if(p==="style"){var i=l[p];for(o in i)i.hasOwnProperty(o)&&(n||(n={}),n[o]="")}else p!=="dangerouslySetInnerHTML"&&p!=="children"&&p!=="suppressContentEditableWarning"&&p!=="suppressHydrationWarning"&&p!=="autoFocus"&&(A.hasOwnProperty(p)?u||(u=[]):(u=u||[]).push(p,null));for(p in r){var s=r[p];if(i=l!=null?l[p]:void 0,r.hasOwnProperty(p)&&s!==i&&(s!=null||i!=null))if(p==="style")if(i){for(o in i)!i.hasOwnProperty(o)||s&&s.hasOwnProperty(o)||(n||(n={}),n[o]="");for(o in s)s.hasOwnProperty(o)&&i[o]!==s[o]&&(n||(n={}),n[o]=s[o])}else n||(u||(u=[]),u.push(p,n)),n=s;else p==="dangerouslySetInnerHTML"?(s=s?s.__html:void 0,i=i?i.__html:void 0,s!=null&&i!==s&&(u=u||[]).push(p,s)):p==="children"?typeof s!="string"&&typeof s!="number"||(u=u||[]).push(p,""+s):p!=="suppressContentEditableWarning"&&p!=="suppressHydrationWarning"&&(A.hasOwnProperty(p)?(s!=null&&p==="onScroll"&&X("scroll",e),u||i===s||(u=[])):(u=u||[]).push(p,s))}n&&(u=u||[]).push("style",n);var p=u;(t.updateQueue=p)&&(t.flags|=4)}},Zs=function(e,t,n,r){n!==r&&(t.flags|=4)};function fr(e,t){if(!b)switch(e.tailMode){case"hidden":t=e.tail;for(var n=null;t!==null;)t.alternate!==null&&(n=t),t=t.sibling;n===null?e.tail=null:n.sibling=null;break;case"collapsed":n=e.tail;for(var r=null;n!==null;)n.alternate!==null&&(r=n),n=n.sibling;r===null?t||e.tail===null?e.tail=null:e.tail.sibling=null:r.sibling=null}}function ke(e){var t=e.alternate!==null&&e.alternate.child===e.child,n=0,r=0;if(t)for(var l=e.child;l!==null;)n|=l.lanes|l.childLanes,r|=l.subtreeFlags&14680064,r|=l.flags&14680064,l.return=e,l=l.sibling;else for(l=e.child;l!==null;)n|=l.lanes|l.childLanes,r|=l.subtreeFlags,r|=l.flags,l.return=e,l=l.sibling;return e.subtreeFlags|=r,e.childLanes=n,t}function sf(e,t,n){var r=t.pendingProps;switch(Eu(t),t.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return ke(t),null;case 1:return Re(t.type)&&$r(),ke(t),null;case 3:return r=t.stateNode,Pn(),G(Te),G(we),Iu(),r.pendingContext&&(r.context=r.pendingContext,r.pendingContext=null),(e===null||e.child===null)&&(Gr(t)?t.flags|=4:e===null||e.memoizedState.isDehydrated&&(t.flags&256)===0||(t.flags|=1024,rt!==null&&(fo(rt),rt=null))),eo(e,t),ke(t),null;case 5:Mu(t);var l=bt(or.current);if(n=t.type,e!==null&&t.stateNode!=null)Gs(e,t,n,r,l),e.ref!==t.ref&&(t.flags|=512,t.flags|=2097152);else{if(!r){if(t.stateNode===null)throw Error(m(166));return ke(t),null}if(e=bt(pt.current),Gr(t)){r=t.stateNode,n=t.type;var u=t.memoizedProps;switch(r[dt]=t,r[tr]=u,e=(t.mode&1)!==0,n){case"dialog":X("cancel",r),X("close",r);break;case"iframe":case"object":case"embed":X("load",r);break;case"video":case"audio":for(l=0;l<qn.length;l++)X(qn[l],r);break;case"source":X("error",r);break;case"img":case"image":case"link":X("error",r),X("load",r);break;case"details":X("toggle",r);break;case"input":To(r,u),X("invalid",r);break;case"select":r._wrapperState={wasMultiple:!!u.multiple},X("invalid",r);break;case"textarea":Mo(r,u),X("invalid",r)}Dl(n,u),l=null;for(var o in u)if(u.hasOwnProperty(o)){var i=u[o];o==="children"?typeof i=="string"?r.textContent!==i&&(u.suppressHydrationWarning!==!0&&Br(r.textContent,i,e),l=["children",i]):typeof i=="number"&&r.textContent!==""+i&&(u.suppressHydrationWarning!==!0&&Br(r.textContent,i,e),l=["children",""+i]):A.hasOwnProperty(o)&&i!=null&&o==="onScroll"&&X("scroll",r)}switch(n){case"input":gr(r),Oo(r,u,!0);break;case"textarea":gr(r),Io(r);break;case"select":case"option":break;default:typeof u.onClick=="function"&&(r.onclick=Hr)}r=l,t.updateQueue=r,r!==null&&(t.flags|=4)}else{o=l.nodeType===9?l:l.ownerDocument,e==="http://www.w3.org/1999/xhtml"&&(e=jo(n)),e==="http://www.w3.org/1999/xhtml"?n==="script"?(e=o.createElement("div"),e.innerHTML="<script><\/script>",e=e.removeChild(e.firstChild)):typeof r.is=="string"?e=o.createElement(n,{is:r.is}):(e=o.createElement(n),n==="select"&&(o=e,r.multiple?o.multiple=!0:r.size&&(o.size=r.size))):e=o.createElementNS(e,n),e[dt]=t,e[tr]=r,Xs(e,t,!1,!1),t.stateNode=e;e:{switch(o=Il(n,r),n){case"dialog":X("cancel",e),X("close",e),l=r;break;case"iframe":case"object":case"embed":X("load",e),l=r;break;case"video":case"audio":for(l=0;l<qn.length;l++)X(qn[l],e);l=r;break;case"source":X("error",e),l=r;break;case"img":case"image":case"link":X("error",e),X("load",e),l=r;break;case"details":X("toggle",e),l=r;break;case"input":To(e,r),l=Ll(e,r),X("invalid",e);break;case"option":l=r;break;case"select":e._wrapperState={wasMultiple:!!r.multiple},l=_({},r,{value:void 0}),X("invalid",e);break;case"textarea":Mo(e,r),l=Ol(e,r),X("invalid",e);break;default:l=r}Dl(n,l),i=l;for(u in i)if(i.hasOwnProperty(u)){var s=i[u];u==="style"?Ao(e,s):u==="dangerouslySetInnerHTML"?(s=s?s.__html:void 0,s!=null&&Fo(e,s)):u==="children"?typeof s=="string"?(n!=="textarea"||s!=="")&&Mn(e,s):typeof s=="number"&&Mn(e,""+s):u!=="suppressContentEditableWarning"&&u!=="suppressHydrationWarning"&&u!=="autoFocus"&&(A.hasOwnProperty(u)?s!=null&&u==="onScroll"&&X("scroll",e):s!=null&&qe(e,u,s,o))}switch(n){case"input":gr(e),Oo(e,r,!1);break;case"textarea":gr(e),Io(e);break;case"option":r.value!=null&&e.setAttribute("value",""+V(r.value));break;case"select":e.multiple=!!r.multiple,u=r.value,u!=null?on(e,!!r.multiple,u,!1):r.defaultValue!=null&&on(e,!!r.multiple,r.defaultValue,!0);break;default:typeof l.onClick=="function"&&(e.onclick=Hr)}switch(n){case"button":case"input":case"select":case"textarea":r=!!r.autoFocus;break e;case"img":r=!0;break e;default:r=!1}}r&&(t.flags|=4)}t.ref!==null&&(t.flags|=512,t.flags|=2097152)}return ke(t),null;case 6:if(e&&t.stateNode!=null)Zs(e,t,e.memoizedProps,r);else{if(typeof r!="string"&&t.stateNode===null)throw Error(m(166));if(n=bt(or.current),bt(pt.current),Gr(t)){if(r=t.stateNode,n=t.memoizedProps,r[dt]=t,(u=r.nodeValue!==n)&&(e=Ve,e!==null))switch(e.tag){case 3:Br(r.nodeValue,n,(e.mode&1)!==0);break;case 5:e.memoizedProps.suppressHydrationWarning!==!0&&Br(r.nodeValue,n,(e.mode&1)!==0)}u&&(t.flags|=4)}else r=(n.nodeType===9?n:n.ownerDocument).createTextNode(r),r[dt]=t,t.stateNode=r}return ke(t),null;case 13:if(G(te),r=t.memoizedState,e===null||e.memoizedState!==null&&e.memoizedState.dehydrated!==null){if(b&&Be!==null&&(t.mode&1)!==0&&(t.flags&128)===0)bi(),En(),t.flags|=98560,u=!1;else if(u=Gr(t),r!==null&&r.dehydrated!==null){if(e===null){if(!u)throw Error(m(318));if(u=t.memoizedState,u=u!==null?u.dehydrated:null,!u)throw Error(m(317));u[dt]=t}else En(),(t.flags&128)===0&&(t.memoizedState=null),t.flags|=4;ke(t),u=!1}else rt!==null&&(fo(rt),rt=null),u=!0;if(!u)return t.flags&65536?t:null}return(t.flags&128)!==0?(t.lanes=n,t):(r=r!==null,r!==(e!==null&&e.memoizedState!==null)&&r&&(t.child.flags|=8192,(t.mode&1)!==0&&(e===null||(te.current&1)!==0?ae===0&&(ae=3):ho())),t.updateQueue!==null&&(t.flags|=4),ke(t),null);case 4:return Pn(),eo(e,t),e===null&&bn(t.stateNode.containerInfo),ke(t),null;case 10:return zu(t.type._context),ke(t),null;case 17:return Re(t.type)&&$r(),ke(t),null;case 19:if(G(te),u=t.memoizedState,u===null)return ke(t),null;if(r=(t.flags&128)!==0,o=u.rendering,o===null)if(r)fr(u,!1);else{if(ae!==0||e!==null&&(e.flags&128)!==0)for(e=t.child;e!==null;){if(o=tl(e),o!==null){for(t.flags|=128,fr(u,!1),r=o.updateQueue,r!==null&&(t.updateQueue=r,t.flags|=4),t.subtreeFlags=0,r=n,n=t.child;n!==null;)u=n,e=r,u.flags&=14680066,o=u.alternate,o===null?(u.childLanes=0,u.lanes=e,u.child=null,u.subtreeFlags=0,u.memoizedProps=null,u.memoizedState=null,u.updateQueue=null,u.dependencies=null,u.stateNode=null):(u.childLanes=o.childLanes,u.lanes=o.lanes,u.child=o.child,u.subtreeFlags=0,u.deletions=null,u.memoizedProps=o.memoizedProps,u.memoizedState=o.memoizedState,u.updateQueue=o.updateQueue,u.type=o.type,e=o.dependencies,u.dependencies=e===null?null:{lanes:e.lanes,firstContext:e.firstContext}),n=n.sibling;return K(te,te.current&1|2),t.child}e=e.sibling}u.tail!==null&&ue()>Tn&&(t.flags|=128,r=!0,fr(u,!1),t.lanes=4194304)}else{if(!r)if(e=tl(o),e!==null){if(t.flags|=128,r=!0,n=e.updateQueue,n!==null&&(t.updateQueue=n,t.flags|=4),fr(u,!0),u.tail===null&&u.tailMode==="hidden"&&!o.alternate&&!b)return ke(t),null}else 2*ue()-u.renderingStartTime>Tn&&n!==1073741824&&(t.flags|=128,r=!0,fr(u,!1),t.lanes=4194304);u.isBackwards?(o.sibling=t.child,t.child=o):(n=u.last,n!==null?n.sibling=o:t.child=o,u.last=o)}return u.tail!==null?(t=u.tail,u.rendering=t,u.tail=t.sibling,u.renderingStartTime=ue(),t.sibling=null,n=te.current,K(te,r?n&1|2:n&1),t):(ke(t),null);case 22:case 23:return mo(),r=t.memoizedState!==null,e!==null&&e.memoizedState!==null!==r&&(t.flags|=8192),r&&(t.mode&1)!==0?(He&1073741824)!==0&&(ke(t),t.subtreeFlags&6&&(t.flags|=8192)):ke(t),null;case 24:return null;case 25:return null}throw Error(m(156,t.tag))}function af(e,t){switch(Eu(t),t.tag){case 1:return Re(t.type)&&$r(),e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 3:return Pn(),G(Te),G(we),Iu(),e=t.flags,(e&65536)!==0&&(e&128)===0?(t.flags=e&-65537|128,t):null;case 5:return Mu(t),null;case 13:if(G(te),e=t.memoizedState,e!==null&&e.dehydrated!==null){if(t.alternate===null)throw Error(m(340));En()}return e=t.flags,e&65536?(t.flags=e&-65537|128,t):null;case 19:return G(te),null;case 4:return Pn(),null;case 10:return zu(t.type._context),null;case 22:case 23:return mo(),null;case 24:return null;default:return null}}var cl=!1,Ee=!1,cf=typeof WeakSet=="function"?WeakSet:Set,E=null;function zn(e,t){var n=e.ref;if(n!==null)if(typeof n=="function")try{n(null)}catch(r){le(e,t,r)}else n.current=null}function to(e,t,n){try{n()}catch(r){le(e,t,r)}}var Js=!1;function ff(e,t){if(pu=Tr,e=Li(),uu(e)){if("selectionStart"in e)var n={start:e.selectionStart,end:e.selectionEnd};else e:{n=(n=e.ownerDocument)&&n.defaultView||window;var r=n.getSelection&&n.getSelection();if(r&&r.rangeCount!==0){n=r.anchorNode;var l=r.anchorOffset,u=r.focusNode;r=r.focusOffset;try{n.nodeType,u.nodeType}catch{n=null;break e}var o=0,i=-1,s=-1,p=0,y=0,g=e,h=null;t:for(;;){for(var k;g!==n||l!==0&&g.nodeType!==3||(i=o+l),g!==u||r!==0&&g.nodeType!==3||(s=o+r),g.nodeType===3&&(o+=g.nodeValue.length),(k=g.firstChild)!==null;)h=g,g=k;for(;;){if(g===e)break t;if(h===n&&++p===l&&(i=o),h===u&&++y===r&&(s=o),(k=g.nextSibling)!==null)break;g=h,h=g.parentNode}g=k}n=i===-1||s===-1?null:{start:i,end:s}}else n=null}n=n||{start:0,end:0}}else n=null;for(mu={focusedElem:e,selectionRange:n},Tr=!1,E=t;E!==null;)if(t=E,e=t.child,(t.subtreeFlags&1028)!==0&&e!==null)e.return=t,E=e;else for(;E!==null;){t=E;try{var C=t.alternate;if((t.flags&1024)!==0)switch(t.tag){case 0:case 11:case 15:break;case 1:if(C!==null){var x=C.memoizedProps,oe=C.memoizedState,f=t.stateNode,a=f.getSnapshotBeforeUpdate(t.elementType===t.type?x:lt(t.type,x),oe);f.__reactInternalSnapshotBeforeUpdate=a}break;case 3:var d=t.stateNode.containerInfo;d.nodeType===1?d.textContent="":d.nodeType===9&&d.documentElement&&d.removeChild(d.documentElement);break;case 5:case 6:case 4:case 17:break;default:throw Error(m(163))}}catch(w){le(t,t.return,w)}if(e=t.sibling,e!==null){e.return=t.return,E=e;break}E=t.return}return C=Js,Js=!1,C}function dr(e,t,n){var r=t.updateQueue;if(r=r!==null?r.lastEffect:null,r!==null){var l=r=r.next;do{if((l.tag&e)===e){var u=l.destroy;l.destroy=void 0,u!==void 0&&to(t,n,u)}l=l.next}while(l!==r)}}function fl(e,t){if(t=t.updateQueue,t=t!==null?t.lastEffect:null,t!==null){var n=t=t.next;do{if((n.tag&e)===e){var r=n.create;n.destroy=r()}n=n.next}while(n!==t)}}function no(e){var t=e.ref;if(t!==null){var n=e.stateNode;switch(e.tag){case 5:e=n;break;default:e=n}typeof t=="function"?t(e):t.current=e}}function qs(e){var t=e.alternate;t!==null&&(e.alternate=null,qs(t)),e.child=null,e.deletions=null,e.sibling=null,e.tag===5&&(t=e.stateNode,t!==null&&(delete t[dt],delete t[tr],delete t[gu],delete t[Kc],delete t[Yc])),e.stateNode=null,e.return=null,e.dependencies=null,e.memoizedProps=null,e.memoizedState=null,e.pendingProps=null,e.stateNode=null,e.updateQueue=null}function bs(e){return e.tag===5||e.tag===3||e.tag===4}function ea(e){e:for(;;){for(;e.sibling===null;){if(e.return===null||bs(e.return))return null;e=e.return}for(e.sibling.return=e.return,e=e.sibling;e.tag!==5&&e.tag!==6&&e.tag!==18;){if(e.flags&2||e.child===null||e.tag===4)continue e;e.child.return=e,e=e.child}if(!(e.flags&2))return e.stateNode}}function ro(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.nodeType===8?n.parentNode.insertBefore(e,t):n.insertBefore(e,t):(n.nodeType===8?(t=n.parentNode,t.insertBefore(e,n)):(t=n,t.appendChild(e)),n=n._reactRootContainer,n!=null||t.onclick!==null||(t.onclick=Hr));else if(r!==4&&(e=e.child,e!==null))for(ro(e,t,n),e=e.sibling;e!==null;)ro(e,t,n),e=e.sibling}function lo(e,t,n){var r=e.tag;if(r===5||r===6)e=e.stateNode,t?n.insertBefore(e,t):n.appendChild(e);else if(r!==4&&(e=e.child,e!==null))for(lo(e,t,n),e=e.sibling;e!==null;)lo(e,t,n),e=e.sibling}var he=null,ut=!1;function At(e,t,n){for(n=n.child;n!==null;)ta(e,t,n),n=n.sibling}function ta(e,t,n){if(ft&&typeof ft.onCommitFiberUnmount=="function")try{ft.onCommitFiberUnmount(Cr,n)}catch{}switch(n.tag){case 5:Ee||zn(n,t);case 6:var r=he,l=ut;he=null,At(e,t,n),he=r,ut=l,he!==null&&(ut?(e=he,n=n.stateNode,e.nodeType===8?e.parentNode.removeChild(n):e.removeChild(n)):he.removeChild(n.stateNode));break;case 18:he!==null&&(ut?(e=he,n=n.stateNode,e.nodeType===8?yu(e.parentNode,n):e.nodeType===1&&yu(e,n),$n(e)):yu(he,n.stateNode));break;case 4:r=he,l=ut,he=n.stateNode.containerInfo,ut=!0,At(e,t,n),he=r,ut=l;break;case 0:case 11:case 14:case 15:if(!Ee&&(r=n.updateQueue,r!==null&&(r=r.lastEffect,r!==null))){l=r=r.next;do{var u=l,o=u.destroy;u=u.tag,o!==void 0&&((u&2)!==0||(u&4)!==0)&&to(n,t,o),l=l.next}while(l!==r)}At(e,t,n);break;case 1:if(!Ee&&(zn(n,t),r=n.stateNode,typeof r.componentWillUnmount=="function"))try{r.props=n.memoizedProps,r.state=n.memoizedState,r.componentWillUnmount()}catch(i){le(n,t,i)}At(e,t,n);break;case 21:At(e,t,n);break;case 22:n.mode&1?(Ee=(r=Ee)||n.memoizedState!==null,At(e,t,n),Ee=r):At(e,t,n);break;default:At(e,t,n)}}function na(e){var t=e.updateQueue;if(t!==null){e.updateQueue=null;var n=e.stateNode;n===null&&(n=e.stateNode=new cf),t.forEach(function(r){var l=Sf.bind(null,e,r);n.has(r)||(n.add(r),r.then(l,l))})}}function ot(e,t){var n=t.deletions;if(n!==null)for(var r=0;r<n.length;r++){var l=n[r];try{var u=e,o=t,i=o;e:for(;i!==null;){switch(i.tag){case 5:he=i.stateNode,ut=!1;break e;case 3:he=i.stateNode.containerInfo,ut=!0;break e;case 4:he=i.stateNode.containerInfo,ut=!0;break e}i=i.return}if(he===null)throw Error(m(160));ta(u,o,l),he=null,ut=!1;var s=l.alternate;s!==null&&(s.return=null),l.return=null}catch(p){le(l,t,p)}}if(t.subtreeFlags&12854)for(t=t.child;t!==null;)ra(t,e),t=t.sibling}function ra(e,t){var n=e.alternate,r=e.flags;switch(e.tag){case 0:case 11:case 14:case 15:if(ot(t,e),ht(e),r&4){try{dr(3,e,e.return),fl(3,e)}catch(x){le(e,e.return,x)}try{dr(5,e,e.return)}catch(x){le(e,e.return,x)}}break;case 1:ot(t,e),ht(e),r&512&&n!==null&&zn(n,n.return);break;case 5:if(ot(t,e),ht(e),r&512&&n!==null&&zn(n,n.return),e.flags&32){var l=e.stateNode;try{Mn(l,"")}catch(x){le(e,e.return,x)}}if(r&4&&(l=e.stateNode,l!=null)){var u=e.memoizedProps,o=n!==null?n.memoizedProps:u,i=e.type,s=e.updateQueue;if(e.updateQueue=null,s!==null)try{i==="input"&&u.type==="radio"&&u.name!=null&&Ro(l,u),Il(i,o);var p=Il(i,u);for(o=0;o<s.length;o+=2){var y=s[o],g=s[o+1];y==="style"?Ao(l,g):y==="dangerouslySetInnerHTML"?Fo(l,g):y==="children"?Mn(l,g):qe(l,y,g,p)}switch(i){case"input":Tl(l,u);break;case"textarea":Do(l,u);break;case"select":var h=l._wrapperState.wasMultiple;l._wrapperState.wasMultiple=!!u.multiple;var k=u.value;k!=null?on(l,!!u.multiple,k,!1):h!==!!u.multiple&&(u.defaultValue!=null?on(l,!!u.multiple,u.defaultValue,!0):on(l,!!u.multiple,u.multiple?[]:"",!1))}l[tr]=u}catch(x){le(e,e.return,x)}}break;case 6:if(ot(t,e),ht(e),r&4){if(e.stateNode===null)throw Error(m(162));l=e.stateNode,u=e.memoizedProps;try{l.nodeValue=u}catch(x){le(e,e.return,x)}}break;case 3:if(ot(t,e),ht(e),r&4&&n!==null&&n.memoizedState.isDehydrated)try{$n(t.containerInfo)}catch(x){le(e,e.return,x)}break;case 4:ot(t,e),ht(e);break;case 13:ot(t,e),ht(e),l=e.child,l.flags&8192&&(u=l.memoizedState!==null,l.stateNode.isHidden=u,!u||l.alternate!==null&&l.alternate.memoizedState!==null||(io=ue())),r&4&&na(e);break;case 22:if(y=n!==null&&n.memoizedState!==null,e.mode&1?(Ee=(p=Ee)||y,ot(t,e),Ee=p):ot(t,e),ht(e),r&8192){if(p=e.memoizedState!==null,(e.stateNode.isHidden=p)&&!y&&(e.mode&1)!==0)for(E=e,y=e.child;y!==null;){for(g=E=y;E!==null;){switch(h=E,k=h.child,h.tag){case 0:case 11:case 14:case 15:dr(4,h,h.return);break;case 1:zn(h,h.return);var C=h.stateNode;if(typeof C.componentWillUnmount=="function"){r=h,n=h.return;try{t=r,C.props=t.memoizedProps,C.state=t.memoizedState,C.componentWillUnmount()}catch(x){le(r,n,x)}}break;case 5:zn(h,h.return);break;case 22:if(h.memoizedState!==null){oa(g);continue}}k!==null?(k.return=h,E=k):oa(g)}y=y.sibling}e:for(y=null,g=e;;){if(g.tag===5){if(y===null){y=g;try{l=g.stateNode,p?(u=l.style,typeof u.setProperty=="function"?u.setProperty("display","none","important"):u.display="none"):(i=g.stateNode,s=g.memoizedProps.style,o=s!=null&&s.hasOwnProperty("display")?s.display:null,i.style.display=Uo("display",o))}catch(x){le(e,e.return,x)}}}else if(g.tag===6){if(y===null)try{g.stateNode.nodeValue=p?"":g.memoizedProps}catch(x){le(e,e.return,x)}}else if((g.tag!==22&&g.tag!==23||g.memoizedState===null||g===e)&&g.child!==null){g.child.return=g,g=g.child;continue}if(g===e)break e;for(;g.sibling===null;){if(g.return===null||g.return===e)break e;y===g&&(y=null),g=g.return}y===g&&(y=null),g.sibling.return=g.return,g=g.sibling}}break;case 19:ot(t,e),ht(e),r&4&&na(e);break;case 21:break;default:ot(t,e),ht(e)}}function ht(e){var t=e.flags;if(t&2){try{e:{for(var n=e.return;n!==null;){if(bs(n)){var r=n;break e}n=n.return}throw Error(m(160))}switch(r.tag){case 5:var l=r.stateNode;r.flags&32&&(Mn(l,""),r.flags&=-33);var u=ea(e);lo(e,u,l);break;case 3:case 4:var o=r.stateNode.containerInfo,i=ea(e);ro(e,i,o);break;default:throw Error(m(161))}}catch(s){le(e,e.return,s)}e.flags&=-3}t&4096&&(e.flags&=-4097)}function df(e,t,n){E=e,la(e)}function la(e,t,n){for(var r=(e.mode&1)!==0;E!==null;){var l=E,u=l.child;if(l.tag===22&&r){var o=l.memoizedState!==null||cl;if(!o){var i=l.alternate,s=i!==null&&i.memoizedState!==null||Ee;i=cl;var p=Ee;if(cl=o,(Ee=s)&&!p)for(E=l;E!==null;)o=E,s=o.child,o.tag===22&&o.memoizedState!==null?ia(l):s!==null?(s.return=o,E=s):ia(l);for(;u!==null;)E=u,la(u),u=u.sibling;E=l,cl=i,Ee=p}ua(e)}else(l.subtreeFlags&8772)!==0&&u!==null?(u.return=l,E=u):ua(e)}}function ua(e){for(;E!==null;){var t=E;if((t.flags&8772)!==0){var n=t.alternate;try{if((t.flags&8772)!==0)switch(t.tag){case 0:case 11:case 15:Ee||fl(5,t);break;case 1:var r=t.stateNode;if(t.flags&4&&!Ee)if(n===null)r.componentDidMount();else{var l=t.elementType===t.type?n.memoizedProps:lt(t.type,n.memoizedProps);r.componentDidUpdate(l,n.memoizedState,r.__reactInternalSnapshotBeforeUpdate)}var u=t.updateQueue;u!==null&&os(t,u,r);break;case 3:var o=t.updateQueue;if(o!==null){if(n=null,t.child!==null)switch(t.child.tag){case 5:n=t.child.stateNode;break;case 1:n=t.child.stateNode}os(t,o,n)}break;case 5:var i=t.stateNode;if(n===null&&t.flags&4){n=i;var s=t.memoizedProps;switch(t.type){case"button":case"input":case"select":case"textarea":s.autoFocus&&n.focus();break;case"img":s.src&&(n.src=s.src)}}break;case 6:break;case 4:break;case 12:break;case 13:if(t.memoizedState===null){var p=t.alternate;if(p!==null){var y=p.memoizedState;if(y!==null){var g=y.dehydrated;g!==null&&$n(g)}}}break;case 19:case 17:case 21:case 22:case 23:case 25:break;default:throw Error(m(163))}Ee||t.flags&512&&no(t)}catch(h){le(t,t.return,h)}}if(t===e){E=null;break}if(n=t.sibling,n!==null){n.return=t.return,E=n;break}E=t.return}}function oa(e){for(;E!==null;){var t=E;if(t===e){E=null;break}var n=t.sibling;if(n!==null){n.return=t.return,E=n;break}E=t.return}}function ia(e){for(;E!==null;){var t=E;try{switch(t.tag){case 0:case 11:case 15:var n=t.return;try{fl(4,t)}catch(s){le(t,n,s)}break;case 1:var r=t.stateNode;if(typeof r.componentDidMount=="function"){var l=t.return;try{r.componentDidMount()}catch(s){le(t,l,s)}}var u=t.return;try{no(t)}catch(s){le(t,u,s)}break;case 5:var o=t.return;try{no(t)}catch(s){le(t,o,s)}}}catch(s){le(t,t.return,s)}if(t===e){E=null;break}var i=t.sibling;if(i!==null){i.return=t.return,E=i;break}E=t.return}}var pf=Math.ceil,dl=ge.ReactCurrentDispatcher,uo=ge.ReactCurrentOwner,Ze=ge.ReactCurrentBatchConfig,I=0,pe=null,ie=null,ve=0,He=0,Ln=Dt(0),ae=0,pr=null,tn=0,pl=0,oo=0,mr=null,Me=null,io=0,Tn=1/0,xt=null,ml=!1,so=null,Vt=null,hl=!1,Bt=null,vl=0,hr=0,ao=null,yl=-1,gl=0;function Pe(){return(I&6)!==0?ue():yl!==-1?yl:yl=ue()}function Ht(e){return(e.mode&1)===0?1:(I&2)!==0&&ve!==0?ve&-ve:Gc.transition!==null?(gl===0&&(gl=ei()),gl):(e=B,e!==0||(e=window.event,e=e===void 0?16:ai(e.type)),e)}function it(e,t,n,r){if(50<hr)throw hr=0,ao=null,Error(m(185));An(e,n,r),((I&2)===0||e!==pe)&&(e===pe&&((I&2)===0&&(pl|=n),ae===4&&Wt(e,ve)),De(e,r),n===1&&I===0&&(t.mode&1)===0&&(Tn=ue()+500,Kr&&jt()))}function De(e,t){var n=e.callbackNode;Ga(e,t);var r=Nr(e,e===pe?ve:0);if(r===0)n!==null&&Jo(n),e.callbackNode=null,e.callbackPriority=0;else if(t=r&-r,e.callbackPriority!==t){if(n!=null&&Jo(n),t===1)e.tag===0?Xc(aa.bind(null,e)):Xi(aa.bind(null,e)),$c(function(){(I&6)===0&&jt()}),n=null;else{switch(ti(r)){case 1:n=Hl;break;case 4:n=qo;break;case 16:n=_r;break;case 536870912:n=bo;break;default:n=_r}n=ya(n,sa.bind(null,e))}e.callbackPriority=t,e.callbackNode=n}}function sa(e,t){if(yl=-1,gl=0,(I&6)!==0)throw Error(m(327));var n=e.callbackNode;if(Rn()&&e.callbackNode!==n)return null;var r=Nr(e,e===pe?ve:0);if(r===0)return null;if((r&30)!==0||(r&e.expiredLanes)!==0||t)t=wl(e,r);else{t=r;var l=I;I|=2;var u=fa();(pe!==e||ve!==t)&&(xt=null,Tn=ue()+500,rn(e,t));do try{vf();break}catch(i){ca(e,i)}while(!0);Nu(),dl.current=u,I=l,ie!==null?t=0:(pe=null,ve=0,t=ae)}if(t!==0){if(t===2&&(l=Wl(e),l!==0&&(r=l,t=co(e,l))),t===1)throw n=pr,rn(e,0),Wt(e,r),De(e,ue()),n;if(t===6)Wt(e,r);else{if(l=e.current.alternate,(r&30)===0&&!mf(l)&&(t=wl(e,r),t===2&&(u=Wl(e),u!==0&&(r=u,t=co(e,u))),t===1))throw n=pr,rn(e,0),Wt(e,r),De(e,ue()),n;switch(e.finishedWork=l,e.finishedLanes=r,t){case 0:case 1:throw Error(m(345));case 2:ln(e,Me,xt);break;case 3:if(Wt(e,r),(r&130023424)===r&&(t=io+500-ue(),10<t)){if(Nr(e,0)!==0)break;if(l=e.suspendedLanes,(l&r)!==r){Pe(),e.pingedLanes|=e.suspendedLanes&l;break}e.timeoutHandle=vu(ln.bind(null,e,Me,xt),t);break}ln(e,Me,xt);break;case 4:if(Wt(e,r),(r&4194240)===r)break;for(t=e.eventTimes,l=-1;0<r;){var o=31-tt(r);u=1<<o,o=t[o],o>l&&(l=o),r&=~u}if(r=l,r=ue()-r,r=(120>r?120:480>r?480:1080>r?1080:1920>r?1920:3e3>r?3e3:4320>r?4320:1960*pf(r/1960))-r,10<r){e.timeoutHandle=vu(ln.bind(null,e,Me,xt),r);break}ln(e,Me,xt);break;case 5:ln(e,Me,xt);break;default:throw Error(m(329))}}}return De(e,ue()),e.callbackNode===n?sa.bind(null,e):null}function co(e,t){var n=mr;return e.current.memoizedState.isDehydrated&&(rn(e,t).flags|=256),e=wl(e,t),e!==2&&(t=Me,Me=n,t!==null&&fo(t)),e}function fo(e){Me===null?Me=e:Me.push.apply(Me,e)}function mf(e){for(var t=e;;){if(t.flags&16384){var n=t.updateQueue;if(n!==null&&(n=n.stores,n!==null))for(var r=0;r<n.length;r++){var l=n[r],u=l.getSnapshot;l=l.value;try{if(!nt(u(),l))return!1}catch{return!1}}}if(n=t.child,t.subtreeFlags&16384&&n!==null)n.return=t,t=n;else{if(t===e)break;for(;t.sibling===null;){if(t.return===null||t.return===e)return!0;t=t.return}t.sibling.return=t.return,t=t.sibling}}return!0}function Wt(e,t){for(t&=~oo,t&=~pl,e.suspendedLanes|=t,e.pingedLanes&=~t,e=e.expirationTimes;0<t;){var n=31-tt(t),r=1<<n;e[n]=-1,t&=~r}}function aa(e){if((I&6)!==0)throw Error(m(327));Rn();var t=Nr(e,0);if((t&1)===0)return De(e,ue()),null;var n=wl(e,t);if(e.tag!==0&&n===2){var r=Wl(e);r!==0&&(t=r,n=co(e,r))}if(n===1)throw n=pr,rn(e,0),Wt(e,t),De(e,ue()),n;if(n===6)throw Error(m(345));return e.finishedWork=e.current.alternate,e.finishedLanes=t,ln(e,Me,xt),De(e,ue()),null}function po(e,t){var n=I;I|=1;try{return e(t)}finally{I=n,I===0&&(Tn=ue()+500,Kr&&jt())}}function nn(e){Bt!==null&&Bt.tag===0&&(I&6)===0&&Rn();var t=I;I|=1;var n=Ze.transition,r=B;try{if(Ze.transition=null,B=1,e)return e()}finally{B=r,Ze.transition=n,I=t,(I&6)===0&&jt()}}function mo(){He=Ln.current,G(Ln)}function rn(e,t){e.finishedWork=null,e.finishedLanes=0;var n=e.timeoutHandle;if(n!==-1&&(e.timeoutHandle=-1,Wc(n)),ie!==null)for(n=ie.return;n!==null;){var r=n;switch(Eu(r),r.tag){case 1:r=r.type.childContextTypes,r!=null&&$r();break;case 3:Pn(),G(Te),G(we),Iu();break;case 5:Mu(r);break;case 4:Pn();break;case 13:G(te);break;case 19:G(te);break;case 10:zu(r.type._context);break;case 22:case 23:mo()}n=n.return}if(pe=e,ie=e=$t(e.current,null),ve=He=t,ae=0,pr=null,oo=pl=tn=0,Me=mr=null,qt!==null){for(t=0;t<qt.length;t++)if(n=qt[t],r=n.interleaved,r!==null){n.interleaved=null;var l=r.next,u=n.pending;if(u!==null){var o=u.next;u.next=l,r.next=o}n.pending=r}qt=null}return e}function ca(e,t){do{var n=ie;try{if(Nu(),nl.current=ol,rl){for(var r=ne.memoizedState;r!==null;){var l=r.queue;l!==null&&(l.pending=null),r=r.next}rl=!1}if(en=0,de=se=ne=null,ir=!1,sr=0,uo.current=null,n===null||n.return===null){ae=1,pr=t,ie=null;break}e:{var u=e,o=n.return,i=n,s=t;if(t=ve,i.flags|=32768,s!==null&&typeof s=="object"&&typeof s.then=="function"){var p=s,y=i,g=y.tag;if((y.mode&1)===0&&(g===0||g===11||g===15)){var h=y.alternate;h?(y.updateQueue=h.updateQueue,y.memoizedState=h.memoizedState,y.lanes=h.lanes):(y.updateQueue=null,y.memoizedState=null)}var k=Is(o);if(k!==null){k.flags&=-257,js(k,o,i,u,t),k.mode&1&&Ds(u,p,t),t=k,s=p;var C=t.updateQueue;if(C===null){var x=new Set;x.add(s),t.updateQueue=x}else C.add(s);break e}else{if((t&1)===0){Ds(u,p,t),ho();break e}s=Error(m(426))}}else if(b&&i.mode&1){var oe=Is(o);if(oe!==null){(oe.flags&65536)===0&&(oe.flags|=256),js(oe,o,i,u,t),xu(Nn(s,i));break e}}u=s=Nn(s,i),ae!==4&&(ae=2),mr===null?mr=[u]:mr.push(u),u=o;do{switch(u.tag){case 3:u.flags|=65536,t&=-t,u.lanes|=t;var f=Os(u,s,t);us(u,f);break e;case 1:i=s;var a=u.type,d=u.stateNode;if((u.flags&128)===0&&(typeof a.getDerivedStateFromError=="function"||d!==null&&typeof d.componentDidCatch=="function"&&(Vt===null||!Vt.has(d)))){u.flags|=65536,t&=-t,u.lanes|=t;var w=Ms(u,i,t);us(u,w);break e}}u=u.return}while(u!==null)}pa(n)}catch(P){t=P,ie===n&&n!==null&&(ie=n=n.return);continue}break}while(!0)}function fa(){var e=dl.current;return dl.current=ol,e===null?ol:e}function ho(){(ae===0||ae===3||ae===2)&&(ae=4),pe===null||(tn&268435455)===0&&(pl&268435455)===0||Wt(pe,ve)}function wl(e,t){var n=I;I|=2;var r=fa();(pe!==e||ve!==t)&&(xt=null,rn(e,t));do try{hf();break}catch(l){ca(e,l)}while(!0);if(Nu(),I=n,dl.current=r,ie!==null)throw Error(m(261));return pe=null,ve=0,ae}function hf(){for(;ie!==null;)da(ie)}function vf(){for(;ie!==null&&!Va();)da(ie)}function da(e){var t=va(e.alternate,e,He);e.memoizedProps=e.pendingProps,t===null?pa(e):ie=t,uo.current=null}function pa(e){var t=e;do{var n=t.alternate;if(e=t.return,(t.flags&32768)===0){if(n=sf(n,t,He),n!==null){ie=n;return}}else{if(n=af(n,t),n!==null){n.flags&=32767,ie=n;return}if(e!==null)e.flags|=32768,e.subtreeFlags=0,e.deletions=null;else{ae=6,ie=null;return}}if(t=t.sibling,t!==null){ie=t;return}ie=t=e}while(t!==null);ae===0&&(ae=5)}function ln(e,t,n){var r=B,l=Ze.transition;try{Ze.transition=null,B=1,yf(e,t,n,r)}finally{Ze.transition=l,B=r}return null}function yf(e,t,n,r){do Rn();while(Bt!==null);if((I&6)!==0)throw Error(m(327));n=e.finishedWork;var l=e.finishedLanes;if(n===null)return null;if(e.finishedWork=null,e.finishedLanes=0,n===e.current)throw Error(m(177));e.callbackNode=null,e.callbackPriority=0;var u=n.lanes|n.childLanes;if(Za(e,u),e===pe&&(ie=pe=null,ve=0),(n.subtreeFlags&2064)===0&&(n.flags&2064)===0||hl||(hl=!0,ya(_r,function(){return Rn(),null})),u=(n.flags&15990)!==0,(n.subtreeFlags&15990)!==0||u){u=Ze.transition,Ze.transition=null;var o=B;B=1;var i=I;I|=4,uo.current=null,ff(e,n),ra(n,e),jc(mu),Tr=!!pu,mu=pu=null,e.current=n,df(n),Ba(),I=i,B=o,Ze.transition=u}else e.current=n;if(hl&&(hl=!1,Bt=e,vl=l),u=e.pendingLanes,u===0&&(Vt=null),$a(n.stateNode),De(e,ue()),t!==null)for(r=e.onRecoverableError,n=0;n<t.length;n++)l=t[n],r(l.value,{componentStack:l.stack,digest:l.digest});if(ml)throw ml=!1,e=so,so=null,e;return(vl&1)!==0&&e.tag!==0&&Rn(),u=e.pendingLanes,(u&1)!==0?e===ao?hr++:(hr=0,ao=e):hr=0,jt(),null}function Rn(){if(Bt!==null){var e=ti(vl),t=Ze.transition,n=B;try{if(Ze.transition=null,B=16>e?16:e,Bt===null)var r=!1;else{if(e=Bt,Bt=null,vl=0,(I&6)!==0)throw Error(m(331));var l=I;for(I|=4,E=e.current;E!==null;){var u=E,o=u.child;if((E.flags&16)!==0){var i=u.deletions;if(i!==null){for(var s=0;s<i.length;s++){var p=i[s];for(E=p;E!==null;){var y=E;switch(y.tag){case 0:case 11:case 15:dr(8,y,u)}var g=y.child;if(g!==null)g.return=y,E=g;else for(;E!==null;){y=E;var h=y.sibling,k=y.return;if(qs(y),y===p){E=null;break}if(h!==null){h.return=k,E=h;break}E=k}}}var C=u.alternate;if(C!==null){var x=C.child;if(x!==null){C.child=null;do{var oe=x.sibling;x.sibling=null,x=oe}while(x!==null)}}E=u}}if((u.subtreeFlags&2064)!==0&&o!==null)o.return=u,E=o;else e:for(;E!==null;){if(u=E,(u.flags&2048)!==0)switch(u.tag){case 0:case 11:case 15:dr(9,u,u.return)}var f=u.sibling;if(f!==null){f.return=u.return,E=f;break e}E=u.return}}var a=e.current;for(E=a;E!==null;){o=E;var d=o.child;if((o.subtreeFlags&2064)!==0&&d!==null)d.return=o,E=d;else e:for(o=a;E!==null;){if(i=E,(i.flags&2048)!==0)try{switch(i.tag){case 0:case 11:case 15:fl(9,i)}}catch(P){le(i,i.return,P)}if(i===o){E=null;break e}var w=i.sibling;if(w!==null){w.return=i.return,E=w;break e}E=i.return}}if(I=l,jt(),ft&&typeof ft.onPostCommitFiberRoot=="function")try{ft.onPostCommitFiberRoot(Cr,e)}catch{}r=!0}return r}finally{B=n,Ze.transition=t}}return!1}function ma(e,t,n){t=Nn(n,t),t=Os(e,t,1),e=Ut(e,t,1),t=Pe(),e!==null&&(An(e,1,t),De(e,t))}function le(e,t,n){if(e.tag===3)ma(e,e,n);else for(;t!==null;){if(t.tag===3){ma(t,e,n);break}else if(t.tag===1){var r=t.stateNode;if(typeof t.type.getDerivedStateFromError=="function"||typeof r.componentDidCatch=="function"&&(Vt===null||!Vt.has(r))){e=Nn(n,e),e=Ms(t,e,1),t=Ut(t,e,1),e=Pe(),t!==null&&(An(t,1,e),De(t,e));break}}t=t.return}}function gf(e,t,n){var r=e.pingCache;r!==null&&r.delete(t),t=Pe(),e.pingedLanes|=e.suspendedLanes&n,pe===e&&(ve&n)===n&&(ae===4||ae===3&&(ve&130023424)===ve&&500>ue()-io?rn(e,0):oo|=n),De(e,t)}function ha(e,t){t===0&&((e.mode&1)===0?t=1:(t=Pr,Pr<<=1,(Pr&130023424)===0&&(Pr=4194304)));var n=Pe();e=Et(e,t),e!==null&&(An(e,t,n),De(e,n))}function wf(e){var t=e.memoizedState,n=0;t!==null&&(n=t.retryLane),ha(e,n)}function Sf(e,t){var n=0;switch(e.tag){case 13:var r=e.stateNode,l=e.memoizedState;l!==null&&(n=l.retryLane);break;case 19:r=e.stateNode;break;default:throw Error(m(314))}r!==null&&r.delete(t),ha(e,n)}var va;va=function(e,t,n){if(e!==null)if(e.memoizedProps!==t.pendingProps||Te.current)Oe=!0;else{if((e.lanes&n)===0&&(t.flags&128)===0)return Oe=!1,of(e,t,n);Oe=(e.flags&131072)!==0}else Oe=!1,b&&(t.flags&1048576)!==0&&Gi(t,Xr,t.index);switch(t.lanes=0,t.tag){case 2:var r=t.type;al(e,t),e=t.pendingProps;var l=wn(t,we.current);xn(t,n),l=Uu(null,t,r,e,l,n);var u=Au();return t.flags|=1,typeof l=="object"&&l!==null&&typeof l.render=="function"&&l.$$typeof===void 0?(t.tag=1,t.memoizedState=null,t.updateQueue=null,Re(r)?(u=!0,Qr(t)):u=!1,t.memoizedState=l.state!==null&&l.state!==void 0?l.state:null,Ru(t),l.updater=il,t.stateNode=l,l._reactInternals=t,Qu(t,r,e,n),t=Gu(null,t,r,!0,u,n)):(t.tag=0,b&&u&&ku(t),xe(null,t,l,n),t=t.child),t;case 16:r=t.elementType;e:{switch(al(e,t),e=t.pendingProps,l=r._init,r=l(r._payload),t.type=r,l=t.tag=Ef(r),e=lt(r,e),l){case 0:t=Xu(null,t,r,e,n);break e;case 1:t=Hs(null,t,r,e,n);break e;case 11:t=Fs(null,t,r,e,n);break e;case 14:t=Us(null,t,r,lt(r.type,e),n);break e}throw Error(m(306,r,""))}return t;case 0:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:lt(r,l),Xu(e,t,r,l,n);case 1:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:lt(r,l),Hs(e,t,r,l,n);case 3:e:{if(Ws(t),e===null)throw Error(m(387));r=t.pendingProps,u=t.memoizedState,l=u.element,ls(e,t),el(t,r,null,n);var o=t.memoizedState;if(r=o.element,u.isDehydrated)if(u={element:r,isDehydrated:!1,cache:o.cache,pendingSuspenseBoundaries:o.pendingSuspenseBoundaries,transitions:o.transitions},t.updateQueue.baseState=u,t.memoizedState=u,t.flags&256){l=Nn(Error(m(423)),t),t=$s(e,t,r,n,l);break e}else if(r!==l){l=Nn(Error(m(424)),t),t=$s(e,t,r,n,l);break e}else for(Be=Mt(t.stateNode.containerInfo.firstChild),Ve=t,b=!0,rt=null,n=ns(t,null,r,n),t.child=n;n;)n.flags=n.flags&-3|4096,n=n.sibling;else{if(En(),r===l){t=Ct(e,t,n);break e}xe(e,t,r,n)}t=t.child}return t;case 5:return is(t),e===null&&Cu(t),r=t.type,l=t.pendingProps,u=e!==null?e.memoizedProps:null,o=l.children,hu(r,l)?o=null:u!==null&&hu(r,u)&&(t.flags|=32),Bs(e,t),xe(e,t,o,n),t.child;case 6:return e===null&&Cu(t),null;case 13:return Qs(e,t,n);case 4:return Ou(t,t.stateNode.containerInfo),r=t.pendingProps,e===null?t.child=_n(t,null,r,n):xe(e,t,r,n),t.child;case 11:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:lt(r,l),Fs(e,t,r,l,n);case 7:return xe(e,t,t.pendingProps,n),t.child;case 8:return xe(e,t,t.pendingProps.children,n),t.child;case 12:return xe(e,t,t.pendingProps.children,n),t.child;case 10:e:{if(r=t.type._context,l=t.pendingProps,u=t.memoizedProps,o=l.value,K(Jr,r._currentValue),r._currentValue=o,u!==null)if(nt(u.value,o)){if(u.children===l.children&&!Te.current){t=Ct(e,t,n);break e}}else for(u=t.child,u!==null&&(u.return=t);u!==null;){var i=u.dependencies;if(i!==null){o=u.child;for(var s=i.firstContext;s!==null;){if(s.context===r){if(u.tag===1){s=_t(-1,n&-n),s.tag=2;var p=u.updateQueue;if(p!==null){p=p.shared;var y=p.pending;y===null?s.next=s:(s.next=y.next,y.next=s),p.pending=s}}u.lanes|=n,s=u.alternate,s!==null&&(s.lanes|=n),Lu(u.return,n,t),i.lanes|=n;break}s=s.next}}else if(u.tag===10)o=u.type===t.type?null:u.child;else if(u.tag===18){if(o=u.return,o===null)throw Error(m(341));o.lanes|=n,i=o.alternate,i!==null&&(i.lanes|=n),Lu(o,n,t),o=u.sibling}else o=u.child;if(o!==null)o.return=u;else for(o=u;o!==null;){if(o===t){o=null;break}if(u=o.sibling,u!==null){u.return=o.return,o=u;break}o=o.return}u=o}xe(e,t,l.children,n),t=t.child}return t;case 9:return l=t.type,r=t.pendingProps.children,xn(t,n),l=Xe(l),r=r(l),t.flags|=1,xe(e,t,r,n),t.child;case 14:return r=t.type,l=lt(r,t.pendingProps),l=lt(r.type,l),Us(e,t,r,l,n);case 15:return As(e,t,t.type,t.pendingProps,n);case 17:return r=t.type,l=t.pendingProps,l=t.elementType===r?l:lt(r,l),al(e,t),t.tag=1,Re(r)?(e=!0,Qr(t)):e=!1,xn(t,n),Ts(t,r,l),Qu(t,r,l,n),Gu(null,t,r,!0,e,n);case 19:return Ys(e,t,n);case 22:return Vs(e,t,n)}throw Error(m(156,t.tag))};function ya(e,t){return Zo(e,t)}function kf(e,t,n,r){this.tag=e,this.key=n,this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null,this.index=0,this.ref=null,this.pendingProps=t,this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null,this.mode=r,this.subtreeFlags=this.flags=0,this.deletions=null,this.childLanes=this.lanes=0,this.alternate=null}function Je(e,t,n,r){return new kf(e,t,n,r)}function vo(e){return e=e.prototype,!(!e||!e.isReactComponent)}function Ef(e){if(typeof e=="function")return vo(e)?1:0;if(e!=null){if(e=e.$$typeof,e===at)return 11;if(e===ct)return 14}return 2}function $t(e,t){var n=e.alternate;return n===null?(n=Je(e.tag,t,e.key,e.mode),n.elementType=e.elementType,n.type=e.type,n.stateNode=e.stateNode,n.alternate=e,e.alternate=n):(n.pendingProps=t,n.type=e.type,n.flags=0,n.subtreeFlags=0,n.deletions=null),n.flags=e.flags&14680064,n.childLanes=e.childLanes,n.lanes=e.lanes,n.child=e.child,n.memoizedProps=e.memoizedProps,n.memoizedState=e.memoizedState,n.updateQueue=e.updateQueue,t=e.dependencies,n.dependencies=t===null?null:{lanes:t.lanes,firstContext:t.firstContext},n.sibling=e.sibling,n.index=e.index,n.ref=e.ref,n}function Sl(e,t,n,r,l,u){var o=2;if(r=e,typeof e=="function")vo(e)&&(o=1);else if(typeof e=="string")o=5;else e:switch(e){case ze:return un(n.children,l,u,t);case Qe:o=8,l|=8;break;case Pt:return e=Je(12,n,t,l|2),e.elementType=Pt,e.lanes=u,e;case Fe:return e=Je(13,n,t,l),e.elementType=Fe,e.lanes=u,e;case et:return e=Je(19,n,t,l),e.elementType=et,e.lanes=u,e;case re:return kl(n,l,u,t);default:if(typeof e=="object"&&e!==null)switch(e.$$typeof){case yt:o=10;break e;case Kt:o=9;break e;case at:o=11;break e;case ct:o=14;break e;case Le:o=16,r=null;break e}throw Error(m(130,e==null?e:typeof e,""))}return t=Je(o,n,t,l),t.elementType=e,t.type=r,t.lanes=u,t}function un(e,t,n,r){return e=Je(7,e,r,t),e.lanes=n,e}function kl(e,t,n,r){return e=Je(22,e,r,t),e.elementType=re,e.lanes=n,e.stateNode={isHidden:!1},e}function yo(e,t,n){return e=Je(6,e,null,t),e.lanes=n,e}function go(e,t,n){return t=Je(4,e.children!==null?e.children:[],e.key,t),t.lanes=n,t.stateNode={containerInfo:e.containerInfo,pendingChildren:null,implementation:e.implementation},t}function _f(e,t,n,r,l){this.tag=t,this.containerInfo=e,this.finishedWork=this.pingCache=this.current=this.pendingChildren=null,this.timeoutHandle=-1,this.callbackNode=this.pendingContext=this.context=null,this.callbackPriority=0,this.eventTimes=$l(0),this.expirationTimes=$l(-1),this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0,this.entanglements=$l(0),this.identifierPrefix=r,this.onRecoverableError=l,this.mutableSourceEagerHydrationData=null}function wo(e,t,n,r,l,u,o,i,s){return e=new _f(e,t,n,i,s),t===1?(t=1,u===!0&&(t|=8)):t=0,u=Je(3,null,null,t),e.current=u,u.stateNode=e,u.memoizedState={element:r,isDehydrated:n,cache:null,transitions:null,pendingSuspenseBoundaries:null},Ru(u),e}function Cf(e,t,n){var r=3<arguments.length&&arguments[3]!==void 0?arguments[3]:null;return{$$typeof:Ce,key:r==null?null:""+r,children:e,containerInfo:t,implementation:n}}function ga(e){if(!e)return It;e=e._reactInternals;e:{if(Yt(e)!==e||e.tag!==1)throw Error(m(170));var t=e;do{switch(t.tag){case 3:t=t.stateNode.context;break e;case 1:if(Re(t.type)){t=t.stateNode.__reactInternalMemoizedMergedChildContext;break e}}t=t.return}while(t!==null);throw Error(m(171))}if(e.tag===1){var n=e.type;if(Re(n))return Ki(e,n,t)}return t}function wa(e,t,n,r,l,u,o,i,s){return e=wo(n,r,!0,e,l,u,o,i,s),e.context=ga(null),n=e.current,r=Pe(),l=Ht(n),u=_t(r,l),u.callback=t??null,Ut(n,u,l),e.current.lanes=l,An(e,l,r),De(e,r),e}function El(e,t,n,r){var l=t.current,u=Pe(),o=Ht(l);return n=ga(n),t.context===null?t.context=n:t.pendingContext=n,t=_t(u,o),t.payload={element:e},r=r===void 0?null:r,r!==null&&(t.callback=r),e=Ut(l,t,o),e!==null&&(it(e,l,o,u),br(e,l,o)),o}function _l(e){if(e=e.current,!e.child)return null;switch(e.child.tag){case 5:return e.child.stateNode;default:return e.child.stateNode}}function Sa(e,t){if(e=e.memoizedState,e!==null&&e.dehydrated!==null){var n=e.retryLane;e.retryLane=n!==0&&n<t?n:t}}function So(e,t){Sa(e,t),(e=e.alternate)&&Sa(e,t)}function xf(){return null}var ka=typeof reportError=="function"?reportError:function(e){console.error(e)};function ko(e){this._internalRoot=e}Cl.prototype.render=ko.prototype.render=function(e){var t=this._internalRoot;if(t===null)throw Error(m(409));El(e,t,null,null)},Cl.prototype.unmount=ko.prototype.unmount=function(){var e=this._internalRoot;if(e!==null){this._internalRoot=null;var t=e.containerInfo;nn(function(){El(null,e,null,null)}),t[gt]=null}};function Cl(e){this._internalRoot=e}Cl.prototype.unstable_scheduleHydration=function(e){if(e){var t=li();e={blockedOn:null,target:e,priority:t};for(var n=0;n<Tt.length&&t!==0&&t<Tt[n].priority;n++);Tt.splice(n,0,e),n===0&&ii(e)}};function Eo(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11)}function xl(e){return!(!e||e.nodeType!==1&&e.nodeType!==9&&e.nodeType!==11&&(e.nodeType!==8||e.nodeValue!==" react-mount-point-unstable "))}function Ea(){}function Pf(e,t,n,r,l){if(l){if(typeof r=="function"){var u=r;r=function(){var p=_l(o);u.call(p)}}var o=wa(t,r,e,0,null,!1,!1,"",Ea);return e._reactRootContainer=o,e[gt]=o.current,bn(e.nodeType===8?e.parentNode:e),nn(),o}for(;l=e.lastChild;)e.removeChild(l);if(typeof r=="function"){var i=r;r=function(){var p=_l(s);i.call(p)}}var s=wo(e,0,!1,null,null,!1,!1,"",Ea);return e._reactRootContainer=s,e[gt]=s.current,bn(e.nodeType===8?e.parentNode:e),nn(function(){El(t,s,n,r)}),s}function Pl(e,t,n,r,l){var u=n._reactRootContainer;if(u){var o=u;if(typeof l=="function"){var i=l;l=function(){var s=_l(o);i.call(s)}}El(t,o,e,l)}else o=Pf(n,t,e,l,r);return _l(o)}ni=function(e){switch(e.tag){case 3:var t=e.stateNode;if(t.current.memoizedState.isDehydrated){var n=Un(t.pendingLanes);n!==0&&(Ql(t,n|1),De(t,ue()),(I&6)===0&&(Tn=ue()+500,jt()))}break;case 13:nn(function(){var r=Et(e,1);if(r!==null){var l=Pe();it(r,e,1,l)}}),So(e,1)}},Kl=function(e){if(e.tag===13){var t=Et(e,134217728);if(t!==null){var n=Pe();it(t,e,134217728,n)}So(e,134217728)}},ri=function(e){if(e.tag===13){var t=Ht(e),n=Et(e,t);if(n!==null){var r=Pe();it(n,e,t,r)}So(e,t)}},li=function(){return B},ui=function(e,t){var n=B;try{return B=e,t()}finally{B=n}},Ul=function(e,t,n){switch(t){case"input":if(Tl(e,n),t=n.name,n.type==="radio"&&t!=null){for(n=e;n.parentNode;)n=n.parentNode;for(n=n.querySelectorAll("input[name="+JSON.stringify(""+t)+'][type="radio"]'),t=0;t<n.length;t++){var r=n[t];if(r!==e&&r.form===e.form){var l=Wr(r);if(!l)throw Error(m(90));Lo(r),Tl(r,l)}}}break;case"textarea":Do(e,n);break;case"select":t=n.value,t!=null&&on(e,!!n.multiple,t,!1)}},Wo=po,$o=nn;var Nf={usingClientEntryPoint:!1,Events:[nr,yn,Wr,Bo,Ho,po]},vr={findFiberByHostInstance:Xt,bundleType:0,version:"18.3.1",rendererPackageName:"react-dom"},zf={bundleType:vr.bundleType,version:vr.version,rendererPackageName:vr.rendererPackageName,rendererConfig:vr.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:ge.ReactCurrentDispatcher,findHostInstanceByFiber:function(e){return e=Xo(e),e===null?null:e.stateNode},findFiberByHostInstance:vr.findFiberByHostInstance||xf,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.3.1-next-f1338f8080-20240426"};if(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__<"u"){var Nl=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!Nl.isDisabled&&Nl.supportsFiber)try{Cr=Nl.inject(zf),ft=Nl}catch{}}return Ie.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=Nf,Ie.createPortal=function(e,t){var n=2<arguments.length&&arguments[2]!==void 0?arguments[2]:null;if(!Eo(t))throw Error(m(200));return Cf(e,t,null,n)},Ie.createRoot=function(e,t){if(!Eo(e))throw Error(m(299));var n=!1,r="",l=ka;return t!=null&&(t.unstable_strictMode===!0&&(n=!0),t.identifierPrefix!==void 0&&(r=t.identifierPrefix),t.onRecoverableError!==void 0&&(l=t.onRecoverableError)),t=wo(e,1,!1,null,null,n,!1,r,l),e[gt]=t.current,bn(e.nodeType===8?e.parentNode:e),new ko(t)},Ie.findDOMNode=function(e){if(e==null)return null;if(e.nodeType===1)return e;var t=e._reactInternals;if(t===void 0)throw typeof e.render=="function"?Error(m(188)):(e=Object.keys(e).join(","),Error(m(268,e)));return e=Xo(t),e=e===null?null:e.stateNode,e},Ie.flushSync=function(e){return nn(e)},Ie.hydrate=function(e,t,n){if(!xl(t))throw Error(m(200));return Pl(null,e,t,!0,n)},Ie.hydrateRoot=function(e,t,n){if(!Eo(e))throw Error(m(405));var r=n!=null&&n.hydratedSources||null,l=!1,u="",o=ka;if(n!=null&&(n.unstable_strictMode===!0&&(l=!0),n.identifierPrefix!==void 0&&(u=n.identifierPrefix),n.onRecoverableError!==void 0&&(o=n.onRecoverableError)),t=wa(t,null,e,1,n??null,l,!1,u,o),e[gt]=t.current,bn(e),r)for(e=0;e<r.length;e++)n=r[e],l=n._getVersion,l=l(n._source),t.mutableSourceEagerHydrationData==null?t.mutableSourceEagerHydrationData=[n,l]:t.mutableSourceEagerHydrationData.push(n,l);return new Cl(t)},Ie.render=function(e,t,n){if(!xl(t))throw Error(m(200));return Pl(null,e,t,!1,n)},Ie.unmountComponentAtNode=function(e){if(!xl(e))throw Error(m(40));return e._reactRootContainer?(nn(function(){Pl(null,null,e,!1,function(){e._reactRootContainer=null,e[gt]=null})}),!0):!1},Ie.unstable_batchedUpdates=po,Ie.unstable_renderSubtreeIntoContainer=function(e,t,n,r){if(!xl(n))throw Error(m(200));if(e==null||e._reactInternals===void 0)throw Error(m(38));return Pl(e,t,n,!1,r)},Ie.version="18.3.1-next-f1338f8080-20240426",Ie}var Ta;function Uf(){if(Ta)return xo.exports;Ta=1;function T(){if(!(typeof __REACT_DEVTOOLS_GLOBAL_HOOK__>"u"||typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE!="function"))try{__REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(T)}catch(H){console.error(H)}}return T(),xo.exports=Ff(),xo.exports}var Ra;function Af(){if(Ra)return zl;Ra=1;var T=Uf();return zl.createRoot=T.createRoot,zl.hydrateRoot=T.hydrateRoot,zl}var Vf=Af();const Bf=Oa(Vf),Hf=()=>je.jsx("div",{children:je.jsx("h1",{children:"Home"})}),Wf=()=>je.jsx("div",{children:je.jsx("h1",{children:"User Info"})}),$f=()=>je.jsx("div",{children:je.jsx("h1",{children:"User Settings"})}),Qf=()=>je.jsxs(je.Fragment,{children:[je.jsx("h1",{children:"State-Management-Zustand-Welcome to Final Project-Special Garden Group!"}),je.jsx(Hf,{}),je.jsx(Wf,{}),je.jsx($f,{})]});Bf.createRoot(document.getElementById("root")).render(je.jsx(Df.StrictMode,{children:je.jsx(Qf,{})}));
diff --git a/frontend/dist/index.html b/frontend/dist/index.html
new file mode 100644
index 0000000000..fb7712e499
--- /dev/null
+++ b/frontend/dist/index.html
@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Special Garden Group App</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,200..1000;1,200..1000&display=swap" rel="stylesheet" />
+    <link href="/src/style.css" rel="stylesheet">
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+      tailwind.config = {
+        theme: {
+          extend: {
+            colors: {
+              clifford: '#da373d',
+            },
+            fontFamily: {
+              'sans': ['Nunito', 'sans-serif'],
+              'serif': ['Georgia', 'serif'],
+              'mono': ['Menlo', 'monospace'],
+            },
+          },
+        },
+      }
+    </script>
+  <script type="module" crossorigin src="/assets/index-DPwCqAy9.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BYbkx6M0.css">
+</head>
+<body class="h-dvh bg-orange-500 md:bg-indigo-500 lg:bg-cyan-500">
+    <div id="root"></div>
+</body>
+</html>
diff --git a/frontend/dist/vite.svg b/frontend/dist/vite.svg
new file mode 100644
index 0000000000..e7b8dfb1b2
--- /dev/null
+++ b/frontend/dist/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/frontend/index.html b/frontend/index.html
index 664410b5b9..2cb36d73be 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -1,13 +1,34 @@
 <!DOCTYPE html>
 <html lang="en">
-  <head>
+<head>
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Technigo React Vite Boiler Plate</title>
-  </head>
-  <body>
+    <title>Special Garden Group App</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,200..1000;1,200..1000&display=swap" rel="stylesheet" />
+    <link href="/src/style.css" rel="stylesheet">
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+      tailwind.config = {
+        theme: {
+          extend: {
+            colors: {
+              clifford: '#da373d',
+            },
+            fontFamily: {
+              'sans': ['Nunito', 'sans-serif'],
+              'serif': ['Georgia', 'serif'],
+              'mono': ['Menlo', 'monospace'],
+            },
+          },
+        },
+      }
+    </script>
+</head>
+<body class="h-dvh bg-orange-500 md:bg-indigo-500 lg:bg-cyan-500">
     <div id="root"></div>
     <script type="module" src="/src/main.jsx"></script>
-  </body>
+</body>
 </html>
diff --git a/frontend/package.json b/frontend/package.json
index 7b2747e949..3ed12c2f95 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "project-final-backend",
+  "name": "project-final-frontend",
   "description": "Client part of final project",
   "version": "1.0.0",
   "type": "module",
@@ -7,13 +7,15 @@
     "dev": "vite",
     "build": "vite build",
     "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "jest"
   },
   "dependencies": {
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
+    "@babel/preset-typescript": "^7.27.1",
     "@types/react": "^18.2.15",
     "@types/react-dom": "^18.2.7",
     "@vitejs/plugin-react": "^4.0.3",
diff --git a/frontend/src/.babelrc.json b/frontend/src/.babelrc.json
new file mode 100644
index 0000000000..92e4ea82d2
--- /dev/null
+++ b/frontend/src/.babelrc.json
@@ -0,0 +1,5 @@
+{
+    "presets": [...],
+    "plugins": [...]
+  }
+{ "extends": "../../.babelrc" }
\ No newline at end of file
diff --git a/frontend/src/.browserslistrc b/frontend/src/.browserslistrc
new file mode 100644
index 0000000000..bd9fb7727b
--- /dev/null
+++ b/frontend/src/.browserslistrc
@@ -0,0 +1,2 @@
+> 0.25%
+not dead
\ No newline at end of file
diff --git a/frontend/src/App.jsx b/frontend/src/App.jsx
index 0a24275e6e..aa48dc713d 100644
--- a/frontend/src/App.jsx
+++ b/frontend/src/App.jsx
@@ -1,8 +1,14 @@
+import Home from "./components/Home"
+import UserInfo from "./components/UserInfo"
+import UserSettings from "./components/UserSettings"
 export const App = () => {
 
   return (
-    <>
-      <h1>Welcome to Final Project!</h1>
-    </>
+    <main>
+      <h1>Welcome to the Special Garden Group!</h1>
+      <Home/>
+      <UserInfo/>
+      <UserSettings/>
+    </main>
   );
 };
diff --git a/frontend/src/a.js b/frontend/src/a.js
new file mode 100644
index 0000000000..9c730bc08b
--- /dev/null
+++ b/frontend/src/a.js
@@ -0,0 +1,4 @@
+var a = new Promise();
+import "core-js/modules/es.promise";
+var a = new Promise();
+var a = new Promise();
\ No newline at end of file
diff --git a/frontend/src/b.js b/frontend/src/b.js
new file mode 100644
index 0000000000..a8ebb50343
--- /dev/null
+++ b/frontend/src/b.js
@@ -0,0 +1,4 @@
+var b = new Map();
+import "core-js/modules/es.map";
+var b = new Map();
+var b = new Map();
\ No newline at end of file
diff --git a/frontend/src/babel-plugin.js b/frontend/src/babel-plugin.js
new file mode 100644
index 0000000000..7600b3557b
--- /dev/null
+++ b/frontend/src/babel-plugin.js
@@ -0,0 +1,28 @@
+// a naive plugin replace `a.b` to `a != null && a.b`
+module.exports = api => {
+    const targets = api.targets();
+    // The targets have native optional chaining support
+    // if `transform-optional-chaining` is _not_ required
+    const optionalChainingSupported = !isRequired(
+      "transform-optional-chaining",
+      targets
+    );
+    const visited = new WeakSet();
+    return {
+      visitor: {
+        MemberExpression(path) {
+          if (path.matchesPattern("a.b")) {
+            if (visited.has(path.node)) return;
+            visited.add(path.node);
+            if (optionalChainingSupported) {
+              // When optional chaining is supported,
+              // output `a?.b` instead of `a != null && a.b`
+              path.replaceWith(api.templates`a?.b`);
+            } else {
+              path.replaceWith(api.templates`a != null && ${path.node}`);
+            }
+          }
+        },
+      },
+    };
+  };
\ No newline at end of file
diff --git a/frontend/src/babel.config.json b/frontend/src/babel.config.json
new file mode 100644
index 0000000000..750ab7bce2
--- /dev/null
+++ b/frontend/src/babel.config.json
@@ -0,0 +1,399 @@
+
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "edge": "17",
+            "firefox": "60",
+            "chrome": "67",
+            "safari": "11.1"
+          },
+          "useBuiltIns": "usage",
+          "corejs": "3.6.5"
+        }
+      ]
+    ]
+  }
+const presets = [
+    [
+      "@babel/preset-env",
+      {
+        targets: {
+          edge: "17",
+          firefox: "60",
+          chrome: "67",
+          safari: "11.1",
+        },
+        useBuiltIns: "usage",
+        corejs: "3.6.4",
+      },
+    ],
+  ];
+  
+  module.exports = { presets };
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "edge": "17",
+            "firefox": "60",
+            "chrome": "67",
+            "safari": "11.1"
+          }
+        }
+      ]
+    ]
+  }
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "edge": "17",
+            "firefox": "60",
+            "chrome": "67",
+            "safari": "11.1"
+          },
+          "useBuiltIns": "usage"
+        }
+      ]
+    ]
+  }
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "edge": "17",
+            "firefox": "60",
+            "chrome": "67",
+            "safari": "11.1"
+          },
+          "useBuiltIns": "entry"
+        }
+      ]
+    ]
+  }
+{
+    "presets": [...],
+    "plugins": [...]
+  }
+module.exports = function (api) {
+    api.cache(true);
+  
+    const presets = [ ... ];
+    const plugins = [ ... ];
+  
+    return {
+      presets,
+      plugins
+    };
+  }
+babel.config.js
+module.exports = function (api) {
+  api.cache(true);
+
+  const presets = [ ... ];
+  const plugins = [ ... ];
+
+  if (process.env["ENV"] === "prod") {
+    plugins.push(...);
+  }
+
+  return {
+    presets,
+    plugins
+  };
+}
+module.exports = {
+    presets: ["@babel/env"], // "@babel/preset-env"
+    plugins: ["@babel/transform-arrow-functions"], // same as "@babel/plugin-transform-arrow-functions"
+  };
+{
+    "plugins": ["@babel/plugin-transform-runtime"]
+  }
+module.exports = function(api) {
+    return {};
+  };
+{
+    "targets": "> 0.25%, not dead"
+  }
+{
+    "targets": {
+      "chrome": "58",
+      "ie": "11"
+    }
+  }
+{
+    "presets": ["@babel/preset-env"]
+  }
+{
+    "targets": "defaults"
+  }
+{
+    // Resolve to "Chrome 61+, FF60+, Safari 11+"
+    "targets": {
+      "esmodules": "intersect", // Chrome 61+, FF 60+, Safari 10.1+
+      "browsers": "chrome 58, firefox 60, safari 11"
+    }
+  }
+{
+    "targets": "node 12" // not recommended
+  }
+{
+    "targets": "node 12.0"
+  }
+{
+    "targets": {
+      "deno": "1.9"
+    }
+  }
+{
+    "assumptions": {
+      "iterableIsArray": true
+    },
+    "presets": ["@babel/preset-env"]
+  }
+{
+    "plugins": ["babel-plugin-myPlugin", "@babel/plugin-transform-runtime"]
+  }
+{
+    "plugins": ["./node_modules/asdf/plugin"]
+  }
+{
+    "plugins": ["transform-decorators-legacy", "transform-class-properties"]
+  }
+{
+    "presets": ["@babel/preset-env", "@babel/preset-react"]
+  }
+{
+    "plugins": ["pluginA", ["pluginA"], ["pluginA", {}]]
+  }
+{
+    "plugins": [
+      [
+        "transform-async-to-module-method",
+        {
+          "module": "bluebird",
+          "method": "coroutine"
+        }
+      ]
+    ]
+  }
+{
+    "presets": [
+      [
+        "env",
+        {
+          "loose": true,
+          "modules": false
+        }
+      ]
+    ]
+  }
+{
+    "targets": ">0.5%",
+    "assumptions": {
+      "noDocumentAll": true,
+      "noClassCalls": true
+    },
+    "presets": ["@babel/preset-env"]
+  }
+{
+    "presets": ["babel-preset-myPreset", "@babel/preset-env"]
+  }
+{
+    "presets": ["./myProject/myPreset"]
+  }
+{
+    "presets": ["a", "b", "c"]
+  }
+{
+  "presets": [
+    "presetA", // bare string
+    ["presetA"], // wrapped in array
+    ["presetA", {}] // 2nd argument is an empty options object
+  ]
+}
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "loose": true,
+          "modules": false
+        }
+      ]
+    ]
+  }
+{
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "useBuiltIns": "entry",
+          "corejs": "3.22"
+        }
+      ]
+    ]
+  }
+{
+    "plugins": ["@babel/plugin-transform-explicit-resource-management"]
+  }
+{
+    "plugins": ["@babel/plugin-transform-duplicate-named-capturing-groups-regex"]
+  }
+{
+    "plugins": ["@babel/plugin-transform-json-modules"]
+  }
+{
+    "plugins": ["@babel/plugin-transform-regexp-modifiers"]
+  }
+{
+    "plugins": ["@babel/plugin-syntax-import-attributes"]
+  }
+  {
+    "plugins": ["@babel/plugin-bugfix-firefox-class-in-computed-class-key"]
+  }
+  {
+    "plugins": ["@babel/plugin-bugfix-safari-class-field-initializer-scope"]
+  }
+  {
+    "plugins": ["@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression"]
+  }
+  {
+    "plugins": ["@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining"]
+  }
+  {
+    "presets": ["@babel/preset-react"]
+  }
+  {
+    "presets": [
+      [
+        "@babel/preset-react",
+        {
+          "pragma": "dom", // default pragma is React.createElement (only in classic runtime)
+          "pragmaFrag": "DomFrag", // default is React.Fragment (only in classic runtime)
+          "throwIfNamespace": false, // defaults to true
+          "runtime": "classic" // defaults to classic
+          // "importSource": "custom-jsx-library" // defaults to react (only in automatic runtime)
+        }
+      ]
+    ]
+  }
+  babel.config.js
+module.exports = {
+  presets: [
+    [
+      "@babel/preset-react",
+      {
+        development: process.env.BABEL_ENV === "development",
+      },
+    ],
+  ],
+};
+{
+    "presets": ["@babel/preset-react"],
+    "env": {
+      "development": {
+        "presets": [["@babel/preset-react", { "development": true }]]
+      }
+    }
+  }
+  {
+    "plugins": ["@babel/plugin-transform-react-jsx"]
+  }
+  {
+    "plugins": [
+      [
+        "@babel/plugin-transform-react-jsx",
+        {
+          "throwIfNamespace": false, // defaults to true
+          "runtime": "automatic", // defaults to classic
+          "importSource": "custom-jsx-library" // defaults to react
+        }
+      ]
+    ]
+  }
+  {
+    "plugins": ["@babel/plugin-transform-react-jsx-development"]
+  }
+  {
+    "plugins": [
+      [
+        "@babel/plugin-transform-react-jsx-development",
+        {
+          "throwIfNamespace": false, // defaults to true
+          "runtime": "automatic", // defaults to classic
+          "importSource": "custom-jsx-library" // defaults to react
+        }
+      ]
+    ]
+  }
+  {
+    "presets": ["@babel/preset-typescript"]
+  }
+  {
+    "presets": ["@babel/preset-react"],
+    "overrides": [{
+      "test": "*.vue",
+      "presets": [
+        ["@babel/preset-typescript"], { "ignoreExtensions": true }
+      ]
+    }]
+  }
+  {
+    "presets": [
+      ["@babel/preset-typescript", {
+        "rewriteImportExtensions": true
+      }]
+    ]
+  }
+  {
+    "plugins": ["@babel/plugin-transform-typescript"]
+  }
+  {
+    "presets": ["@babel/preset-flow"]
+  }
+  {
+    "plugins": ["@babel/plugin-transform-flow-strip-types"]
+  }
+  {
+    "plugins": ["@babel/plugin-transform-runtime"]
+  }
+  {
+    "plugins": [
+      [
+        "@babel/plugin-transform-runtime",
+        {
+          "absoluteRuntime": false,
+          "corejs": false,
+          "helpers": true,
+          "regenerator": true,
+          "version": "7.0.0-beta.0"
+        }
+      ]
+    ]
+  }
+  {
+    "plugins": [
+      ["@babel/plugin-transform-runtime", {
+        "version": "^7.24.0"
+      }]
+    ]
+  }
+  module.exports = api => {
+    const targets = api.targets();
+    // The targets have native optional chaining support
+    // if `transform-optional-chaining` is _not_ required
+    const optionalChainingSupported = !isRequired(
+      "transform-optional-chaining",
+      targets
+    );
+  };
\ No newline at end of file
diff --git a/frontend/src/collect-await-expression.plugin.js b/frontend/src/collect-await-expression.plugin.js
new file mode 100644
index 0000000000..9c29cb8a12
--- /dev/null
+++ b/frontend/src/collect-await-expression.plugin.js
@@ -0,0 +1,25 @@
+module.exports = (api) => {
+    const { types: t, traverse } = api;
+    return {
+      name: "collect-await",
+      visitor: {
+        Function(path) {
+          if (path.node.async) {
+            const awaitExpressions = [];
+            // Get a list of related await expressions within the async function body
+            path.traverse(traverse.visitors.merge([
+              environmentVisitor,
+              {
+                AwaitExpression(path) {
+                  awaitExpressions.push(path);
+                },
+                ArrowFunctionExpression(path) {
+                  path.skip();
+                },
+              }
+            ]))
+          }
+        }
+      }
+    }
+  }
\ No newline at end of file
diff --git a/frontend/src/components/Home.jsx b/frontend/src/components/Home.jsx
new file mode 100644
index 0000000000..a93c3f4af4
--- /dev/null
+++ b/frontend/src/components/Home.jsx
@@ -0,0 +1,11 @@
+import React from 'react';
+
+const Home = () => {
+  return (
+    <div>
+      <h1>Home</h1>
+    </div>
+  );
+};
+
+export default Home;
diff --git a/frontend/src/components/UserInfo.jsx b/frontend/src/components/UserInfo.jsx
new file mode 100644
index 0000000000..43f1fb12ef
--- /dev/null
+++ b/frontend/src/components/UserInfo.jsx
@@ -0,0 +1,17 @@
+import React from 'react';
+import { useUserStore } from '../stores/userStore';
+
+const UserInfo = () => {
+  const { userName, age, incrementAge } = useUserStore();
+
+  return (
+    <section>
+      <h2>User Information</h2>
+      <p>Username: {userName}</p>
+      <p>Age: {age}</p>
+      <button onClick={incrementAge}>Increment Age</button>
+    </section>
+  );
+};
+
+export default UserInfo;
diff --git a/frontend/src/components/UserSettings.jsx b/frontend/src/components/UserSettings.jsx
new file mode 100644
index 0000000000..1de6846122
--- /dev/null
+++ b/frontend/src/components/UserSettings.jsx
@@ -0,0 +1,32 @@
+import React from 'react';
+import { useUserStore } from '../stores/userStore';
+
+const UserSettings = () => {
+  const { userName, isLoggedIn, setUserName, toggleLogin } = useUserStore();
+
+  const handleUserNameChange = (event) => {
+    setUserName(event.target.value);
+  };
+
+  return (
+    <section>
+      <h2>User Settings</h2>
+      <form>
+        <div>
+          <label htmlFor="username">Username:</label>
+          <input
+            type="text"
+            id="username"
+            value={userName}
+            onChange={handleUserNameChange}
+          />
+        </div>
+        <button type="button" onClick={toggleLogin}>
+          {isLoggedIn ? 'Log Out' : 'Log In'}
+        </button>
+      </form>
+    </section>
+  );
+};
+
+export default UserSettings;
diff --git a/frontend/src/eslint.config.js b/frontend/src/eslint.config.js
new file mode 100644
index 0000000000..6a10b2c59b
--- /dev/null
+++ b/frontend/src/eslint.config.js
@@ -0,0 +1,120 @@
+import babelParser from "@babel/eslint-parser";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.js", "**/*.cjs", "**/*.mjs"],
+    languageOptions: {
+      parser: babelParser,
+    },
+  },
+]);
+import babelParser from "@babel/eslint-parser";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.js", "**/*.cjs", "**/*.mjs"],
+    languageOptions: {
+      parser: babelParser,
+      parserOptions: {
+        requireConfigFile: false,
+        babelOptions: {
+          babelrc: false,
+          configFile: false,
+          // your babel options
+          presets: ["@babel/preset-env"],
+        },
+      },
+    },
+  },
+]);
+import babelParser from "@babel/eslint-parser";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.js", "**/*.cjs", "**/*.mjs"],
+    languageOptions: {
+      parser: babelParser,
+      parserOptions: {
+        requireConfigFile: false,
+        babelOptions: {
+          babelrc: false,
+          configFile: "path/to/babel.config.js",
+        },
+      },
+    },
+  },
+]);
+import babelParserExperimentalWorker from "@babel/eslint-parser/experimental-worker";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.js", "**/*.cjs", "**/*.mjs"],
+    languageOptions: {
+      parser: babelParserExperimentalWorker,
+      parserOptions: {
+        requireConfigFile: false,
+        babelOptions: {
+          babelrc: false,
+          configFile: "path/to/babel.config.mjs",
+        },
+      },
+    },
+  },
+]);
+import babelParser from "@babel/eslint-parser";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["files/transformed/by/babel/*.js"],
+    languageOptions: {
+      parser: babelParser,
+    },
+  },
+]);
+import babelParser from "@babel/eslint-parser";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.js", "**/*.cjs", "**/*.mjs"],
+    languageOptions: {
+      parser: babelParser,
+      parserOptions: {
+        babelOptions: {
+          rootMode: "upward",
+        },
+      },
+    },
+  },
+]);
+import babelParser from "@babel/eslint-parser";
+import babelPlugin from "@babel/eslint-plugin";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.js", "**/*.cjs", "**/*.mjs"],
+    languageOptions: {
+      parser: babelParser,
+    },
+    plugins: {
+      babel: babelPlugin
+    },
+    rules: {
+      "new-cap": "off",
+      "no-undef": "off",
+      "no-unused-expressions": "off",
+      "object-curly-spacing": "off",
+
+      "babel/new-cap": "error",
+      "babel/no-undef": "error",
+      "babel/no-unused-expressions": "error",
+      "babel/object-curly-spacing": "error"
+    }
+  },
+]);
\ No newline at end of file
diff --git a/frontend/src/index.css b/frontend/src/index.css
index e69de29bb2..776bb70de8 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -0,0 +1,14 @@
+import '@fontsource/roboto/300.css';
+import '@fontsource/roboto/400.css';
+import '@fontsource/roboto/500.css';
+import '@fontsource/roboto/700.css';
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+<link
+  rel="stylesheet"
+  href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap"
+/>
+<link
+  rel="stylesheet"
+  href="https://fonts.googleapis.com/icon?family=Material+Icons"
+/>
\ No newline at end of file
diff --git a/frontend/src/input.js b/frontend/src/input.js
new file mode 100644
index 0000000000..984bedcf74
--- /dev/null
+++ b/frontend/src/input.js
@@ -0,0 +1,51 @@
+using handlerSync = openSync();
+await using handlerAsync = await openAsync();
+import data from "./data.json" with { type: "json" };
+// matches Aa and aa
+const regex = /(?i:a)a/
+// matches aa, a\naa, etc. but not a\na
+const regex = /(?m:^a)a/
+// matches \na and aa, but not \n\n
+const regex = /(?s:.)./
+// replace this expression to `globalThis.foo = "top"`
+this.foo = "top";
+
+() => {
+  // replace
+  this.foo = "top"
+}
+function Foo() {
+    // don't replace
+    this.foo = "inner";
+  }
+  
+  class Bar {
+    method() {
+      // don't replace
+      this.foo = "inner";
+    }
+  }
+  class Bar {
+    // replace
+    [this.foo = "outer"]() {
+      // don't replace
+      this.foo = "inner";
+    }
+  }
+  {
+    "type": "ClassMethod", // skipped
+    "key": { "type": "AssignmentExpression" }, // [this.foo = "outer"]
+    "body": { "type": "BlockStatement" }, // { this.foo = "inner"; }
+    "params": [], // should visit too if there are any
+    "computed": true
+  }
+  class Bar {
+    // replace
+    [this.foo = "outer"] =
+    // don't replace
+    this.foo
+  }
+  class Foo {
+    // replaced to `@globalThis.log`
+    @(this.log) foo = 1;
+  }
\ No newline at end of file
diff --git a/frontend/src/input.jsx b/frontend/src/input.jsx
new file mode 100644
index 0000000000..4e8d2ed281
--- /dev/null
+++ b/frontend/src/input.jsx
@@ -0,0 +1,6 @@
+const profile = (
+    <div>
+      <img src="avatar.png" className="profile" />
+      <h3>{[user.firstName, user.lastName].join(" ")}</h3>
+    </div>
+  );
\ No newline at end of file
diff --git a/frontend/src/launch.json b/frontend/src/launch.json
new file mode 100644
index 0000000000..2057022402
--- /dev/null
+++ b/frontend/src/launch.json
@@ -0,0 +1,68 @@
+{
+  "weatherApiUrl": "https://pro.openweathermap.org/data/2.5/forecast/climate?lat={lat}&lon={lon}&appid={API key}",
+  "weatherApiUrlByCity": "https://pro.openweathermap.org/data/2.5/forecast/climate?q={city name},{country code}&appid={API key}",
+  "weatherApiUrlLondon": "https://pro.openweathermap.org/data/2.5/forecast/climate?q=London&appid={API key}",
+  "weatherApiUrlByCityId": "https://pro.openweathermap.org/data/2.5/forecast/climate?id={city ID}&appid={API key}",
+  "weatherApiUrlByCityIdExample": "https://pro.openweathermap.org/data/2.5/forecast/climate?id=2643743&appid={API key}",
+  "weatherApiUrlByZip": "https://pro.openweathermap.org/data/2.5/forecast/climate?zip={zip code},{country code}&appid={API key}",
+  "weatherApiUrlByZipExample": "https://pro.openweathermap.org/data/2.5/forecast/climate?zip=94040,us&appid={API key}",
+  "weatherApiUrlLondonCnt3": "https://api.openweathermap.org/data/2.5/forecast/climate?q=London&cnt=3",
+  "weatherApiUrlLondonExample": "https://api.openweathermap.org/data/2.5/forecast/climate?q=London",
+  "weatherApiUrlLondonMetric": "https://api.openweathermap.org/data/2.5/forecast/climate?q=London&units=metric",
+  "api.openweathermap.org/data/2.5/forecast/climate?q=London&units=imperial": "",
+  "weatherApiUrlByCityLang": "http://api.openweathermap.org/data/2.5/forecast/climate?id=524901&lang={lang}",
+  "weatherApiUrlByCityLangZhCn": "http://api.openweathermap.org/data/2.5/forecast/climate?id=524901&lang=zh_cn",
+  "api.openweathermap.org/data/2.5/forecast/climate?q=London,uk&callback=test": "",
+
+  "response": {
+    "cod": "200",
+    "city": {
+      "id": 2643743,
+      "name": "London",
+      "coord": {
+        "lon": -0.1277,
+        "lat": 51.5073
+      },
+      "country": "GB"
+    },
+    "message": 0.353472054,
+    "list": [
+      {
+        "dt": 1594382400,
+        "sunrise": 1594353335,
+        "sunset": 1594412149,
+        "temp": {
+          "day": 286.98,
+          "min": 285.22,
+          "max": 287.97,
+          "night": 285.22,
+          "eve": 287.97,
+          "morn": 287.29
+        },
+        "feels_like": {
+          "day": 282.61,
+          "night": 283.19,
+          "eve": 284.98,
+          "morn": 282.68
+        },
+        "pressure": 1016,
+        "humidity": 84,
+        "weather": [
+          {
+            "id": 500,
+            "main": "Rain",
+            "description": "light rain",
+            "icon": "10d"
+          }
+        ],
+        "speed": 6.78,
+        "deg": 320,
+        "clouds": 81,
+        "rain": 1.96
+      }
+    ]
+  }
+}
+ 
+                     
+                  
\ No newline at end of file
diff --git a/frontend/src/main.jsx b/frontend/src/main.jsx
index 51294f3998..eac7edd957 100644
--- a/frontend/src/main.jsx
+++ b/frontend/src/main.jsx
@@ -1,10 +1,10 @@
-import React from "react";
-import ReactDOM from "react-dom/client";
-import { App } from "./App.jsx";
-import "./index.css";
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import { App } from './App.jsx'
+import './index.css'
 
-ReactDOM.createRoot(document.getElementById("root")).render(
+ReactDOM.createRoot(document.getElementById('root')).render(
   <React.StrictMode>
     <App />
-  </React.StrictMode>
-);
+  </React.StrictMode>,
+)
diff --git a/frontend/src/misc.ts b/frontend/src/misc.ts
new file mode 100644
index 0000000000..8a080b0410
--- /dev/null
+++ b/frontend/src/misc.ts
@@ -0,0 +1,11 @@
+const findBareSupers = traverse.visitors.merge<NodePath<t.CallExpression>[]>([
+    {
+      Super(path) {
+        const { node, parentPath } = path;
+        if (parentPath.isCallExpression({ callee: node })) {
+          this.push(parentPath);
+        }
+      },
+    },
+    environmentVisitor,
+  ]);
\ No newline at end of file
diff --git a/frontend/src/my-babel-plugin.js b/frontend/src/my-babel-plugin.js
new file mode 100644
index 0000000000..c998d14a4a
--- /dev/null
+++ b/frontend/src/my-babel-plugin.js
@@ -0,0 +1,38 @@
+{
+    "chrome": "60",
+    "opera": "47",
+    "edge": "79",
+    "firefox": "55",
+    "safari": "11.1",
+    "node": "8.3",
+    "deno": "1",
+    "ios": "11.3",
+    "samsung": "8",
+    "opera_mobile": "44",
+    "electron": "2.0"
+}
+import { isRequired } from "@babel/helper-compilation-targets";
+
+module.exports = api => {
+  // Check if the targets have native object-rest-spread support
+  const objectRestSpreadSupported = !isRequired(
+    "transform-object-rest-spread",
+    api.targets()
+  );
+};
+import {
+    isIdentifierName,
+    isIdentifierStart,
+    isIdentifierChar,
+    isReservedWord,
+    isStrictBindOnlyReservedWord,
+    isStrictBindReservedWord,
+    isStrictReservedWord,
+    isKeyword,
+  } from "@babel/helper-validator-identifier";
+  import environmentVisitor, {
+    requeueComputedKeyAndDecorators
+  } from "@babel/helper-environment-visitor";
+  if (path.isMethod()) {
+    requeueComputedKeyAndDecorators(path)
+  }
\ No newline at end of file
diff --git a/frontend/src/output.js b/frontend/src/output.js
new file mode 100644
index 0000000000..82dade23d4
--- /dev/null
+++ b/frontend/src/output.js
@@ -0,0 +1,28 @@
+try {
+    var _usingCtx = babelHelpers.usingCtx();
+    var handlerSync = _usingCtx.u(openSync());
+    var handlerAsync = _usingCtx.a(await openAsync());
+  } catch (_) {
+    _usingCtx.e = _;
+  } finally {
+    await _usingCtx.d();
+  }
+const data = await fetch(import.meta.resolve("./data.json")).then(r => r.json());
+const regex = /(?:[Aa])a/
+const regex = /(?:(?:^|(?<=[\n\r\u2028\u2029]))a)a/
+const regex = /(?:[\s\S])./;
+import { jsxDEV as _jsxDEV } from "react/jsx-dev-runtime";
+
+const _jsxFileName = "input.jsx";
+const profile = _jsxDEV("div", {
+  children: [
+    _jsxDEV("img", {
+      src: "avatar.png",
+      className: "profile",
+    }, undefined, false, { fileName: _jsxFileName, lineNumber: 3, columnNumber: 5 }, this),
+    _jsxDEV("h3", {
+      children: [user.firstName, user.lastName].join(" "),
+    }, undefined, false, { fileName: _jsxFileName, lineNumber: 4, columnNumber: 5 }, this),
+  ]},
+  undefined, false, { fileName: _jsxFileName, lineNumber: 2, columnNumber: 3 }, this
+);
\ No newline at end of file
diff --git a/frontend/src/replace-top-level-this-plugin.js b/frontend/src/replace-top-level-this-plugin.js
new file mode 100644
index 0000000000..9cbecd06a8
--- /dev/null
+++ b/frontend/src/replace-top-level-this-plugin.js
@@ -0,0 +1,81 @@
+module.exports = (api) => {
+    const { types: t } = api;
+    return {
+      name: "replace-top-level-this",
+      visitor: {
+        ThisExpression(path) {
+          path.replaceWith(t.identifier("globalThis"));
+        }
+      }
+    }
+  }
+  replace-top-level-this-plugin.js
+module.exports = (api) => {
+  const { types: t } = api;
+  return {
+    name: "replace-top-level-this",
+    visitor: {
+      ThisExpression(path) {
+        path.replaceWith(t.identifier("globalThis"));
+      }
+      "FunctionDeclaration|FunctionExpression|ObjectMethod|ClassMethod|ClassPrivateMethod"(path) {
+        path.skip();
+      }
+    }
+  }
+}
+module.exports = (api) => {
+    const { types: t } = api;
+    return {
+      name: "replace-top-level-this",
+      visitor: {
+        ThisExpression(path) {
+          path.replaceWith(t.identifier("globalThis"));
+        }
+        FunctionParent(path) {
+          if (!path.isArrowFunctionExpression()) {
+            path.skip();
+          }
+        }
+      }
+    }
+  }
+  import {
+    requeueComputedKeyAndDecorators
+  } from "@babel/helper-environment-visitor";
+  
+  module.exports = (api) => {
+    const { types: t } = api;
+    return {
+      name: "replace-top-level-this",
+      visitor: {
+        ThisExpression(path) {
+          path.replaceWith(t.identifier("globalThis"));
+        }
+        FunctionParent(path) {
+          if (!path.isArrowFunctionExpression()) {
+            path.skip();
+          }
+          if (path.isMethod()) {
+            requeueComputedKeyAndDecorators(path);
+          }
+        }
+      }
+    }
+  }
+  import environmentVisitor from "@babel/helper-environment-visitor";
+
+module.exports = (api) => {
+  const { types: t, traverse } = api;
+  return {
+    name: "replace-top-level-this",
+    visitor: traverse.visitors.merge([
+      {
+        ThisExpression(path) {
+          path.replaceWith(t.identifier("globalThis"));
+        }
+      },
+      environmentVisitor
+    ]);
+  }
+}
\ No newline at end of file
diff --git a/frontend/src/stores/appContentStore.jsx b/frontend/src/stores/appContentStore.jsx
new file mode 100644
index 0000000000..f39765e872
--- /dev/null
+++ b/frontend/src/stores/appContentStore.jsx
@@ -0,0 +1,7 @@
+import {create} from "zustand"
+
+export const useAppContentStore = create(() => ({
+  appContent:{
+      heading: "Welcome to the Special Garden Group!"
+  }
+}));
diff --git a/frontend/src/stores/userStore.jsx b/frontend/src/stores/userStore.jsx
new file mode 100644
index 0000000000..0c56e5b9d5
--- /dev/null
+++ b/frontend/src/stores/userStore.jsx
@@ -0,0 +1,10 @@
+import { create } from "zustand";
+
+export const useUserStore = create((set) => ({
+  isLoggedIn: false,
+  age: 25,
+  userName: "John Doe",
+  toggleLogin: () => set((state) => ({ isLoggedIn: !state.isLoggedIn })),
+  incrementAge: () => set((state) => ({ age: state.age + 1 })),
+  setUserName: (newUserName) => set({ userName: newUserName }),
+}));
diff --git a/frontend/src/tests/cleanup.sh b/frontend/src/tests/cleanup.sh
new file mode 100644
index 0000000000..f7ac5fc3f3
--- /dev/null
+++ b/frontend/src/tests/cleanup.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+rm -f *.{ER,OU}
+rm -f hopper_w_*_*.pbs
\ No newline at end of file
diff --git a/frontend/src/tests/client.py b/frontend/src/tests/client.py
new file mode 100644
index 0000000000..b1a75d47a5
--- /dev/null
+++ b/frontend/src/tests/client.py
@@ -0,0 +1,29 @@
+import socket
+
+
+
+# create an ipv4 (AF_INET) socket object using the tcp protocol (SOCK_STREAM)
+client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+# connect the client
+# client.connect((target, port))
+client.connect(('127.0.0.1', 1233))
+response = client.recv(2048)
+# Input UserName
+name = input(response.decode())	
+client.send(str.encode(name))
+response = client.recv(2048)
+# Input Password
+password = input(response.decode())	
+client.send(str.encode(password))
+''' Response : Status of Connection :
+	1 : Registeration successful 
+	2 : Connection Successful
+	3 : Login Failed
+'''
+# Receive response 
+response = client.recv(2048)
+response = response.decode()
+
+print(response)
+client.close()
\ No newline at end of file
diff --git a/frontend/src/tests/hopper_w.pbs b/frontend/src/tests/hopper_w.pbs
new file mode 100644
index 0000000000..25867caa94
--- /dev/null
+++ b/frontend/src/tests/hopper_w.pbs
@@ -0,0 +1,23 @@
+#!/bin/bash
+#PBS -q debug
+#PBS -N mongostress
+#PBS -l mppwidth=48
+#PBS -l walltime=00:10:00
+#PBS -o $PBS_O_WORKDIR/job.out
+#PBS -e $PBS_O_WORKDIR/job.error
+
+module load python
+
+export CRAY_ROOTFS=DSL
+
+cd $PBS_O_WORKDIR
+
+## Pick a time 3 minutes into the future
+#future=`python -c "import time; print(int(time.time()) + 180)"`
+# or, for debugging, 10 seconds into the future
+future=`python -c "import time; print(int(time.time()) + 10)"`
+
+docs=10
+clear_flag="-c"
+
+aprun -a xt -n 48 ./w.py $clear_flag --server=128.55.57.13 --ndocs=$docs --when=$future
\ No newline at end of file
diff --git a/frontend/src/tests/hopper_w.stache b/frontend/src/tests/hopper_w.stache
new file mode 100644
index 0000000000..5a450fdf93
--- /dev/null
+++ b/frontend/src/tests/hopper_w.stache
@@ -0,0 +1,26 @@
+#!/bin/bash
+#PBS -q debug
+#PBS -N mongostress_{{run}}
+#PBS -l mppwidth={{procs}}
+#PBS -l walltime=00:30:00
+
+module load python
+
+export CRAY_ROOTFS=DSL
+
+cd $PBS_O_WORKDIR
+
+## Pick a time 3 minutes into the future
+future=`python -c "import time; print(int(time.time()) + 180)"`
+# or, for debugging, 10 seconds into the future
+#future=`python -c "import time; print(int(time.time()) + 10)"`
+
+{{#clear}}
+clear_flag="-c"
+{{/clear}}
+{{^clear}}
+clear_flag=""
+{{/clear}}
+
+aprun -a xt -n {{procs}} ./w.py $clear_flag --server={{server}} --ndocs={{docs}} --when=$future \
+      -R hopper_{{run}}
\ No newline at end of file
diff --git a/frontend/src/tests/jest.config.js b/frontend/src/tests/jest.config.js
new file mode 100644
index 0000000000..37dc7e93e2
--- /dev/null
+++ b/frontend/src/tests/jest.config.js
@@ -0,0 +1,3 @@
+"transform": {
+  "^.+\\.jsx?$": "./path/to/wrapper.js"
+},
\ No newline at end of file
diff --git a/frontend/src/tests/jest.config.ts b/frontend/src/tests/jest.config.ts
new file mode 100644
index 0000000000..71a89149f9
--- /dev/null
+++ b/frontend/src/tests/jest.config.ts
@@ -0,0 +1,201 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+import type {Config} from 'jest';
+
+const config: Config = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/tmp/jest_rs",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: true,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: "coverage",
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: "v8",
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "mts",
+  //   "cts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.?([mc])[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).?([mc])[jt]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  // testPathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  // transform: undefined,
+
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};
+
+export default config;
diff --git a/frontend/src/tests/jsonify.py b/frontend/src/tests/jsonify.py
new file mode 100644
index 0000000000..193f13287c
--- /dev/null
+++ b/frontend/src/tests/jsonify.py
@@ -0,0 +1,40 @@
+from flask import Flask, request, jsonify
+import re
+
+app= Flask(__name__)
+def validate_password(password):
+    """
+    Validate the strength of a password
+    A strong password must contain at least:
+    - 8 characters
+    - 1 uppercase letter
+    - 1 lowercase letter
+    - 1 digit
+    - 1 special character
+    """
+    if (len(password) < 8 or
+        not re.search(r"[A-Z]", password) or
+        not re.search(r"[a-z]", password) or
+        not re.search(r"[0-9]", password) or
+        not re.search(r"[!@#$%^&*(),.?\":{}|<>]", password)):
+        return False
+    return True
+
+@app.route('/signup', methods=['POST'])
+def sinup():
+    data = request.get_json()
+    
+    username = data.get('username')
+    password = data.get('password')
+    
+    if not username or not password:
+        return jsonify({"error": "Username and password are required"}), 400
+    if not validate_password(password):
+        return jsonify({"error": "Password is not strong enough"}), 400
+    # Here you would normally save the user to your database
+    # For simplicity we will just return a succesful message
+
+    return jsonify({"message": "User signed up succesfully"}), 200
+
+if __name__ == '__main__':
+    app.run(debug=True)
\ No newline at end of file
diff --git a/frontend/src/tests/mpi_run.pbs b/frontend/src/tests/mpi_run.pbs
new file mode 100644
index 0000000000..c8e4c18097
--- /dev/null
+++ b/frontend/src/tests/mpi_run.pbs
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+#PBS -q debug
+#PBS -N test_mpi4py
+#PBS -l mppwidth=216
+## Number of processes on each node
+##PBS -l mppnppn=1
+#PBS -l walltime=00:10:00
+#PBS -o $PBS_O_WORKDIR/job.out
+#PBS -e $PBS_O_WORKDIR/job.error
+
+module load python/2.7.1
+
+cd $PBS_O_WORKDIR
+# run 216 tasks
+aprun -n 216 python ./mpi_stress_test.py --host='X.X.X.X' --port=27018 --nclients=216
+# run 4 tasks with 1 task (MPI process) per node
+#aprun -n 4 -N 1 python ./test_01.py
\ No newline at end of file
diff --git a/frontend/src/tests/mpi_stress_test.py b/frontend/src/tests/mpi_stress_test.py
new file mode 100644
index 0000000000..699e8ddc84
--- /dev/null
+++ b/frontend/src/tests/mpi_stress_test.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+" Mongo Stress Test using MPI"
+import sys
+import time
+import datetime
+import logging
+import socket
+from optparse import OptionParser
+
+import pymongo
+from mpi4py import MPI
+
+DB_NAME = 'db_flex'
+COLLECTION_NAME = 'flexers'
+
+log = logging.getLogger(__name__)
+
+comm = MPI.COMM_WORLD
+rank = comm.Get_rank()
+size = comm.Get_size()
+
+log.info("MPI size {n}".format(n=size))
+
+
+def mongo_inserter(cid, ndocs, host, port):
+    """
+    cid (int) Client id
+    ndoc (int) Number of docs to import
+    host (str) mongo hostname
+    port (int) mongo port to connect to
+    """
+    s = socket.getfqdn()
+    log.info("start client {i} on node {n} connecting to {h}:{p} at {d}".format(i=cid, n=s, h=host, p=port, d=datetime.datetime.now()))
+    conn = pymongo.Connection(host, port)
+    db = conn[DB_NAME]
+    collection = db[COLLECTION_NAME]
+    t0 = time.time()
+    for n in range(ndocs):
+        message = "updating mongodb with value {v} from client {i}".format(v=n, i=cid)
+        log.info(message)
+        doc = {'doc_id': n, 'created_at': datetime.datetime.now(), 'message': message, 'client_id': cid}
+        collection.insert(doc)
+
+    tf = time.time()
+    dt = tf - t0
+    ops = ndocs / dt
+    m = "Client {i} on node {s} took {dt} with op/s {o:2f}".format(i=cid, s=s, dt=dt, o=ops)
+    print(m)
+    log.info(m)
+    log.info("Client {i} completed".format(i=cid))
+
+
+def main(nclients, ndocs, host, port):
+    sname = socket.getfqdn()
+    if rank == 0:
+        #data could be the db config params
+        #comm.send(config, tag=11)
+        print("starting up rank {r} on {s}".format(r=rank, s=sname))
+    else:
+        print("starting up rank {r} on {s}".format(r=rank, s=sname))
+        #data = comm.recv(source=0, tag=11)
+        mongo_inserter(rank, ndocs, host, port)
+        sys.exit(0)
+    return 0
+
+
+if __name__ == '__main__':
+    parser = OptionParser()
+    # nclients isn't necessary now. MPI determines the number from PBS script
+    parser.add_option('-n', '--nclients', type='int', dest='nclients', help='Number of clients to start up')
+    parser.add_option('-d', '--ndocs', dest='ndocs', type='int', default=1000, help='number of docs to import per client into the db')
+    parser.add_option('-H', '--host', dest='host', help='db hostname')
+    parser.add_option('-p', '--port', dest='port', type='int', default=27017, help='db port to connect to')
+    (options, args) = parser.parse_args()
+    # nclients, host must be given!
+    if options.nclients is not None and options.host is not None:
+        sys.exit(main(options.nclients, options.ndocs, options.host, options.port))
+    else:
+        print("Provide --nclients and --host options")
+        sys.exit(0)
\ No newline at end of file
diff --git a/frontend/src/tests/pbstache.py b/frontend/src/tests/pbstache.py
new file mode 100644
index 0000000000..41dec0cea0
--- /dev/null
+++ b/frontend/src/tests/pbstache.py
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+"""Generate PBS run scripts.
+
+Usage: pbstache.py <input>.stache from:to:by
+  Output is <input>_<procs>_<docs>.pbs,
+  where <procs> is number of clients and <docs>
+  is the total number of documents.
+"""
+import pystache
+import sys
+
+def usage():
+    print(__doc__)
+    sys.exit(1)
+
+if len(sys.argv) < 2 or sys.argv[1] == "-h" or len(sys.argv) != 3:
+    usage()
+
+infile = sys.argv[1]
+if not infile.endswith(".stache"):
+    print("Input file format is <name>.stache")
+    usage()
+try:
+    data = file(infile).read()
+except IOError, err:
+    print("Cannot read file {f}".format(f=infile))
+    usage()
+base_infile = infile[:-7]
+
+try:
+    p_from, p_to, p_step = map(int, sys.argv[2].split(':'))
+except ValueError:
+    print("Client count range must be 3 numbers a:b:c")
+    usage()
+
+total_docs = 1000000
+v = {'clear':True, 'server':"128.55.57.13"}
+
+for procs in xrange(p_from, p_to+1, p_step):
+    v['docs'] = total_docs / procs
+    v['procs'] = procs
+    v['run'] = "{p:d}_{t:d}".format(p=procs, t=total_docs)
+    script = pystache.render(data, v)
+    ofile = "{f}_{run}.pbs".format(f=base_infile, **v)
+    file(ofile, "w").write(script)
+    print("wrote {f}".format(f=ofile))
\ No newline at end of file
diff --git a/frontend/src/tests/server.py b/frontend/src/tests/server.py
new file mode 100644
index 0000000000..0582240838
--- /dev/null
+++ b/frontend/src/tests/server.py
@@ -0,0 +1,63 @@
+import socket
+import os
+import threading
+import hashlib
+
+
+# Create Socket (TCP) Connection
+ServerSocket = socket.socket(family = socket.AF_INET, type = socket.SOCK_STREAM) 
+host = '127.0.0.1'
+port = 1233
+ThreadCount = 0
+try:
+    ServerSocket.bind((host, port))
+except socket.error as e:
+    print(str(e))
+
+print('Waitiing for a Connection..')
+ServerSocket.listen(5)
+HashTable = {}
+
+# Function : For each client 
+def threaded_client(connection):
+    connection.send(str.encode('ENTER USERNAME : ')) # Request Username
+    name = connection.recv(2048)
+    connection.send(str.encode('ENTER PASSWORD : ')) # Request Password
+    password = connection.recv(2048)
+    password = password.decode()
+    name = name.decode()
+    password=hashlib.sha256(str.encode(password)).hexdigest() # Password hash using SHA256
+# REGISTERATION PHASE   
+# If new user,  regiter in Hashtable Dictionary  
+    if name not in HashTable:
+        HashTable[name]=password
+        connection.send(str.encode('Registeration Successful')) 
+        print('Registered : ',name)
+        print("{:<8} {:<20}".format('USER','PASSWORD'))
+        for k, v in HashTable.items():
+            label, num = k,v
+            print("{:<8} {:<20}".format(label, num))
+        print("-------------------------------------------")
+        
+    else:
+# If already existing user, check if the entered password is correct
+        if(HashTable[name] == password):
+            connection.send(str.encode('Connection Successful')) # Response Code for Connected Client 
+            print('Connected : ',name)
+        else:
+            connection.send(str.encode('Login Failed')) # Response code for login failed
+            print('Connection denied : ',name)
+    while True:
+        break
+    connection.close()
+
+while True:
+    Client, address = ServerSocket.accept()
+    client_handler = threading.Thread(
+        target=threaded_client,
+        args=(Client,)  
+    )
+    client_handler.start()
+    ThreadCount += 1
+    print('Connection Request: ' + str(ThreadCount))
+ServerSocket.close()
\ No newline at end of file
diff --git a/frontend/src/tests/sharded-mongo b/frontend/src/tests/sharded-mongo
new file mode 100644
index 0000000000..2385fd6ac3
--- /dev/null
+++ b/frontend/src/tests/sharded-mongo
@@ -0,0 +1,66 @@
+#!/bin/sh
+
+mode=$1
+shift
+
+function usage() {
+    e=$1
+    if [ "x$e" != "x" ]; then
+        printf "** $e\n\n"
+    fi
+    p=$(basename $0)
+    cat - <<EOT
+usage: $p MODE
+
+mode   action
+----   -------
+s      run servers
+c      configure
+k      kill mongod/mongos processes
+EOT
+}
+
+case "$mode" in
+    s*)
+        printf "== Start servers ==\n"
+        mongod --shardsvr --dbpath /data/db/a --port 10000 > /tmp/sharda.log &
+        mongod --shardsvr --dbpath /data/db/b --port 10001 > /tmp/shardb.log &
+        mongod --configsvr --dbpath /data/db/config --port 20000 > /tmp/configdb.log &
+        sleep 2
+        mongos --chunkSize 1 --port 27017 --configdb 127.0.0.1:20000 > /tmp/mongos1.log &
+        mongos --chunkSize 1 --port 27018 --configdb 127.0.0.1:20000 > /tmp/mongos2.log &
+        ;;
+
+    c*)
+        printf "== Configure sharding ==\n"
+        shardf=/tmp/configshard.js
+        cat - >$shardf <<EOF
+        db.runCommand( { addshard : "127.0.0.1:10000" } )
+        db.runCommand( { addshard : "127.0.0.1:10001" } )
+        db.runCommand( { enablesharding : "test" } )
+        db.runCommand( { shardcollection : "test.people", key : {name : 1} } )
+EOF
+        mongo admin $shardf
+        /bin/rm -f $shardf
+        ;;
+
+     k*)
+         printf "== Kill processes ==\n"
+         xpr="^[0-9]+ mongo[sd]"
+         n=$(ps -eo pid,command|grep -c -E "$xpr")
+         if [ $n -gt 0 ]; then
+             printf "killing $n processes\n"
+             ps -eo pid,command|grep -E "$xpr"| cut -f1 -d' '| xargs kill
+             printf "done\n"
+         else
+             printf "no mongo processes found\n"
+         fi
+         ;;
+
+    *)
+        usage "Unrecognized mode"
+        exit 1
+        ;;
+esac
+
+printf "== Done ==\n"
\ No newline at end of file
diff --git a/frontend/src/tests/sum.js b/frontend/src/tests/sum.js
new file mode 100644
index 0000000000..c201d58d6b
--- /dev/null
+++ b/frontend/src/tests/sum.js
@@ -0,0 +1,4 @@
+function sum(a, b) {
+    return a + b;
+  }
+  module.exports = sum;
\ No newline at end of file
diff --git a/frontend/src/tests/sum.test.js b/frontend/src/tests/sum.test.js
new file mode 100644
index 0000000000..c201d58d6b
--- /dev/null
+++ b/frontend/src/tests/sum.test.js
@@ -0,0 +1,4 @@
+function sum(a, b) {
+    return a + b;
+  }
+  module.exports = sum;
\ No newline at end of file
diff --git a/frontend/src/tests/sum.test.ts b/frontend/src/tests/sum.test.ts
new file mode 100644
index 0000000000..c37767cd90
--- /dev/null
+++ b/frontend/src/tests/sum.test.ts
@@ -0,0 +1,8 @@
+import {describe, expect, test} from '@jest/globals';
+import {sum} from './sum';
+
+describe('sum module', () => {
+  test('adds 1 + 2 to equal 3', () => {
+    expect(sum(1, 2)).toBe(3);
+  });
+});
\ No newline at end of file
diff --git a/frontend/src/tests/tests.ts b/frontend/src/tests/tests.ts
new file mode 100644
index 0000000000..177cc4c21c
--- /dev/null
+++ b/frontend/src/tests/tests.ts
@@ -0,0 +1,30 @@
+import React from 'react'
+import styled from 'styled-components'
+import 'jest-styled-components';
+import renderer from 'react-test-renderer'
+import { expect } from '@jest/globals';
+
+
+const Button = styled.button`
+  color: red;
+`
+
+
+test('it works', () => {
+  const SendButton = () => React.createElement(Button, null, 'Send'); // 'Send' is now correctly a string
+  const tree = renderer.create(React.createElement(SendButton)).toJSON();
+  
+  expect(tree).toMatchSnapshot();
+});
+export const snapshot = `
+.c0 {
+  color: red;
+}
+
+
+<button
+  className="c0"
+/>
+`
+
+// Removed custom expect function to use Jest's built-in expect
diff --git a/frontend/src/tests/tsconfig.json b/frontend/src/tests/tsconfig.json
new file mode 100644
index 0000000000..033572aa21
--- /dev/null
+++ b/frontend/src/tests/tsconfig.json
@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+      "target": "ES6",
+      "outDir": "./dist",
+      "strict": true
+    },
+    "include": ["src/**/*.ts"],
+    "exclude": ["node_modules"]
+  }
\ No newline at end of file
diff --git a/frontend/src/tests/w.py b/frontend/src/tests/w.py
new file mode 100644
index 0000000000..93708546bf
--- /dev/null
+++ b/frontend/src/tests/w.py
@@ -0,0 +1,210 @@
+#!/usr/bin/env python
+"""Mongo Stress Test
+"""
+import datetime
+import logging
+from optparse import OptionParser
+import os
+import random
+import socket
+import sys
+import time
+
+import pymongo
+try:
+    import mongate
+except ImportError:
+    mongate = None
+
+TRACE = logging.DEBUG / 2
+def trace(x, msg, *args, **kwargs):
+    x.log(TRACE, msg, *args, **kwargs)
+
+my_hostname = socket.getfqdn()
+my_pid = os.getpid()
+
+log = logging.getLogger(__name__)
+
+STRESS_DB = 'stress'
+STRESS_COLL = 'data'
+
+REPORT_DB = STRESS_DB
+REPORT_COLL = 'report'
+
+wait_for_it = 0
+net_timeout = 3600 # default to 1 hr
+
+def stress_test(connections, ndocs=None, db_name=None,
+                coll_name=None, pause=0):
+    """Run a stress test.
+    Returns: duration, in seconds
+    """
+    tracing = log.isEnabledFor(TRACE)
+    collections = [x[db_name][coll_name] for x in connections]
+    t0 = time.time()
+    if wait_for_it > 0:
+        wait_sleep = int(max(0,wait_for_it - t0))
+        log.debug("client.wait.start sec={0:d}".format(wait_sleep))
+        time.sleep(wait_sleep)
+        log.debug("client.wait.end sec={0:d}".format(wait_sleep))
+    message = "I am legend"
+    log.debug("loop.start n={n}".format(n=ndocs))
+    t0 = time.time()
+    for i in xrange(ndocs):
+        doc = {'doc_num': i, 'message': message}
+        for collection in collections:
+            collection.insert(doc)
+        if pause > 0:
+            time.sleep(pause)
+        if tracing:
+            trace(log, "inserted {0:d}".format(i))
+    dur = time.time() - t0
+    log.debug("loop.end n={n} dur={d:f}".format(n=ndocs, d=dur))
+    return dur
+
+def report(conn, run, delta_time, **kw):
+    """Report time for a client.
+    """
+    doc = {"host":my_hostname, "pid":my_pid, "run":run, "dt":delta_time}
+    doc.update(kw)
+    log.debug("reporting {}".format(doc))
+    coll = conn[REPORT_DB][REPORT_COLL]
+    coll.insert(doc)
+
+def print_results(coll): 
+    hdr = None
+    for rec in coll.find():
+        if not hdr:
+            hdr = filter(lambda x: x[0] != "_", rec.keys())
+            print(",".join(hdr))
+        values = [str(rec.get(key, "")) for key in hdr]
+        print(",".join(values))
+
+def main():
+    """Program entry point.
+    """
+    global wait_for_it
+
+    # command-line
+    parser = OptionParser()
+    parser.add_option('-c', '--clear', dest='do_clear', help='Clear collection first', 
+                      action="store_true", default=False)
+    parser.add_option('-d', '--ndocs', dest='ndocs', metavar="NUM", type='int', default= 1000,
+                      help='Insert NUM docs per client (default=%default)')
+    parser.add_option('-m', '--mongoose', dest='mongoose', action='store_true',
+                      help="Use sleepy mongoose REST api instead of mongodb native protocol")
+    parser.add_option('-n', '--nclients', dest='nclients', metavar="NUM", type='int', default=1,
+                      help="Number of clients to connect to server (default=%default)")
+    parser.add_option('-p', '--port', dest='port', type='int', default=27018,
+                      help='Connect to MongoDB server on PORT (default=%default)')
+    parser.add_option('-P', '--pause', dest='pause', type='int', default=0,
+                      help="Pause MS milliseconds between each write (default=%default)",
+                      metavar="MS")
+    parser.add_option('-q', '--quiet', dest='quiet', action='store_true', help="No logging")
+    parser.add_option('-r', '--results', dest='do_check', help="Print results and exit. "
+                      "With -c/--clear also clears results.",
+                      action="store_true")
+    parser.add_option("-R", "--run", dest="runid", metavar="ID", help="Run identifier", default=None)
+    parser.add_option('-s', '--server', dest='host', help='MongoDB server host (required)')
+    parser.add_option('-v', '--verbose', dest='vb', action='count', help="More logging")
+    parser.add_option('-w', '--when', dest='when', type='int', default=0,
+                      help="Start at future time SEC seconds since 1/1/1970 (default=now)",
+                      metavar="SEC")
+    (options, args) = parser.parse_args()
+    if options.host is None:
+        parser.error("-s/--server is required")
+        return 1
+
+    # set run identifier string
+    if options.runid is None:
+        if options.when > 0:
+            tm = options.when
+        else:
+            tm = int(time.time())
+        run_id = "{0:d}".format(tm)
+    else:
+        run_id = options.runid
+
+    # init logging
+    hdlr = logging.StreamHandler()
+    formatter = logging.Formatter("{r} %(asctime)s {h} {p:d} "
+        "%(levelname)s %(message)s".format(r=run_id, h=my_hostname, p=my_pid))
+    hdlr.setFormatter(formatter)
+    log.addHandler(hdlr)
+    if options.quiet:
+       log.setLevel(logging.ERROR)
+    elif options.vb > 1:
+        log.setLevel(TRACE)
+    elif options.vb == 1:
+        log.setLevel(logging.DEBUG)
+    else:
+        if options.do_check:
+            log.setLevel(logging.WARN)
+        else:
+            log.setLevel(logging.INFO)
+
+    # get vars from options
+    db_name, coll_name = STRESS_DB, STRESS_COLL
+    ndocs, host, port, wait_for_it, ncli = (options.ndocs, options.host,
+                                     options.port, options.when, options.nclients)
+    pause = options.pause / 1000.0
+
+    # start
+    log.info("run.start docs={m} clients={c} server={h}:{p:d} "
+             "db={db} collection={coll}".format(
+             r=run_id, m=ndocs, h=host, p=port, db=db_name,
+             coll=coll_name, c=ncli))
+
+    log.debug("pre.start")
+    # connect (once for each client)
+    if options.do_check:
+        ncli = 1
+    if options.mongoose:
+        # Assume sleepymongoose is listening on port 27080
+        # and connecting via localhost to the mongodb server.
+        if mongate is None:
+            parser.error("-m/--mongoose option requires 'mongate' Python "
+                    "module, which was not found.")
+            return 2
+        from mongate import connection
+        try:
+            connections = [connection.Connection(host, 27080)
+                      for _ in range(ncli)]
+        except socket.error as err:
+            log.critical("mongoose.connection.error msg={}".format(err))
+            return -1
+        for conn in connections:
+            conn.connect_to_mongo("mongodb://localhost", port)
+    else:
+        connections = [pymongo.Connection(host, port)
+                      for _ in xrange(ncli)]
+    # check mode, just print results and stop
+    conn = connections[0]
+    if options.do_check:
+        coll = conn[db_name][REPORT_COLL]
+        print_results(coll)
+        if options.do_clear:
+            conn[db_name][REPORT_COLL].remove()
+        log.debug("pre.end status=0")
+        return 0
+    # with clear flag, empty db first
+    if options.do_clear:
+        conn[db_name][coll_name].remove()
+    log.debug("pre.end status=0")
+
+    log.debug("main.start")
+    dur = stress_test(connections, ndocs=ndocs, db_name=db_name,
+                      coll_name=coll_name, pause=pause)
+    log.debug("main.end status=0")
+
+    log.debug("post.start")
+    # re-use a previous connection
+    report(conn, run_id, dur, docs=ndocs, clients=ncli)
+    log.debug("post.end status=0")
+
+    # done
+    log.info("run.end status=0")
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main())
\ No newline at end of file
diff --git a/frontend/src/tests/write_pbs.py b/frontend/src/tests/write_pbs.py
new file mode 100644
index 0000000000..6a0fbf784b
--- /dev/null
+++ b/frontend/src/tests/write_pbs.py
@@ -0,0 +1,57 @@
+import sys
+import os
+from optparse import OptionParser
+
+
+name = 'stress_test.py'
+EXE = os.path.join(os.path.abspath(os.path.dirname(__file__)), name)
+
+
+def write_file(file_name, nclients, ndocs, host, port, walltime):
+    """
+    ncores (int) to use
+    file_name (str) to write pbs to
+    walltime (int) walltime (in min) used
+    """
+    outs = []
+    outs.append("#!/bin/bash")
+    outs.append("")
+    outs.append("#PBS -q debug")
+    outs.append("#PBS -N test")
+    # add one for the driving process?
+    outs.append("#PBS -l mppwidth={n}".format(n=nclients + 1))
+    outs.append("#PBS -l walltime=00:0{i}:00".format(i=walltime))
+    outs.append("#PBS -o {f}/RUN.out".format(f=os.getcwd()))
+    outs.append("#PBS -e {f}/RUN.error".format(f=os.getcwd()))
+    outs.append("")
+    outs.append("module load python/2.7.1")
+    outs.append("")
+    outs.append("cd {d}".format(d=os.getcwd()))
+    outs.append("aprun -n {n} python {e} --nclient {n} --port {p} --ndocs {ndocs} --host {h}".format(e=EXE, n=nclients, h=host, p=port, ndocs=ndocs))
+    outs.append("")
+
+    with open(file_name, 'w+') as f:
+        f.write("\n".join(outs))
+
+
+def main(output_file, nclients, ndocs, host, port, walltime):
+    write_file(output_file, nclients, ndocs, host, port, walltime)
+    return 0
+
+if __name__ == '__main__':
+    parser = OptionParser()
+    parser.add_option('-n', '--nclients', type='int', dest='nclients', help='Number of clients to start up')
+    parser.add_option('-d', '--ndocs', dest='ndocs', type='int', default= 1000, help='number of docs to import per client into the db')
+    parser.add_option('-H', '--host', dest='host', help='db hostname')
+    parser.add_option('-o', '--out', dest='output_file', default='run.pbs', help='Output file to write to (e.g, "my_file.pbs"')
+    parser.add_option('-p', '--port', dest='port', type='int', default=27017, help='db port to connect to')
+    # 30 min is the max walltime allowed in the Hopper Debug queue
+    parser.add_option('-t', '--walltime', dest='walltime', type='int', default=29, help='pbs walltime')
+    (options, args) = parser.parse_args()
+    
+    # nclients, host must be given!
+    if options.nclients is not None and options.host is not None:
+        sys.exit(main(options.output_file, options.nclients, options.ndocs, options.host, options.port, options.walltime))
+    else:
+        print "Provide --nclients and --host options"
+        sys.exit(0)
\ No newline at end of file
diff --git a/gcrypt: b/gcrypt:
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/my-project/.gitignore b/my-project/.gitignore
new file mode 100644
index 0000000000..a547bf36d8
--- /dev/null
+++ b/my-project/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/my-project/README.md b/my-project/README.md
new file mode 100644
index 0000000000..7059a962ad
--- /dev/null
+++ b/my-project/README.md
@@ -0,0 +1,12 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.
diff --git a/my-project/eslint.config.js b/my-project/eslint.config.js
new file mode 100644
index 0000000000..cee1e2c788
--- /dev/null
+++ b/my-project/eslint.config.js
@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs['recommended-latest'],
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])
diff --git a/my-project/index.html b/my-project/index.html
new file mode 100644
index 0000000000..0c589eccd4
--- /dev/null
+++ b/my-project/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/my-project/my-project/.gitignore b/my-project/my-project/.gitignore
new file mode 100644
index 0000000000..a547bf36d8
--- /dev/null
+++ b/my-project/my-project/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/my-project/my-project/README.md b/my-project/my-project/README.md
new file mode 100644
index 0000000000..7959ce4269
--- /dev/null
+++ b/my-project/my-project/README.md
@@ -0,0 +1,69 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default tseslint.config([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      ...tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      ...tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      ...tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default tseslint.config([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
diff --git a/my-project/my-project/eslint.config.js b/my-project/my-project/eslint.config.js
new file mode 100644
index 0000000000..d94e7deb72
--- /dev/null
+++ b/my-project/my-project/eslint.config.js
@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { globalIgnores } from 'eslint/config'
+
+export default tseslint.config([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs['recommended-latest'],
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])
diff --git a/my-project/my-project/index.html b/my-project/my-project/index.html
new file mode 100644
index 0000000000..e4b78eae12
--- /dev/null
+++ b/my-project/my-project/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + TS</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/my-project/my-project/package.json b/my-project/my-project/package.json
new file mode 100644
index 0000000000..eb5c2fdbf7
--- /dev/null
+++ b/my-project/my-project/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "my-project",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@vitejs/plugin-react": "^5.0.0",
+    "eslint": "^9.33.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^16.3.0",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.39.1",
+    "vite": "^7.1.2"
+  }
+}
diff --git a/my-project/my-project/public/vite.svg b/my-project/my-project/public/vite.svg
new file mode 100644
index 0000000000..e7b8dfb1b2
--- /dev/null
+++ b/my-project/my-project/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/my-project/my-project/src/App.css b/my-project/my-project/src/App.css
new file mode 100644
index 0000000000..b9d355df2a
--- /dev/null
+++ b/my-project/my-project/src/App.css
@@ -0,0 +1,42 @@
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}
diff --git a/my-project/my-project/src/App.tsx b/my-project/my-project/src/App.tsx
new file mode 100644
index 0000000000..3d7ded3ff6
--- /dev/null
+++ b/my-project/my-project/src/App.tsx
@@ -0,0 +1,35 @@
+import { useState } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from '/vite.svg'
+import './App.css'
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <div>
+        <a href="https://vite.dev" target="_blank">
+          <img src={viteLogo} className="logo" alt="Vite logo" />
+        </a>
+        <a href="https://react.dev" target="_blank">
+          <img src={reactLogo} className="logo react" alt="React logo" />
+        </a>
+      </div>
+      <h1>Vite + React</h1>
+      <div className="card">
+        <button onClick={() => setCount((count) => count + 1)}>
+          count is {count}
+        </button>
+        <p>
+          Edit <code>src/App.tsx</code> and save to test HMR
+        </p>
+      </div>
+      <p className="read-the-docs">
+        Click on the Vite and React logos to learn more
+      </p>
+    </>
+  )
+}
+
+export default App
diff --git a/my-project/my-project/src/assets/react.svg b/my-project/my-project/src/assets/react.svg
new file mode 100644
index 0000000000..6c87de9bb3
--- /dev/null
+++ b/my-project/my-project/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/my-project/my-project/src/index.css b/my-project/my-project/src/index.css
new file mode 100644
index 0000000000..08a3ac9e1e
--- /dev/null
+++ b/my-project/my-project/src/index.css
@@ -0,0 +1,68 @@
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}
diff --git a/my-project/my-project/src/main.tsx b/my-project/my-project/src/main.tsx
new file mode 100644
index 0000000000..bef5202a32
--- /dev/null
+++ b/my-project/my-project/src/main.tsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/my-project/my-project/src/vite-env.d.ts b/my-project/my-project/src/vite-env.d.ts
new file mode 100644
index 0000000000..11f02fe2a0
--- /dev/null
+++ b/my-project/my-project/src/vite-env.d.ts
@@ -0,0 +1 @@
+/// <reference types="vite/client" />
diff --git a/my-project/my-project/tsconfig.app.json b/my-project/my-project/tsconfig.app.json
new file mode 100644
index 0000000000..227a6c6723
--- /dev/null
+++ b/my-project/my-project/tsconfig.app.json
@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}
diff --git a/my-project/my-project/tsconfig.json b/my-project/my-project/tsconfig.json
new file mode 100644
index 0000000000..1ffef600d9
--- /dev/null
+++ b/my-project/my-project/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/my-project/my-project/tsconfig.node.json b/my-project/my-project/tsconfig.node.json
new file mode 100644
index 0000000000..f85a39906e
--- /dev/null
+++ b/my-project/my-project/tsconfig.node.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/my-project/my-project/vite.config.ts b/my-project/my-project/vite.config.ts
new file mode 100644
index 0000000000..8b0f57b91a
--- /dev/null
+++ b/my-project/my-project/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/my-project/package.json b/my-project/package.json
new file mode 100644
index 0000000000..38467d00f1
--- /dev/null
+++ b/my-project/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "my-project",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@vitejs/plugin-react": "^5.0.0",
+    "eslint": "^9.33.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^16.3.0",
+    "vite": "^7.1.2"
+  }
+}
diff --git a/my-project/public/vite.svg b/my-project/public/vite.svg
new file mode 100644
index 0000000000..e7b8dfb1b2
--- /dev/null
+++ b/my-project/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/my-project/src/App.css b/my-project/src/App.css
new file mode 100644
index 0000000000..b9d355df2a
--- /dev/null
+++ b/my-project/src/App.css
@@ -0,0 +1,42 @@
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}
diff --git a/my-project/src/App.jsx b/my-project/src/App.jsx
new file mode 100644
index 0000000000..f67355ae04
--- /dev/null
+++ b/my-project/src/App.jsx
@@ -0,0 +1,35 @@
+import { useState } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from '/vite.svg'
+import './App.css'
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <div>
+        <a href="https://vite.dev" target="_blank">
+          <img src={viteLogo} className="logo" alt="Vite logo" />
+        </a>
+        <a href="https://react.dev" target="_blank">
+          <img src={reactLogo} className="logo react" alt="React logo" />
+        </a>
+      </div>
+      <h1>Vite + React</h1>
+      <div className="card">
+        <button onClick={() => setCount((count) => count + 1)}>
+          count is {count}
+        </button>
+        <p>
+          Edit <code>src/App.jsx</code> and save to test HMR
+        </p>
+      </div>
+      <p className="read-the-docs">
+        Click on the Vite and React logos to learn more
+      </p>
+    </>
+  )
+}
+
+export default App
diff --git a/my-project/src/assets/react.svg b/my-project/src/assets/react.svg
new file mode 100644
index 0000000000..6c87de9bb3
--- /dev/null
+++ b/my-project/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/my-project/src/index.css b/my-project/src/index.css
new file mode 100644
index 0000000000..08a3ac9e1e
--- /dev/null
+++ b/my-project/src/index.css
@@ -0,0 +1,68 @@
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}
diff --git a/my-project/src/main.jsx b/my-project/src/main.jsx
new file mode 100644
index 0000000000..b9a1a6deac
--- /dev/null
+++ b/my-project/src/main.jsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/my-project/vite.config.js b/my-project/vite.config.js
new file mode 100644
index 0000000000..8b0f57b91a
--- /dev/null
+++ b/my-project/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/name-of-your-project/.gitignore b/name-of-your-project/.gitignore
new file mode 100644
index 0000000000..a547bf36d8
--- /dev/null
+++ b/name-of-your-project/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/name-of-your-project/README.md b/name-of-your-project/README.md
new file mode 100644
index 0000000000..7059a962ad
--- /dev/null
+++ b/name-of-your-project/README.md
@@ -0,0 +1,12 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.
diff --git a/name-of-your-project/eslint.config.js b/name-of-your-project/eslint.config.js
new file mode 100644
index 0000000000..cee1e2c788
--- /dev/null
+++ b/name-of-your-project/eslint.config.js
@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs['recommended-latest'],
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])
diff --git a/name-of-your-project/index.html b/name-of-your-project/index.html
new file mode 100644
index 0000000000..0c589eccd4
--- /dev/null
+++ b/name-of-your-project/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>
diff --git a/name-of-your-project/package.json b/name-of-your-project/package.json
new file mode 100644
index 0000000000..3821519159
--- /dev/null
+++ b/name-of-your-project/package.json
@@ -0,0 +1,27 @@
+{
+  "name": "name-of-your-project",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.33.0",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "@vitejs/plugin-react": "^5.0.0",
+    "eslint": "^9.33.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^16.3.0",
+    "vite": "^7.1.2"
+  }
+}
diff --git a/name-of-your-project/public/vite.svg b/name-of-your-project/public/vite.svg
new file mode 100644
index 0000000000..e7b8dfb1b2
--- /dev/null
+++ b/name-of-your-project/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/name-of-your-project/src/App.css b/name-of-your-project/src/App.css
new file mode 100644
index 0000000000..b9d355df2a
--- /dev/null
+++ b/name-of-your-project/src/App.css
@@ -0,0 +1,42 @@
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}
diff --git a/name-of-your-project/src/App.jsx b/name-of-your-project/src/App.jsx
new file mode 100644
index 0000000000..f67355ae04
--- /dev/null
+++ b/name-of-your-project/src/App.jsx
@@ -0,0 +1,35 @@
+import { useState } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from '/vite.svg'
+import './App.css'
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <div>
+        <a href="https://vite.dev" target="_blank">
+          <img src={viteLogo} className="logo" alt="Vite logo" />
+        </a>
+        <a href="https://react.dev" target="_blank">
+          <img src={reactLogo} className="logo react" alt="React logo" />
+        </a>
+      </div>
+      <h1>Vite + React</h1>
+      <div className="card">
+        <button onClick={() => setCount((count) => count + 1)}>
+          count is {count}
+        </button>
+        <p>
+          Edit <code>src/App.jsx</code> and save to test HMR
+        </p>
+      </div>
+      <p className="read-the-docs">
+        Click on the Vite and React logos to learn more
+      </p>
+    </>
+  )
+}
+
+export default App
diff --git a/name-of-your-project/src/assets/react.svg b/name-of-your-project/src/assets/react.svg
new file mode 100644
index 0000000000..6c87de9bb3
--- /dev/null
+++ b/name-of-your-project/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/name-of-your-project/src/index.css b/name-of-your-project/src/index.css
new file mode 100644
index 0000000000..08a3ac9e1e
--- /dev/null
+++ b/name-of-your-project/src/index.css
@@ -0,0 +1,68 @@
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}
diff --git a/name-of-your-project/src/main.jsx b/name-of-your-project/src/main.jsx
new file mode 100644
index 0000000000..b9a1a6deac
--- /dev/null
+++ b/name-of-your-project/src/main.jsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/name-of-your-project/vite.config.js b/name-of-your-project/vite.config.js
new file mode 100644
index 0000000000..8b0f57b91a
--- /dev/null
+++ b/name-of-your-project/vite.config.js
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/package.json b/package.json
index 680d190772..cca9136aef 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,47 @@
 {
   "name": "project-final-parent",
+  "author": "Code-lab-web",
+  "license": "(ISC OR GPL-3.0)",
   "version": "1.0.0",
   "scripts": {
-    "postinstall": "npm install --prefix backend"
+    "test": "jest",
+    "postinstall": "npm install --prefix backend",
+    "start": "babel-node backend/server.js",
+    "dev": "nodemon backend/server.js --exec babel-node"
+  },
+  "dependencies": {
+    "bcrypt": "^6.0.0",
+    "connect-sqlite3": "^0.9.16",
+    "core-js": "^3.37.1",
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "express-session": "^1.18.2",
+    "global": "^2.0.2",
+    "jsonwebtoken": "^9.0.2",
+    "leaflet": "^1.9.4",
+    "localforage": "^1.10.0",
+    "match-sorter": "^8.1.0",
+    "mongodb": "^6.19.0",
+    "node.js": "0.0.1-security",
+    "ol": "^10.6.1",
+    "passport": "^0.7.0",
+    "passport-facebook": "^3.0.0",
+    "python": "0.0.4",
+    "sort-by": "^0.0.2",
+    "state": "0.2.0",
+    "zustand": "^5.0.8"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.7",
+    "@babel/core": "^7.24.7",
+    "@babel/node": "^7.24.7",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.24.7",
+    "@babel/plugin-proposal-export-namespace-from": "^7.18.9",
+    "@babel/preset-env": "^7.24.7",
+    "@babel/preset-react": "^7.24.7",
+    "eslint": "^9.36.0",
+    "jest": "^30.1.3",
+    "nodemon": "^3.1.4"
   }
-}
\ No newline at end of file
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
new file mode 100644
index 0000000000..04028f38b6
--- /dev/null
+++ b/pnpm-lock.yaml
@@ -0,0 +1,6870 @@
+lockfileVersion: '6.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+dependencies:
+  bcrypt:
+    specifier: ^6.0.0
+    version: 6.0.0
+  connect-sqlite3:
+    specifier: ^0.9.16
+    version: 0.9.16
+  core-js:
+    specifier: ^3.37.1
+    version: 3.46.0
+  cors:
+    specifier: ^2.8.5
+    version: 2.8.5
+  express:
+    specifier: ^5.1.0
+    version: 5.1.0
+  express-session:
+    specifier: ^1.18.2
+    version: 1.18.2
+  global:
+    specifier: ^2.0.2
+    version: 2.0.7
+  jsonwebtoken:
+    specifier: ^9.0.2
+    version: 9.0.2
+  leaflet:
+    specifier: ^1.9.4
+    version: 1.9.4
+  localforage:
+    specifier: ^1.10.0
+    version: 1.10.0
+  match-sorter:
+    specifier: ^8.1.0
+    version: 8.1.0
+  mongodb:
+    specifier: ^6.19.0
+    version: 6.20.0
+  node.js:
+    specifier: 0.0.1-security
+    version: 0.0.1-security
+  ol:
+    specifier: ^10.6.1
+    version: 10.6.1
+  passport:
+    specifier: ^0.7.0
+    version: 0.7.0
+  passport-facebook:
+    specifier: ^3.0.0
+    version: 3.0.0
+  python:
+    specifier: 0.0.4
+    version: 0.0.4
+  sort-by:
+    specifier: ^0.0.2
+    version: 0.0.2
+  state:
+    specifier: 0.2.0
+    version: 0.2.0
+  zustand:
+    specifier: ^5.0.8
+    version: 5.0.8
+
+devDependencies:
+  '@babel/cli':
+    specifier: ^7.24.7
+    version: 7.28.3(@babel/core@7.28.4)
+  '@babel/core':
+    specifier: ^7.24.7
+    version: 7.28.4
+  '@babel/node':
+    specifier: ^7.24.7
+    version: 7.28.0(@babel/core@7.28.4)
+  '@babel/plugin-proposal-class-properties':
+    specifier: ^7.18.6
+    version: 7.18.6(@babel/core@7.28.4)
+  '@babel/plugin-proposal-decorators':
+    specifier: ^7.24.7
+    version: 7.28.0(@babel/core@7.28.4)
+  '@babel/plugin-proposal-export-namespace-from':
+    specifier: ^7.18.9
+    version: 7.18.9(@babel/core@7.28.4)
+  '@babel/preset-env':
+    specifier: ^7.24.7
+    version: 7.28.3(@babel/core@7.28.4)
+  '@babel/preset-react':
+    specifier: ^7.24.7
+    version: 7.27.1(@babel/core@7.28.4)
+  eslint:
+    specifier: ^9.36.0
+    version: 9.38.0
+  jest:
+    specifier: ^30.1.3
+    version: 30.2.0
+  nodemon:
+    specifier: ^3.1.4
+    version: 3.1.10
+
+packages:
+
+  /@babel/cli@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-n1RU5vuCX0CsaqaXm9I0KUCNKNQMy5epmzl/xdSSm70bSqhg9GWhgeosypyQLc0bK24+Xpk1WGzZlI9pJtkZdg==}
+    engines: {node: '>=6.9.0'}
+    hasBin: true
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@jridgewell/trace-mapping': 0.3.31
+      commander: 6.2.1
+      convert-source-map: 2.0.0
+      fs-readdir-recursive: 1.1.0
+      glob: 7.2.3
+      make-dir: 2.1.0
+      slash: 2.0.0
+    optionalDependencies:
+      '@nicolo-ribaudo/chokidar-2': 2.1.8-no-fsevents.3
+      chokidar: 3.6.0
+    dev: true
+
+  /@babel/code-frame@7.27.1:
+    resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.27.1
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+    dev: true
+
+  /@babel/compat-data@7.28.4:
+    resolution: {integrity: sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/core@7.28.4:
+    resolution: {integrity: sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@babel/generator': 7.28.3
+      '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
+      '@babel/helpers': 7.28.4
+      '@babel/parser': 7.28.4
+      '@babel/template': 7.27.2
+      '@babel/traverse': 7.28.4
+      '@babel/types': 7.28.4
+      '@jridgewell/remapping': 2.3.5
+      convert-source-map: 2.0.0
+      debug: 4.4.1(supports-color@5.5.0)
+      gensync: 1.0.0-beta.2
+      json5: 2.2.3
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/generator@7.28.3:
+    resolution: {integrity: sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/parser': 7.28.4
+      '@babel/types': 7.28.4
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+    dev: true
+
+  /@babel/helper-annotate-as-pure@7.27.3:
+    resolution: {integrity: sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@babel/helper-compilation-targets@7.27.2:
+    resolution: {integrity: sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/compat-data': 7.28.4
+      '@babel/helper-validator-option': 7.27.1
+      browserslist: 4.26.3
+      lru-cache: 5.1.1
+      semver: 6.3.1
+    dev: true
+
+  /@babel/helper-create-class-features-plugin@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-V9f6ZFIYSLNEbuGA/92uOvYsGCJNsuA8ESZ4ldc09bWk/j8H8TKiPw8Mk1eG6olpnO0ALHJmYfZvF4MEE4gajg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-member-expression-to-functions': 7.27.1
+      '@babel/helper-optimise-call-expression': 7.27.1
+      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+      '@babel/traverse': 7.28.4
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-create-regexp-features-plugin@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-uVDC72XVf8UbrH5qQTc18Agb8emwjTiZrQE11Nv3CuBEZmVvTwwE9CBUEvHku06gQCAyYf8Nv6ja1IN+6LMbxQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      regexpu-core: 6.4.0
+      semver: 6.3.1
+    dev: true
+
+  /@babel/helper-define-polyfill-provider@0.6.5(@babel/core@7.28.4):
+    resolution: {integrity: sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-plugin-utils': 7.27.1
+      debug: 4.4.1(supports-color@5.5.0)
+      lodash.debounce: 4.0.8
+      resolve: 1.22.11
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-globals@7.28.0:
+    resolution: {integrity: sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/helper-member-expression-to-functions@7.27.1:
+    resolution: {integrity: sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.28.4
+      '@babel/types': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-module-imports@7.27.1:
+    resolution: {integrity: sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.28.4
+      '@babel/types': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-module-transforms@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-module-imports': 7.27.1
+      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-optimise-call-expression@7.27.1:
+    resolution: {integrity: sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@babel/helper-plugin-utils@7.27.1:
+    resolution: {integrity: sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/helper-remap-async-to-generator@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-wrap-function': 7.28.3
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-replace-supers@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-member-expression-to-functions': 7.27.1
+      '@babel/helper-optimise-call-expression': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-skip-transparent-expression-wrappers@7.27.1:
+    resolution: {integrity: sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/traverse': 7.28.4
+      '@babel/types': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helper-string-parser@7.27.1:
+    resolution: {integrity: sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/helper-validator-identifier@7.27.1:
+    resolution: {integrity: sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/helper-validator-option@7.27.1:
+    resolution: {integrity: sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /@babel/helper-wrap-function@7.28.3:
+    resolution: {integrity: sha512-zdf983tNfLZFletc0RRXYrHrucBEg95NIFMkn6K9dbeMYnsgHaSBGcQqdsCSStG2PYwRre0Qc2NNSCXbG+xc6g==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/template': 7.27.2
+      '@babel/traverse': 7.28.4
+      '@babel/types': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/helpers@7.28.4:
+    resolution: {integrity: sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/template': 7.27.2
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@babel/node@7.28.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-6u1Mmn3SIMUH8uwTq543L062X3JDgms9HPf06o/pIGdDjeD/zNQ+dfZPQD27sCyvtP0ZOlJtwnl2RIdPe9bHeQ==}
+    engines: {node: '>=6.9.0'}
+    hasBin: true
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/register': 7.28.3(@babel/core@7.28.4)
+      commander: 6.2.1
+      core-js: 3.46.0
+      node-environment-flags: 1.0.6
+      regenerator-runtime: 0.14.1
+      v8flags: 3.2.0
+    dev: true
+
+  /@babel/parser@7.28.4:
+    resolution: {integrity: sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+    dependencies:
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@babel/plugin-bugfix-firefox-class-in-computed-class-key@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-QPG3C9cCVRQLxAVwmefEmwdTanECuUBMQZ/ym5kiw3XKCGA7qkuQLcjWWHcrD/GKbn/WmJwaezfuuAOcyKlRPA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-bugfix-safari-class-field-initializer-scope@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.13.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+      '@babel/plugin-transform-optional-chaining': 7.27.1(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-b6YTX108evsvE4YgWyQ921ZAFFQm3Bn+CA3+ZXlNVnPhx+UfsVURoPjfGAPCjBgrqo30yX/C2nZGX96DxvR9Iw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-proposal-class-properties@7.18.6(@babel/core@7.28.4):
+    resolution: {integrity: sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==}
+    engines: {node: '>=6.9.0'}
+    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-class-properties instead.
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-proposal-decorators@7.28.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-zOiZqvANjWDUaUS9xMxbMcK/Zccztbe/6ikvUXaG9nsPH3w6qh5UaPGAnirI/WhIbZ8m3OHU0ReyPrknG+ZKeg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/plugin-syntax-decorators': 7.27.1(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-proposal-export-namespace-from@7.18.9(@babel/core@7.28.4):
+    resolution: {integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==}
+    engines: {node: '>=6.9.0'}
+    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-export-namespace-from instead.
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.28.4)
+    dev: true
+
+  /@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.28.4):
+    resolution: {integrity: sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+    dev: true
+
+  /@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-bigint@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.28.4):
+    resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.28.4):
+    resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-decorators@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-YMq8Z87Lhl8EGkmb0MwYkt36QnxC+fzCgrl66ereamPlYToRpIk5nUjKUY3QKLWq8mwUB1BgbeXcTJhZOCDg5A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-export-namespace-from@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-import-assertions@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-UT/Jrhw57xg4ILHLFnzFpPDlMbcdEicaAtjPQpbj9wa8T4r5KVWCimHcL/460g8Ht0DMxDyjsLgiWSkVjnwPFg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-import-attributes@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-jsx@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.28.4):
+    resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.28.4):
+    resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-typescript@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.28.4):
+    resolution: {integrity: sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-arrow-functions@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-async-generator-functions@7.28.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.28.4)
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-async-to-generator@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-module-imports': 7.27.1
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-remap-async-to-generator': 7.27.1(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-block-scoped-functions@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-block-scoping@7.28.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-1yxmvN0MJHOhPVmAsmoW5liWwoILobu/d/ShymZmj867bAdxGbehIrew1DuLpw2Ukv+qDSSPQdYW1dLNE7t11A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-class-properties@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-class-static-block@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-LtPXlBbRoc4Njl/oh1CeD/3jC+atytbnf/UqLoqTDcEYGUPj022+rvfkbDYieUrSj3CaV4yHDByPE+T2HwfsJg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.12.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-classes@7.28.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-cFOlhIYPBv/iBoc+KS3M6et2XPtbT2HiCRfBXWtfpc9OAyostldxIf9YAYB6ypURBBbx+Qv6nyrLzASfJe+hBA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-globals': 7.28.0
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.28.4)
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-computed-properties@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/template': 7.27.2
+    dev: true
+
+  /@babel/plugin-transform-destructuring@7.28.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-v1nrSMBiKcodhsyJ4Gf+Z0U/yawmJDBOTpEB3mcQY52r9RIyPneGyAS/yM6seP/8I+mWI3elOMtT5dB8GJVs+A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-dotall-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-gEbkDVGRvjj7+T1ivxrfgygpT7GUd4vmODtYpbs0gZATdkX8/iSnOtZSxiZnsgm1YjTgjI6VKBGSJJevkrclzw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-duplicate-keys@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-duplicate-named-capturing-groups-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-hkGcueTEzuhB30B3eJCbCYeCaaEQOmQR0AdvzpD4LoN0GXMWzzGSuRrxR2xTnCrvNbVwK9N6/jQ92GSLfiZWoQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-dynamic-import@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-explicit-resource-management@7.28.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-K8nhUcn3f6iB+P3gwCv/no7OdzOZQcKchW6N389V6PD8NUWKZHzndOd9sPDVbMoBsbmjMqlB4L9fm+fEFNVlwQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/plugin-transform-destructuring': 7.28.0(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-exponentiation-operator@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-uspvXnhHvGKf2r4VVtBpeFnuDWsJLQ6MF6lGJLC89jBR1uoVeqM416AZtTuhTezOfgHicpJQmoD5YUakO/YmXQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-export-namespace-from@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-for-of@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-function-name@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-json-strings@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-6WVLVJiTjqcQauBhn1LkICsR2H+zm62I3h9faTDKt1qP4jn2o72tSvqMwtGFKGTpojce0gJs+76eZ2uCHRZh0Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-literals@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-logical-assignment-operators@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-SJvDs5dXxiae4FbSL1aBJlG4wvl594N6YEVVn9e3JGulwioy6z3oPjx/sQBO3Y4NwUu5HNix6KJ3wBZoewcdbw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-member-expression-literals@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-modules-amd@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-modules-commonjs@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-modules-systemjs@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-w5N1XzsRbc0PQStASMksmUeqECuzKuTJer7kFagK8AXgpCMkeDMO5S+aaFb7A51ZYDF7XI34qsTX+fkHiIm5yA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-validator-identifier': 7.27.1
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-modules-umd@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-module-transforms': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-named-capturing-groups-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-new-target@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-nullish-coalescing-operator@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-numeric-separator@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-object-rest-spread@7.28.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-373KA2HQzKhQCYiRVIRr+3MjpCObqzDlyrM6u4I201wL8Mp2wHf7uB8GhDwis03k2ti8Zr65Zyyqs1xOxUF/Ew==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/plugin-transform-destructuring': 7.28.0(@babel/core@7.28.4)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.4)
+      '@babel/traverse': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-object-super@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-replace-supers': 7.27.1(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-optional-catch-binding@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-optional-chaining@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-BQmKPPIuc8EkZgNKsv0X4bPmOoayeu4F1YCwx2/CfmDSXDbp7GnzlUH+/ul5VGfRg1AoFPsrIThlEBj2xb4CAg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-parameters@7.27.7(@babel/core@7.28.4):
+    resolution: {integrity: sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-private-methods@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-private-property-in-object@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-create-class-features-plugin': 7.28.3(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-property-literals@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-react-display-name@7.28.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-react-jsx-development@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-react-jsx@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-module-imports': 7.27.1
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
+      '@babel/types': 7.28.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-react-pure-annotations@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-annotate-as-pure': 7.27.3
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-regenerator@7.28.4(@babel/core@7.28.4):
+    resolution: {integrity: sha512-+ZEdQlBoRg9m2NnzvEeLgtvBMO4tkFBw5SQIUgLICgTrumLoU7lr+Oghi6km2PFj+dbUt2u1oby2w3BDO9YQnA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-regexp-modifiers@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-TtEciroaiODtXvLZv4rmfMhkCv8jx3wgKpL68PuiPh2M4fvz5jhsA7697N1gMvkvr/JTF13DrFYyEbY9U7cVPA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-reserved-words@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-shorthand-properties@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-spread@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-skip-transparent-expression-wrappers': 7.27.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/plugin-transform-sticky-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-template-literals@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-typeof-symbol@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-unicode-escapes@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-unicode-property-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-uW20S39PnaTImxp39O5qFlHLS9LJEmANjMG7SxIhap8rCHqu0Ik+tLEPX5DKmHn6CsWQ7j3lix2tFOa5YtL12Q==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-unicode-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/plugin-transform-unicode-sets-regex@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-EtkOujbc4cgvb0mlpQefi4NTPBzhSIevblFevACNLUspmrALgmEBdL/XfnyyITfd8fKBZrZys92zOWcik7j9Tw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-create-regexp-features-plugin': 7.27.1(@babel/core@7.28.4)
+      '@babel/helper-plugin-utils': 7.27.1
+    dev: true
+
+  /@babel/preset-env@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-ROiDcM+GbYVPYBOeCR6uBXKkQpBExLl8k9HO1ygXEyds39j+vCCsjmj7S8GOniZQlEs81QlkdJZe76IpLSiqpg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/compat-data': 7.28.4
+      '@babel/core': 7.28.4
+      '@babel/helper-compilation-targets': 7.27.2
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-validator-option': 7.27.1
+      '@babel/plugin-bugfix-firefox-class-in-computed-class-key': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-bugfix-safari-class-field-initializer-scope': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly': 7.28.3(@babel/core@7.28.4)
+      '@babel/plugin-proposal-private-property-in-object': 7.21.0-placeholder-for-preset-env.2(@babel/core@7.28.4)
+      '@babel/plugin-syntax-import-assertions': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-syntax-import-attributes': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-syntax-unicode-sets-regex': 7.18.6(@babel/core@7.28.4)
+      '@babel/plugin-transform-arrow-functions': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-async-generator-functions': 7.28.0(@babel/core@7.28.4)
+      '@babel/plugin-transform-async-to-generator': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-block-scoped-functions': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-block-scoping': 7.28.4(@babel/core@7.28.4)
+      '@babel/plugin-transform-class-properties': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-class-static-block': 7.28.3(@babel/core@7.28.4)
+      '@babel/plugin-transform-classes': 7.28.4(@babel/core@7.28.4)
+      '@babel/plugin-transform-computed-properties': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-destructuring': 7.28.0(@babel/core@7.28.4)
+      '@babel/plugin-transform-dotall-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-duplicate-keys': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-duplicate-named-capturing-groups-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-dynamic-import': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-explicit-resource-management': 7.28.0(@babel/core@7.28.4)
+      '@babel/plugin-transform-exponentiation-operator': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-export-namespace-from': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-for-of': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-function-name': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-json-strings': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-literals': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-logical-assignment-operators': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-member-expression-literals': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-modules-amd': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-modules-commonjs': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-modules-systemjs': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-modules-umd': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-named-capturing-groups-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-new-target': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-nullish-coalescing-operator': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-numeric-separator': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-object-rest-spread': 7.28.4(@babel/core@7.28.4)
+      '@babel/plugin-transform-object-super': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-optional-catch-binding': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-optional-chaining': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-parameters': 7.27.7(@babel/core@7.28.4)
+      '@babel/plugin-transform-private-methods': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-private-property-in-object': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-property-literals': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-regenerator': 7.28.4(@babel/core@7.28.4)
+      '@babel/plugin-transform-regexp-modifiers': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-reserved-words': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-shorthand-properties': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-spread': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-sticky-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-template-literals': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-typeof-symbol': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-unicode-escapes': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-unicode-property-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-unicode-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-unicode-sets-regex': 7.27.1(@babel/core@7.28.4)
+      '@babel/preset-modules': 0.1.6-no-external-plugins(@babel/core@7.28.4)
+      babel-plugin-polyfill-corejs2: 0.4.14(@babel/core@7.28.4)
+      babel-plugin-polyfill-corejs3: 0.13.0(@babel/core@7.28.4)
+      babel-plugin-polyfill-regenerator: 0.6.5(@babel/core@7.28.4)
+      core-js-compat: 3.46.0
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.28.4):
+    resolution: {integrity: sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0 || ^8.0.0-0 <8.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/types': 7.28.4
+      esutils: 2.0.3
+    dev: true
+
+  /@babel/preset-react@7.27.1(@babel/core@7.28.4):
+    resolution: {integrity: sha512-oJHWh2gLhU9dW9HHr42q0cI0/iHHXTLGe39qvpAZZzagHy0MzYLCnCVV0symeRvzmjHyVU7mw2K06E6u/JwbhA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-plugin-utils': 7.27.1
+      '@babel/helper-validator-option': 7.27.1
+      '@babel/plugin-transform-react-display-name': 7.28.0(@babel/core@7.28.4)
+      '@babel/plugin-transform-react-jsx': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-react-jsx-development': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-transform-react-pure-annotations': 7.27.1(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/register@7.28.3(@babel/core@7.28.4):
+    resolution: {integrity: sha512-CieDOtd8u208eI49bYl4z1J22ySFw87IGwE+IswFEExH7e3rLgKb0WNQeumnacQ1+VoDJLYI5QFA3AJZuyZQfA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      clone-deep: 4.0.1
+      find-cache-dir: 2.1.0
+      make-dir: 2.1.0
+      pirates: 4.0.7
+      source-map-support: 0.5.21
+    dev: true
+
+  /@babel/runtime@7.28.4:
+    resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==}
+    engines: {node: '>=6.9.0'}
+    dev: false
+
+  /@babel/template@7.27.2:
+    resolution: {integrity: sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@babel/parser': 7.28.4
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@babel/traverse@7.28.4:
+    resolution: {integrity: sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@babel/generator': 7.28.3
+      '@babel/helper-globals': 7.28.0
+      '@babel/parser': 7.28.4
+      '@babel/template': 7.27.2
+      '@babel/types': 7.28.4
+      debug: 4.4.1(supports-color@5.5.0)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@babel/types@7.28.4:
+    resolution: {integrity: sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-string-parser': 7.27.1
+      '@babel/helper-validator-identifier': 7.27.1
+    dev: true
+
+  /@bcoe/v8-coverage@0.2.3:
+    resolution: {integrity: sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==}
+    dev: true
+
+  /@emnapi/core@1.6.0:
+    resolution: {integrity: sha512-zq/ay+9fNIJJtJiZxdTnXS20PllcYMX3OE23ESc4HK/bdYu3cOWYVhsOhVnXALfU/uqJIxn5NBPd9z4v+SfoSg==}
+    requiresBuild: true
+    dependencies:
+      '@emnapi/wasi-threads': 1.1.0
+      tslib: 2.8.1
+    dev: true
+    optional: true
+
+  /@emnapi/runtime@1.6.0:
+    resolution: {integrity: sha512-obtUmAHTMjll499P+D9A3axeJFlhdjOWdKUNs/U6QIGT7V5RjcUW1xToAzjvmgTSQhDbYn/NwfTRoJcQ2rNBxA==}
+    requiresBuild: true
+    dependencies:
+      tslib: 2.8.1
+    dev: true
+    optional: true
+
+  /@emnapi/wasi-threads@1.1.0:
+    resolution: {integrity: sha512-WI0DdZ8xFSbgMjR1sFsKABJ/C5OnRrjT06JXbZKexJGrDuPTzZdDYfFlsgcCXCyf+suG5QU2e/y1Wo2V/OapLQ==}
+    requiresBuild: true
+    dependencies:
+      tslib: 2.8.1
+    dev: true
+    optional: true
+
+  /@eslint-community/eslint-utils@4.9.0(eslint@9.38.0):
+    resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+    dependencies:
+      eslint: 9.38.0
+      eslint-visitor-keys: 3.4.3
+    dev: true
+
+  /@eslint-community/regexpp@4.12.1:
+    resolution: {integrity: sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+    dev: true
+
+  /@eslint/config-array@0.21.1:
+    resolution: {integrity: sha512-aw1gNayWpdI/jSYVgzN5pL0cfzU02GT3NBpeT/DXbx1/1x7ZKxFPd9bwrzygx/qiwIQiJ1sw/zD8qY/kRvlGHA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      '@eslint/object-schema': 2.1.7
+      debug: 4.4.1(supports-color@5.5.0)
+      minimatch: 3.1.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@eslint/config-helpers@0.4.1:
+    resolution: {integrity: sha512-csZAzkNhsgwb0I/UAV6/RGFTbiakPCf0ZrGmrIxQpYvGZ00PhTkSnyKNolphgIvmnJeGw6rcGVEXfTzUnFuEvw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      '@eslint/core': 0.16.0
+    dev: true
+
+  /@eslint/core@0.16.0:
+    resolution: {integrity: sha512-nmC8/totwobIiFcGkDza3GIKfAw1+hLiYVrh3I1nIomQ8PEr5cxg34jnkmGawul/ep52wGRAcyeDCNtWKSOj4Q==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      '@types/json-schema': 7.0.15
+    dev: true
+
+  /@eslint/eslintrc@3.3.1:
+    resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      ajv: 6.12.6
+      debug: 4.4.1(supports-color@5.5.0)
+      espree: 10.4.0
+      globals: 14.0.0
+      ignore: 5.3.2
+      import-fresh: 3.3.1
+      js-yaml: 4.1.0
+      minimatch: 3.1.2
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@eslint/js@9.38.0:
+    resolution: {integrity: sha512-UZ1VpFvXf9J06YG9xQBdnzU+kthors6KjhMAl6f4gH4usHyh31rUf2DLGInT8RFYIReYXNSydgPY0V2LuWgl7A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
+  /@eslint/object-schema@2.1.7:
+    resolution: {integrity: sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
+  /@eslint/plugin-kit@0.4.0:
+    resolution: {integrity: sha512-sB5uyeq+dwCWyPi31B2gQlVlo+j5brPlWx4yZBrEaRo/nhdDE8Xke1gsGgtiBdaBTxuTkceLVuVt/pclrasb0A==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      '@eslint/core': 0.16.0
+      levn: 0.4.1
+    dev: true
+
+  /@gar/promisify@1.1.3:
+    resolution: {integrity: sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /@humanfs/core@0.19.1:
+    resolution: {integrity: sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==}
+    engines: {node: '>=18.18.0'}
+    dev: true
+
+  /@humanfs/node@0.16.7:
+    resolution: {integrity: sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==}
+    engines: {node: '>=18.18.0'}
+    dependencies:
+      '@humanfs/core': 0.19.1
+      '@humanwhocodes/retry': 0.4.3
+    dev: true
+
+  /@humanwhocodes/module-importer@1.0.1:
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
+    dev: true
+
+  /@humanwhocodes/retry@0.4.3:
+    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
+    engines: {node: '>=18.18'}
+    dev: true
+
+  /@isaacs/cliui@8.0.2:
+    resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==}
+    engines: {node: '>=12'}
+    dependencies:
+      string-width: 5.1.2
+      string-width-cjs: /string-width@4.2.3
+      strip-ansi: 7.1.2
+      strip-ansi-cjs: /strip-ansi@6.0.1
+      wrap-ansi: 8.1.0
+      wrap-ansi-cjs: /wrap-ansi@7.0.0
+    dev: true
+
+  /@istanbuljs/load-nyc-config@1.1.0:
+    resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      camelcase: 5.3.1
+      find-up: 4.1.0
+      get-package-type: 0.1.0
+      js-yaml: 3.14.1
+      resolve-from: 5.0.0
+    dev: true
+
+  /@istanbuljs/schema@0.1.3:
+    resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /@jest/console@30.2.0:
+    resolution: {integrity: sha512-+O1ifRjkvYIkBqASKWgLxrpEhQAAE7hY77ALLUufSk5717KfOShg6IbqLmdsLMPdUiFvA2kTs0R7YZy+l0IzZQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      chalk: 4.1.2
+      jest-message-util: 30.2.0
+      jest-util: 30.2.0
+      slash: 3.0.0
+    dev: true
+
+  /@jest/core@30.2.0:
+    resolution: {integrity: sha512-03W6IhuhjqTlpzh/ojut/pDB2LPRygyWX8ExpgHtQA8H/3K7+1vKmcINx5UzeOX1se6YEsBsOHQ1CRzf3fOwTQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@jest/console': 30.2.0
+      '@jest/pattern': 30.0.1
+      '@jest/reporters': 30.2.0
+      '@jest/test-result': 30.2.0
+      '@jest/transform': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      ansi-escapes: 4.3.2
+      chalk: 4.1.2
+      ci-info: 4.3.1
+      exit-x: 0.2.2
+      graceful-fs: 4.2.11
+      jest-changed-files: 30.2.0
+      jest-config: 30.2.0(@types/node@24.9.1)
+      jest-haste-map: 30.2.0
+      jest-message-util: 30.2.0
+      jest-regex-util: 30.0.1
+      jest-resolve: 30.2.0
+      jest-resolve-dependencies: 30.2.0
+      jest-runner: 30.2.0
+      jest-runtime: 30.2.0
+      jest-snapshot: 30.2.0
+      jest-util: 30.2.0
+      jest-validate: 30.2.0
+      jest-watcher: 30.2.0
+      micromatch: 4.0.8
+      pretty-format: 30.2.0
+      slash: 3.0.0
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    dev: true
+
+  /@jest/diff-sequences@30.0.1:
+    resolution: {integrity: sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dev: true
+
+  /@jest/environment@30.2.0:
+    resolution: {integrity: sha512-/QPTL7OBJQ5ac09UDRa3EQes4gt1FTEG/8jZ/4v5IVzx+Cv7dLxlVIvfvSVRiiX2drWyXeBjkMSR8hvOWSog5g==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/fake-timers': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      jest-mock: 30.2.0
+    dev: true
+
+  /@jest/expect-utils@30.2.0:
+    resolution: {integrity: sha512-1JnRfhqpD8HGpOmQp180Fo9Zt69zNtC+9lR+kT7NVL05tNXIi+QC8Csz7lfidMoVLPD3FnOtcmp0CEFnxExGEA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/get-type': 30.1.0
+    dev: true
+
+  /@jest/expect@30.2.0:
+    resolution: {integrity: sha512-V9yxQK5erfzx99Sf+7LbhBwNWEZ9eZay8qQ9+JSC0TrMR1pMDHLMY+BnVPacWU6Jamrh252/IKo4F1Xn/zfiqA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      expect: 30.2.0
+      jest-snapshot: 30.2.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@jest/fake-timers@30.2.0:
+    resolution: {integrity: sha512-HI3tRLjRxAbBy0VO8dqqm7Hb2mIa8d5bg/NJkyQcOk7V118ObQML8RC5luTF/Zsg4474a+gDvhce7eTnP4GhYw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/types': 30.2.0
+      '@sinonjs/fake-timers': 13.0.5
+      '@types/node': 24.9.1
+      jest-message-util: 30.2.0
+      jest-mock: 30.2.0
+      jest-util: 30.2.0
+    dev: true
+
+  /@jest/get-type@30.1.0:
+    resolution: {integrity: sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dev: true
+
+  /@jest/globals@30.2.0:
+    resolution: {integrity: sha512-b63wmnKPaK+6ZZfpYhz9K61oybvbI1aMcIs80++JI1O1rR1vaxHUCNqo3ITu6NU0d4V34yZFoHMn/uoKr/Rwfw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/environment': 30.2.0
+      '@jest/expect': 30.2.0
+      '@jest/types': 30.2.0
+      jest-mock: 30.2.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@jest/pattern@30.0.1:
+    resolution: {integrity: sha512-gWp7NfQW27LaBQz3TITS8L7ZCQ0TLvtmI//4OwlQRx4rnWxcPNIYjxZpDcN4+UlGxgm3jS5QPz8IPTCkb59wZA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@types/node': 24.9.1
+      jest-regex-util: 30.0.1
+    dev: true
+
+  /@jest/reporters@30.2.0:
+    resolution: {integrity: sha512-DRyW6baWPqKMa9CzeiBjHwjd8XeAyco2Vt8XbcLFjiwCOEKOvy82GJ8QQnJE9ofsxCMPjH4MfH8fCWIHHDKpAQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@bcoe/v8-coverage': 0.2.3
+      '@jest/console': 30.2.0
+      '@jest/test-result': 30.2.0
+      '@jest/transform': 30.2.0
+      '@jest/types': 30.2.0
+      '@jridgewell/trace-mapping': 0.3.31
+      '@types/node': 24.9.1
+      chalk: 4.1.2
+      collect-v8-coverage: 1.0.3
+      exit-x: 0.2.2
+      glob: 10.4.5
+      graceful-fs: 4.2.11
+      istanbul-lib-coverage: 3.2.2
+      istanbul-lib-instrument: 6.0.3
+      istanbul-lib-report: 3.0.1
+      istanbul-lib-source-maps: 5.0.6
+      istanbul-reports: 3.2.0
+      jest-message-util: 30.2.0
+      jest-util: 30.2.0
+      jest-worker: 30.2.0
+      slash: 3.0.0
+      string-length: 4.0.2
+      v8-to-istanbul: 9.3.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@jest/schemas@30.0.5:
+    resolution: {integrity: sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@sinclair/typebox': 0.34.41
+    dev: true
+
+  /@jest/snapshot-utils@30.2.0:
+    resolution: {integrity: sha512-0aVxM3RH6DaiLcjj/b0KrIBZhSX1373Xci4l3cW5xiUWPctZ59zQ7jj4rqcJQ/Z8JuN/4wX3FpJSa3RssVvCug==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/types': 30.2.0
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      natural-compare: 1.4.0
+    dev: true
+
+  /@jest/source-map@30.0.1:
+    resolution: {integrity: sha512-MIRWMUUR3sdbP36oyNyhbThLHyJ2eEDClPCiHVbrYAe5g3CHRArIVpBw7cdSB5fr+ofSfIb2Tnsw8iEHL0PYQg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      callsites: 3.1.0
+      graceful-fs: 4.2.11
+    dev: true
+
+  /@jest/test-result@30.2.0:
+    resolution: {integrity: sha512-RF+Z+0CCHkARz5HT9mcQCBulb1wgCP3FBvl9VFokMX27acKphwyQsNuWH3c+ojd1LeWBLoTYoxF0zm6S/66mjg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/console': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/istanbul-lib-coverage': 2.0.6
+      collect-v8-coverage: 1.0.3
+    dev: true
+
+  /@jest/test-sequencer@30.2.0:
+    resolution: {integrity: sha512-wXKgU/lk8fKXMu/l5Hog1R61bL4q5GCdT6OJvdAFz1P+QrpoFuLU68eoKuVc4RbrTtNnTL5FByhWdLgOPSph+Q==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/test-result': 30.2.0
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.2.0
+      slash: 3.0.0
+    dev: true
+
+  /@jest/transform@30.2.0:
+    resolution: {integrity: sha512-XsauDV82o5qXbhalKxD7p4TZYYdwcaEXC77PPD2HixEFF+6YGppjrAAQurTl2ECWcEomHBMMNS9AH3kcCFx8jA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@babel/core': 7.28.4
+      '@jest/types': 30.2.0
+      '@jridgewell/trace-mapping': 0.3.31
+      babel-plugin-istanbul: 7.0.1
+      chalk: 4.1.2
+      convert-source-map: 2.0.0
+      fast-json-stable-stringify: 2.1.0
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.2.0
+      jest-regex-util: 30.0.1
+      jest-util: 30.2.0
+      micromatch: 4.0.8
+      pirates: 4.0.7
+      slash: 3.0.0
+      write-file-atomic: 5.0.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@jest/types@30.2.0:
+    resolution: {integrity: sha512-H9xg1/sfVvyfU7o3zMfBEjQ1gcsdeTMgqHoYdN79tuLqfTtuu7WckRA1R5whDwOzxaZAeMKTYWqP+WCAi0CHsg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/pattern': 30.0.1
+      '@jest/schemas': 30.0.5
+      '@types/istanbul-lib-coverage': 2.0.6
+      '@types/istanbul-reports': 3.0.4
+      '@types/node': 24.9.1
+      '@types/yargs': 17.0.33
+      chalk: 4.1.2
+    dev: true
+
+  /@jridgewell/gen-mapping@0.3.13:
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+    dev: true
+
+  /@jridgewell/remapping@2.3.5:
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+    dev: true
+
+  /@jridgewell/resolve-uri@3.1.2:
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+    dev: true
+
+  /@jridgewell/sourcemap-codec@1.5.5:
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+    dev: true
+
+  /@jridgewell/trace-mapping@0.3.31:
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+    dev: true
+
+  /@mongodb-js/saslprep@1.3.0:
+    resolution: {integrity: sha512-zlayKCsIjYb7/IdfqxorK5+xUMyi4vOKcFy10wKJYc63NSdKI8mNME+uJqfatkPmOSMMUiojrL58IePKBm3gvQ==}
+    dependencies:
+      sparse-bitfield: 3.0.3
+    dev: false
+
+  /@napi-rs/wasm-runtime@0.2.12:
+    resolution: {integrity: sha512-ZVWUcfwY4E/yPitQJl481FjFo3K22D6qF0DuFH6Y/nbnE11GY5uguDxZMGXPQ8WQ0128MXQD7TnfHyK4oWoIJQ==}
+    requiresBuild: true
+    dependencies:
+      '@emnapi/core': 1.6.0
+      '@emnapi/runtime': 1.6.0
+      '@tybys/wasm-util': 0.10.1
+    dev: true
+    optional: true
+
+  /@nicolo-ribaudo/chokidar-2@2.1.8-no-fsevents.3:
+    resolution: {integrity: sha512-s88O1aVtXftvp5bCPB7WnmXc5IwOZZ7YPuwNPt+GtOOXpPvad1LfbmjYv+qII7zP6RU2QGnqve27dnLycEnyEQ==}
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@npmcli/fs@1.1.1:
+    resolution: {integrity: sha512-8KG5RD0GVP4ydEzRn/I4BNDuxDtqVbOdm8675T49OIG/NGhaK0pjPX7ZcDlvKYbA+ulvVK3ztfcF4uBdOxuJbQ==}
+    requiresBuild: true
+    dependencies:
+      '@gar/promisify': 1.1.3
+      semver: 7.7.3
+    dev: false
+    optional: true
+
+  /@npmcli/move-file@1.1.2:
+    resolution: {integrity: sha512-1SUf/Cg2GzGDyaf15aR9St9TWlb+XvbZXWpDx8YKs7MLzMH/BCeopv+y9vzrzgkfykCGuWOlSu3mZhj2+FQcrg==}
+    engines: {node: '>=10'}
+    deprecated: This functionality has been moved to @npmcli/fs
+    requiresBuild: true
+    dependencies:
+      mkdirp: 1.0.4
+      rimraf: 3.0.2
+    dev: false
+    optional: true
+
+  /@petamoriken/float16@3.9.3:
+    resolution: {integrity: sha512-8awtpHXCx/bNpFt4mt2xdkgtgVvKqty8VbjHI/WWWQuEw+KLzFot3f4+LkQY9YmOtq7A5GdOnqoIC8Pdygjk2g==}
+    dev: false
+
+  /@pkgjs/parseargs@0.11.0:
+    resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
+    engines: {node: '>=14'}
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@pkgr/core@0.2.9:
+    resolution: {integrity: sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+    dev: true
+
+  /@sinclair/typebox@0.34.41:
+    resolution: {integrity: sha512-6gS8pZzSXdyRHTIqoqSVknxolr1kzfy4/CeDnrzsVz8TTIWUbOBr6gnzOmTYJ3eXQNh4IYHIGi5aIL7sOZ2G/g==}
+    dev: true
+
+  /@sinonjs/commons@3.0.1:
+    resolution: {integrity: sha512-K3mCHKQ9sVh8o1C9cxkwxaOmXoAMlDxC1mYyHrjqOWEcBjYr76t96zL2zlj5dUGZ3HSw240X1qgH3Mjf1yJWpQ==}
+    dependencies:
+      type-detect: 4.0.8
+    dev: true
+
+  /@sinonjs/fake-timers@13.0.5:
+    resolution: {integrity: sha512-36/hTbH2uaWuGVERyC6da9YwGWnzUZXuPro/F2LfsdOsLnCojz/iSH8MxUt/FD2S5XBSVPhmArFUXcpCQ2Hkiw==}
+    dependencies:
+      '@sinonjs/commons': 3.0.1
+    dev: true
+
+  /@tootallnate/once@1.1.2:
+    resolution: {integrity: sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==}
+    engines: {node: '>= 6'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /@tybys/wasm-util@0.10.1:
+    resolution: {integrity: sha512-9tTaPJLSiejZKx+Bmog4uSubteqTvFrVrURwkmHixBo0G4seD0zUxp98E1DzUBJxLQ3NPwXrGKDiVjwx/DpPsg==}
+    requiresBuild: true
+    dependencies:
+      tslib: 2.8.1
+    dev: true
+    optional: true
+
+  /@types/babel__core@7.20.5:
+    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
+    dependencies:
+      '@babel/parser': 7.28.4
+      '@babel/types': 7.28.4
+      '@types/babel__generator': 7.27.0
+      '@types/babel__template': 7.4.4
+      '@types/babel__traverse': 7.28.0
+    dev: true
+
+  /@types/babel__generator@7.27.0:
+    resolution: {integrity: sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==}
+    dependencies:
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@types/babel__template@7.4.4:
+    resolution: {integrity: sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==}
+    dependencies:
+      '@babel/parser': 7.28.4
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@types/babel__traverse@7.28.0:
+    resolution: {integrity: sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==}
+    dependencies:
+      '@babel/types': 7.28.4
+    dev: true
+
+  /@types/estree@1.0.8:
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+    dev: true
+
+  /@types/istanbul-lib-coverage@2.0.6:
+    resolution: {integrity: sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==}
+    dev: true
+
+  /@types/istanbul-lib-report@3.0.3:
+    resolution: {integrity: sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==}
+    dependencies:
+      '@types/istanbul-lib-coverage': 2.0.6
+    dev: true
+
+  /@types/istanbul-reports@3.0.4:
+    resolution: {integrity: sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==}
+    dependencies:
+      '@types/istanbul-lib-report': 3.0.3
+    dev: true
+
+  /@types/json-schema@7.0.15:
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+    dev: true
+
+  /@types/node@24.9.1:
+    resolution: {integrity: sha512-QoiaXANRkSXK6p0Duvt56W208du4P9Uye9hWLWgGMDTEoKPhuenzNcC4vGUmrNkiOKTlIrBoyNQYNpSwfEZXSg==}
+    dependencies:
+      undici-types: 7.16.0
+    dev: true
+
+  /@types/rbush@4.0.0:
+    resolution: {integrity: sha512-+N+2H39P8X+Hy1I5mC6awlTX54k3FhiUmvt7HWzGJZvF+syUAAxP/stwppS8JE84YHqFgRMv6fCy31202CMFxQ==}
+    dev: false
+
+  /@types/stack-utils@2.0.3:
+    resolution: {integrity: sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==}
+    dev: true
+
+  /@types/webidl-conversions@7.0.3:
+    resolution: {integrity: sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA==}
+    dev: false
+
+  /@types/whatwg-url@11.0.5:
+    resolution: {integrity: sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ==}
+    dependencies:
+      '@types/webidl-conversions': 7.0.3
+    dev: false
+
+  /@types/yargs-parser@21.0.3:
+    resolution: {integrity: sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==}
+    dev: true
+
+  /@types/yargs@17.0.33:
+    resolution: {integrity: sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==}
+    dependencies:
+      '@types/yargs-parser': 21.0.3
+    dev: true
+
+  /@ungap/structured-clone@1.3.0:
+    resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+    dev: true
+
+  /@unrs/resolver-binding-android-arm-eabi@1.11.1:
+    resolution: {integrity: sha512-ppLRUgHVaGRWUx0R0Ut06Mjo9gBaBkg3v/8AxusGLhsIotbBLuRk51rAzqLC8gq6NyyAojEXglNjzf6R948DNw==}
+    cpu: [arm]
+    os: [android]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-android-arm64@1.11.1:
+    resolution: {integrity: sha512-lCxkVtb4wp1v+EoN+HjIG9cIIzPkX5OtM03pQYkG+U5O/wL53LC4QbIeazgiKqluGeVEeBlZahHalCaBvU1a2g==}
+    cpu: [arm64]
+    os: [android]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-darwin-arm64@1.11.1:
+    resolution: {integrity: sha512-gPVA1UjRu1Y/IsB/dQEsp2V1pm44Of6+LWvbLc9SDk1c2KhhDRDBUkQCYVWe6f26uJb3fOK8saWMgtX8IrMk3g==}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-darwin-x64@1.11.1:
+    resolution: {integrity: sha512-cFzP7rWKd3lZaCsDze07QX1SC24lO8mPty9vdP+YVa3MGdVgPmFc59317b2ioXtgCMKGiCLxJ4HQs62oz6GfRQ==}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-freebsd-x64@1.11.1:
+    resolution: {integrity: sha512-fqtGgak3zX4DCB6PFpsH5+Kmt/8CIi4Bry4rb1ho6Av2QHTREM+47y282Uqiu3ZRF5IQioJQ5qWRV6jduA+iGw==}
+    cpu: [x64]
+    os: [freebsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-arm-gnueabihf@1.11.1:
+    resolution: {integrity: sha512-u92mvlcYtp9MRKmP+ZvMmtPN34+/3lMHlyMj7wXJDeXxuM0Vgzz0+PPJNsro1m3IZPYChIkn944wW8TYgGKFHw==}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-arm-musleabihf@1.11.1:
+    resolution: {integrity: sha512-cINaoY2z7LVCrfHkIcmvj7osTOtm6VVT16b5oQdS4beibX2SYBwgYLmqhBjA1t51CarSaBuX5YNsWLjsqfW5Cw==}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-arm64-gnu@1.11.1:
+    resolution: {integrity: sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-arm64-musl@1.11.1:
+    resolution: {integrity: sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-ppc64-gnu@1.11.1:
+    resolution: {integrity: sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==}
+    cpu: [ppc64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-riscv64-gnu@1.11.1:
+    resolution: {integrity: sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==}
+    cpu: [riscv64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-riscv64-musl@1.11.1:
+    resolution: {integrity: sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==}
+    cpu: [riscv64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-s390x-gnu@1.11.1:
+    resolution: {integrity: sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==}
+    cpu: [s390x]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-x64-gnu@1.11.1:
+    resolution: {integrity: sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-linux-x64-musl@1.11.1:
+    resolution: {integrity: sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-wasm32-wasi@1.11.1:
+    resolution: {integrity: sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+    requiresBuild: true
+    dependencies:
+      '@napi-rs/wasm-runtime': 0.2.12
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-win32-arm64-msvc@1.11.1:
+    resolution: {integrity: sha512-nRcz5Il4ln0kMhfL8S3hLkxI85BXs3o8EYoattsJNdsX4YUU89iOkVn7g0VHSRxFuVMdM4Q1jEpIId1Ihim/Uw==}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-win32-ia32-msvc@1.11.1:
+    resolution: {integrity: sha512-DCEI6t5i1NmAZp6pFonpD5m7i6aFrpofcp4LA2i8IIq60Jyo28hamKBxNrZcyOwVOZkgsRp9O2sXWBWP8MnvIQ==}
+    cpu: [ia32]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@unrs/resolver-binding-win32-x64-msvc@1.11.1:
+    resolution: {integrity: sha512-lrW200hZdbfRtztbygyaq/6jP6AKE8qQN2KvPcJ+x7wiD038YtnYtZ82IMNJ69GJibV7bwL3y9FgK+5w/pYt6g==}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /abbrev@1.1.1:
+    resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /accepts@2.0.0:
+    resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      mime-types: 3.0.1
+      negotiator: 1.0.0
+    dev: false
+
+  /acorn-jsx@5.3.2(acorn@8.15.0):
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+    dependencies:
+      acorn: 8.15.0
+    dev: true
+
+  /acorn@8.15.0:
+    resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+    dev: true
+
+  /agent-base@6.0.2:
+    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
+    engines: {node: '>= 6.0.0'}
+    requiresBuild: true
+    dependencies:
+      debug: 4.4.1(supports-color@5.5.0)
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+    optional: true
+
+  /agentkeepalive@4.6.0:
+    resolution: {integrity: sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==}
+    engines: {node: '>= 8.0.0'}
+    requiresBuild: true
+    dependencies:
+      humanize-ms: 1.2.1
+    dev: false
+    optional: true
+
+  /aggregate-error@3.1.0:
+    resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dependencies:
+      clean-stack: 2.2.0
+      indent-string: 4.0.0
+    dev: false
+    optional: true
+
+  /ajv@6.12.6:
+    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+    dev: true
+
+  /ansi-escapes@4.3.2:
+    resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      type-fest: 0.21.3
+    dev: true
+
+  /ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  /ansi-regex@6.2.2:
+    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+    dependencies:
+      color-convert: 2.0.1
+    dev: true
+
+  /ansi-styles@5.2.0:
+    resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /ansi-styles@6.2.3:
+    resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /anymatch@3.1.3:
+    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
+    engines: {node: '>= 8'}
+    dependencies:
+      normalize-path: 3.0.0
+      picomatch: 2.3.1
+    dev: true
+
+  /aproba@2.1.0:
+    resolution: {integrity: sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /are-we-there-yet@3.0.1:
+    resolution: {integrity: sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==}
+    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
+    deprecated: This package is no longer supported.
+    requiresBuild: true
+    dependencies:
+      delegates: 1.0.0
+      readable-stream: 3.6.2
+    dev: false
+    optional: true
+
+  /argparse@1.0.10:
+    resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==}
+    dependencies:
+      sprintf-js: 1.0.3
+    dev: true
+
+  /argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+    dev: true
+
+  /array-buffer-byte-length@1.0.2:
+    resolution: {integrity: sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      is-array-buffer: 3.0.5
+    dev: true
+
+  /array.prototype.reduce@1.0.8:
+    resolution: {integrity: sha512-DwuEqgXFBwbmZSRqt3BpQigWNUoqw9Ml2dTWdF3B2zQlQX4OeUE0zyuzX0fX0IbTvjdkZbcBTU3idgpO78qkTw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-abstract: 1.24.0
+      es-array-method-boxes-properly: 1.0.0
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      is-string: 1.1.1
+    dev: true
+
+  /arraybuffer.prototype.slice@1.0.4:
+    resolution: {integrity: sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      array-buffer-byte-length: 1.0.2
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.24.0
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      is-array-buffer: 3.0.5
+    dev: true
+
+  /async-function@1.0.0:
+    resolution: {integrity: sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /available-typed-arrays@1.0.7:
+    resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      possible-typed-array-names: 1.1.0
+    dev: true
+
+  /babel-jest@30.2.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-0YiBEOxWqKkSQWL9nNGGEgndoeL0ZpWrbLMNL5u/Kaxrli3Eaxlt3ZtIDktEvXt4L/R9r3ODr2zKwGM/2BjxVw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    peerDependencies:
+      '@babel/core': ^7.11.0 || ^8.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@jest/transform': 30.2.0
+      '@types/babel__core': 7.20.5
+      babel-plugin-istanbul: 7.0.1
+      babel-preset-jest: 30.2.0(@babel/core@7.28.4)
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      slash: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /babel-plugin-istanbul@7.0.1:
+    resolution: {integrity: sha512-D8Z6Qm8jCvVXtIRkBnqNHX0zJ37rQcFJ9u8WOS6tkYOsRdHBzypCstaxWiu5ZIlqQtviRYbgnRLSoCEvjqcqbA==}
+    engines: {node: '>=12'}
+    dependencies:
+      '@babel/helper-plugin-utils': 7.27.1
+      '@istanbuljs/load-nyc-config': 1.1.0
+      '@istanbuljs/schema': 0.1.3
+      istanbul-lib-instrument: 6.0.3
+      test-exclude: 6.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /babel-plugin-jest-hoist@30.2.0:
+    resolution: {integrity: sha512-ftzhzSGMUnOzcCXd6WHdBGMyuwy15Wnn0iyyWGKgBDLxf9/s5ABuraCSpBX2uG0jUg4rqJnxsLc5+oYBqoxVaA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@types/babel__core': 7.20.5
+    dev: true
+
+  /babel-plugin-polyfill-corejs2@0.4.14(@babel/core@7.28.4):
+    resolution: {integrity: sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+    dependencies:
+      '@babel/compat-data': 7.28.4
+      '@babel/core': 7.28.4
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.4)
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /babel-plugin-polyfill-corejs3@0.13.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.4)
+      core-js-compat: 3.46.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /babel-plugin-polyfill-regenerator@0.6.5(@babel/core@7.28.4):
+    resolution: {integrity: sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==}
+    peerDependencies:
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/helper-define-polyfill-provider': 0.6.5(@babel/core@7.28.4)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /babel-preset-current-node-syntax@1.2.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0 || ^8.0.0-0
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.28.4)
+      '@babel/plugin-syntax-bigint': 7.8.3(@babel/core@7.28.4)
+      '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.28.4)
+      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.28.4)
+      '@babel/plugin-syntax-import-attributes': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.28.4)
+      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.28.4)
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.28.4)
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.28.4)
+      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.28.4)
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.28.4)
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.28.4)
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.28.4)
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.28.4)
+      '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.28.4)
+    dev: true
+
+  /babel-preset-jest@30.2.0(@babel/core@7.28.4):
+    resolution: {integrity: sha512-US4Z3NOieAQumwFnYdUWKvUKh8+YSnS/gB3t6YBiz0bskpu7Pine8pPCheNxlPEW4wnUkma2a94YuW2q3guvCQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    peerDependencies:
+      '@babel/core': ^7.11.0 || ^8.0.0-beta.1
+    dependencies:
+      '@babel/core': 7.28.4
+      babel-plugin-jest-hoist: 30.2.0
+      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.28.4)
+    dev: true
+
+  /balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  /base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+    dev: false
+
+  /base64url@3.0.1:
+    resolution: {integrity: sha512-ir1UPr3dkwexU7FdV8qBBbNDRUhMmIekYMFZfi+C/sLNnRESKPl23nB9b2pltqfOQNnGzsDdId90AEtG5tCx4A==}
+    engines: {node: '>=6.0.0'}
+    dev: false
+
+  /baseline-browser-mapping@2.8.18:
+    resolution: {integrity: sha512-UYmTpOBwgPScZpS4A+YbapwWuBwasxvO/2IOHArSsAhL/+ZdmATBXTex3t+l2hXwLVYK382ibr/nKoY9GKe86w==}
+    hasBin: true
+    dev: true
+
+  /bcrypt@6.0.0:
+    resolution: {integrity: sha512-cU8v/EGSrnH+HnxV2z0J7/blxH8gq7Xh2JFT6Aroax7UohdmiJJlxApMxtKfuI7z68NvvVcmR78k2LbT6efhRg==}
+    engines: {node: '>= 18'}
+    requiresBuild: true
+    dependencies:
+      node-addon-api: 8.5.0
+      node-gyp-build: 4.8.4
+    dev: false
+
+  /binary-extensions@2.3.0:
+    resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dev: true
+
+  /bindings@1.5.0:
+    resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
+    dependencies:
+      file-uri-to-path: 1.0.0
+    dev: false
+
+  /bl@4.1.0:
+    resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
+    dependencies:
+      buffer: 5.7.1
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+    dev: false
+
+  /body-parser@2.2.0:
+    resolution: {integrity: sha512-02qvAaxv8tp7fBa/mw1ga98OGm+eCbqzJOKoRt70sLmfEEi+jyBYVTDGfCL/k06/4EMk/z01gCe7HoCH/f2LTg==}
+    engines: {node: '>=18'}
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.5
+      debug: 4.4.1(supports-color@5.5.0)
+      http-errors: 2.0.0
+      iconv-lite: 0.6.3
+      on-finished: 2.4.1
+      qs: 6.14.0
+      raw-body: 3.0.0
+      type-is: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /brace-expansion@1.1.12:
+    resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==}
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  /brace-expansion@2.0.2:
+    resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==}
+    dependencies:
+      balanced-match: 1.0.2
+    dev: true
+
+  /braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+    dependencies:
+      fill-range: 7.1.1
+    dev: true
+
+  /browserslist@4.26.3:
+    resolution: {integrity: sha512-lAUU+02RFBuCKQPj/P6NgjlbCnLBMp4UtgTx7vNHd3XSIJF87s9a5rA3aH2yw3GS9DqZAUbOtZdCCiZeVRqt0w==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+    dependencies:
+      baseline-browser-mapping: 2.8.18
+      caniuse-lite: 1.0.30001751
+      electron-to-chromium: 1.5.237
+      node-releases: 2.0.25
+      update-browserslist-db: 1.1.3(browserslist@4.26.3)
+    dev: true
+
+  /bser@2.1.1:
+    resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
+    dependencies:
+      node-int64: 0.4.0
+    dev: true
+
+  /bson@6.10.4:
+    resolution: {integrity: sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng==}
+    engines: {node: '>=16.20.1'}
+    dev: false
+
+  /buffer-equal-constant-time@1.0.1:
+    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
+    dev: false
+
+  /buffer-from@1.1.2:
+    resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
+    dev: true
+
+  /buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+    dev: false
+
+  /bytes@3.1.2:
+    resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /cacache@15.3.0:
+    resolution: {integrity: sha512-VVdYzXEn+cnbXpFgWs5hTT7OScegHVmLhJIR8Ufqk3iFD6A6j5iSX1KuBTfNEv4tdJWE2PzA6IVFtcLC7fN9wQ==}
+    engines: {node: '>= 10'}
+    requiresBuild: true
+    dependencies:
+      '@npmcli/fs': 1.1.1
+      '@npmcli/move-file': 1.1.2
+      chownr: 2.0.0
+      fs-minipass: 2.1.0
+      glob: 7.2.3
+      infer-owner: 1.0.4
+      lru-cache: 6.0.0
+      minipass: 3.3.6
+      minipass-collect: 1.0.2
+      minipass-flush: 1.0.5
+      minipass-pipeline: 1.2.4
+      mkdirp: 1.0.4
+      p-map: 4.0.0
+      promise-inflight: 1.0.1
+      rimraf: 3.0.2
+      ssri: 8.0.1
+      tar: 6.2.1
+      unique-filename: 1.1.1
+    transitivePeerDependencies:
+      - bluebird
+    dev: false
+    optional: true
+
+  /call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  /call-bind@1.0.8:
+    resolution: {integrity: sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      get-intrinsic: 1.3.0
+      set-function-length: 1.2.2
+    dev: true
+
+  /call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
+  /callsites@3.1.0:
+    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /camelcase@5.3.1:
+    resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /camelcase@6.3.0:
+    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /caniuse-lite@1.0.30001751:
+    resolution: {integrity: sha512-A0QJhug0Ly64Ii3eIqHu5X51ebln3k4yTUkY1j8drqpWHVreg/VLijN48cZ1bYPiqOQuqpkIKnzr/Ul8V+p6Cw==}
+    dev: true
+
+  /chalk@4.1.2:
+    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-styles: 4.3.0
+      supports-color: 7.2.0
+    dev: true
+
+  /char-regex@1.0.2:
+    resolution: {integrity: sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /chokidar@3.6.0:
+    resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==}
+    engines: {node: '>= 8.10.0'}
+    dependencies:
+      anymatch: 3.1.3
+      braces: 3.0.3
+      glob-parent: 5.1.2
+      is-binary-path: 2.1.0
+      is-glob: 4.0.3
+      normalize-path: 3.0.0
+      readdirp: 3.6.0
+    optionalDependencies:
+      fsevents: 2.3.3
+    dev: true
+
+  /chownr@1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+    dev: false
+
+  /chownr@2.0.0:
+    resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
+    engines: {node: '>=10'}
+    dev: false
+
+  /ci-info@4.3.1:
+    resolution: {integrity: sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /cjs-module-lexer@2.1.0:
+    resolution: {integrity: sha512-UX0OwmYRYQQetfrLEZeewIFFI+wSTofC+pMBLNuH3RUuu/xzG1oz84UCEDOSoQlN3fZ4+AzmV50ZYvGqkMh9yA==}
+    dev: true
+
+  /clean-stack@2.2.0:
+    resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==}
+    engines: {node: '>=6'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /cliui@8.0.1:
+    resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      wrap-ansi: 7.0.0
+    dev: true
+
+  /clone-deep@4.0.1:
+    resolution: {integrity: sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      is-plain-object: 2.0.4
+      kind-of: 6.0.3
+      shallow-clone: 3.0.1
+    dev: true
+
+  /co@4.6.0:
+    resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==}
+    engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'}
+    dev: true
+
+  /collect-v8-coverage@1.0.3:
+    resolution: {integrity: sha512-1L5aqIkwPfiodaMgQunkF1zRhNqifHBmtbbbxcr6yVxxBnliw4TDOW6NxpO8DJLgJ16OT+Y4ztZqP6p/FtXnAw==}
+    dev: true
+
+  /color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+    dependencies:
+      color-name: 1.1.4
+    dev: true
+
+  /color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+    dev: true
+
+  /color-support@1.1.3:
+    resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==}
+    hasBin: true
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /commander@6.2.1:
+    resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==}
+    engines: {node: '>= 6'}
+    dev: true
+
+  /commondir@1.0.1:
+    resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
+    dev: true
+
+  /concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  /connect-sqlite3@0.9.16:
+    resolution: {integrity: sha512-2gqo0QmcBBL8p8+eqpBETn7RgM/PaoKvpQGl8PfjEgwlr0VuMYNMxRJRrRCo3KR3fxMYeSsCw2tGNG0JKN9Nvg==}
+    engines: {node: '>=0.4.x'}
+    dependencies:
+      sqlite3: 5.1.7
+    transitivePeerDependencies:
+      - bluebird
+      - supports-color
+    dev: false
+
+  /console-control-strings@1.1.0:
+    resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /content-disposition@1.0.0:
+    resolution: {integrity: sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: false
+
+  /content-type@1.0.5:
+    resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+    dev: true
+
+  /cookie-signature@1.0.7:
+    resolution: {integrity: sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==}
+    dev: false
+
+  /cookie-signature@1.2.2:
+    resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}
+    engines: {node: '>=6.6.0'}
+    dev: false
+
+  /cookie@0.7.2:
+    resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /core-js-compat@3.46.0:
+    resolution: {integrity: sha512-p9hObIIEENxSV8xIu+V68JjSeARg6UVMG5mR+JEUguG3sI6MsiS1njz2jHmyJDvA+8jX/sytkBHup6kxhM9law==}
+    dependencies:
+      browserslist: 4.26.3
+    dev: true
+
+  /core-js@3.46.0:
+    resolution: {integrity: sha512-vDMm9B0xnqqZ8uSBpZ8sNtRtOdmfShrvT6h2TuQGLs0Is+cR0DYbj/KWP6ALVNbWPpqA/qPLoOuppJN07humpA==}
+    requiresBuild: true
+
+  /cors@2.8.5:
+    resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==}
+    engines: {node: '>= 0.10'}
+    dependencies:
+      object-assign: 4.1.1
+      vary: 1.1.2
+    dev: false
+
+  /cross-spawn@7.0.6:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+    dev: true
+
+  /data-view-buffer@1.0.2:
+    resolution: {integrity: sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+    dev: true
+
+  /data-view-byte-length@1.0.2:
+    resolution: {integrity: sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+    dev: true
+
+  /data-view-byte-offset@1.0.1:
+    resolution: {integrity: sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-data-view: 1.0.2
+    dev: true
+
+  /debug@2.6.9:
+    resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.0.0
+    dev: false
+
+  /debug@4.4.1(supports-color@5.5.0):
+    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+    dependencies:
+      ms: 2.1.3
+      supports-color: 5.5.0
+
+  /decompress-response@6.0.0:
+    resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      mimic-response: 3.1.0
+    dev: false
+
+  /dedent@1.7.0:
+    resolution: {integrity: sha512-HGFtf8yhuhGhqO07SV79tRp+br4MnbdjeVxotpn1QBl30pcLLCQjX5b2295ll0fv8RKDKsmWYrl05usHM9CewQ==}
+    peerDependencies:
+      babel-plugin-macros: ^3.1.0
+    peerDependenciesMeta:
+      babel-plugin-macros:
+        optional: true
+    dev: true
+
+  /deep-equal@0.0.0:
+    resolution: {integrity: sha512-p1bI/kkDPT6auUI0U+WLuIIrzmDIDo80I406J8tT4y6I4ZGtBuMeTudrKDtBdMJFAcxqrQdx27gosqPVyY3IvQ==}
+    dev: false
+
+  /deep-extend@0.6.0:
+    resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
+    engines: {node: '>=4.0.0'}
+    dev: false
+
+  /deep-is@0.1.4:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+    dev: true
+
+  /deepmerge@4.3.1:
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /define-data-property@1.1.4:
+    resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      gopd: 1.2.0
+    dev: true
+
+  /define-properties@1.2.1:
+    resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      define-data-property: 1.1.4
+      has-property-descriptors: 1.0.2
+      object-keys: 1.1.1
+    dev: true
+
+  /defined@0.0.0:
+    resolution: {integrity: sha512-zpqiCT8bODLu3QSmLLic8xJnYWBFjOSu/fBCm189oAiTtPq/PSanNACKZDS7kgSyCJY7P+IcODzlIogBK/9RBg==}
+    dev: false
+
+  /delegates@1.0.0:
+    resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /depd@2.0.0:
+    resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+    dev: false
+
+  /detect-newline@3.1.0:
+    resolution: {integrity: sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  /earcut@3.0.2:
+    resolution: {integrity: sha512-X7hshQbLyMJ/3RPhyObLARM2sNxxmRALLKx1+NVFFnQ9gKzmCrxm9+uLIAdBcvc8FNLpctqlQ2V6AE92Ol9UDQ==}
+    dev: false
+
+  /eastasianwidth@0.2.0:
+    resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
+    dev: true
+
+  /ecdsa-sig-formatter@1.0.11:
+    resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: false
+
+  /ee-first@1.1.1:
+    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
+    dev: false
+
+  /electron-to-chromium@1.5.237:
+    resolution: {integrity: sha512-icUt1NvfhGLar5lSWH3tHNzablaA5js3HVHacQimfP8ViEBOQv+L7DKEuHdbTZ0SKCO1ogTJTIL1Gwk9S6Qvcg==}
+    dev: true
+
+  /emittery@0.13.1:
+    resolution: {integrity: sha512-DeWwawk6r5yR9jFgnDKYt4sLS0LmHJJi3ZOnb5/JdbYwj3nW+FxQnHIjhBKz8YLC7oRNPVM9NQ47I3CVx34eqQ==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  /emoji-regex@9.2.2:
+    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}
+    dev: true
+
+  /encodeurl@2.0.0:
+    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /encoding@0.1.13:
+    resolution: {integrity: sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==}
+    requiresBuild: true
+    dependencies:
+      iconv-lite: 0.6.3
+    dev: false
+    optional: true
+
+  /end-of-stream@1.4.5:
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
+    dependencies:
+      once: 1.4.0
+    dev: false
+
+  /env-paths@2.2.1:
+    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
+    engines: {node: '>=6'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /err-code@2.0.3:
+    resolution: {integrity: sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /error-ex@1.3.4:
+    resolution: {integrity: sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==}
+    dependencies:
+      is-arrayish: 0.2.1
+    dev: true
+
+  /es-abstract@1.24.0:
+    resolution: {integrity: sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      array-buffer-byte-length: 1.0.2
+      arraybuffer.prototype.slice: 1.0.4
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      data-view-buffer: 1.0.2
+      data-view-byte-length: 1.0.2
+      data-view-byte-offset: 1.0.1
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      es-set-tostringtag: 2.1.0
+      es-to-primitive: 1.3.0
+      function.prototype.name: 1.1.8
+      get-intrinsic: 1.3.0
+      get-proto: 1.0.1
+      get-symbol-description: 1.1.0
+      globalthis: 1.0.4
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+      has-proto: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      internal-slot: 1.1.0
+      is-array-buffer: 3.0.5
+      is-callable: 1.2.7
+      is-data-view: 1.0.2
+      is-negative-zero: 2.0.3
+      is-regex: 1.2.1
+      is-set: 2.0.3
+      is-shared-array-buffer: 1.0.4
+      is-string: 1.1.1
+      is-typed-array: 1.1.15
+      is-weakref: 1.1.1
+      math-intrinsics: 1.1.0
+      object-inspect: 1.13.4
+      object-keys: 1.1.1
+      object.assign: 4.1.7
+      own-keys: 1.0.1
+      regexp.prototype.flags: 1.5.4
+      safe-array-concat: 1.1.3
+      safe-push-apply: 1.0.0
+      safe-regex-test: 1.1.0
+      set-proto: 1.0.0
+      stop-iteration-iterator: 1.1.0
+      string.prototype.trim: 1.2.10
+      string.prototype.trimend: 1.0.9
+      string.prototype.trimstart: 1.0.8
+      typed-array-buffer: 1.0.3
+      typed-array-byte-length: 1.0.3
+      typed-array-byte-offset: 1.0.4
+      typed-array-length: 1.0.7
+      unbox-primitive: 1.1.0
+      which-typed-array: 1.1.19
+    dev: true
+
+  /es-array-method-boxes-properly@1.0.0:
+    resolution: {integrity: sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==}
+    dev: true
+
+  /es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  /es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  /es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+
+  /es-set-tostringtag@2.1.0:
+    resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+    dev: true
+
+  /es-to-primitive@1.3.0:
+    resolution: {integrity: sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      is-callable: 1.2.7
+      is-date-object: 1.1.0
+      is-symbol: 1.1.1
+    dev: true
+
+  /escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /escape-html@1.0.3:
+    resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
+    dev: false
+
+  /escape-string-regexp@2.0.0:
+    resolution: {integrity: sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /escape-string-regexp@4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /eslint-scope@8.4.0:
+    resolution: {integrity: sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+    dev: true
+
+  /eslint-visitor-keys@3.4.3:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    dev: true
+
+  /eslint-visitor-keys@4.2.1:
+    resolution: {integrity: sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dev: true
+
+  /eslint@9.38.0:
+    resolution: {integrity: sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.0(eslint@9.38.0)
+      '@eslint-community/regexpp': 4.12.1
+      '@eslint/config-array': 0.21.1
+      '@eslint/config-helpers': 0.4.1
+      '@eslint/core': 0.16.0
+      '@eslint/eslintrc': 3.3.1
+      '@eslint/js': 9.38.0
+      '@eslint/plugin-kit': 0.4.0
+      '@humanfs/node': 0.16.7
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.3
+      '@types/estree': 1.0.8
+      ajv: 6.12.6
+      chalk: 4.1.2
+      cross-spawn: 7.0.6
+      debug: 4.4.1(supports-color@5.5.0)
+      escape-string-regexp: 4.0.0
+      eslint-scope: 8.4.0
+      eslint-visitor-keys: 4.2.1
+      espree: 10.4.0
+      esquery: 1.6.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /espree@10.4.0:
+    resolution: {integrity: sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    dependencies:
+      acorn: 8.15.0
+      acorn-jsx: 5.3.2(acorn@8.15.0)
+      eslint-visitor-keys: 4.2.1
+    dev: true
+
+  /esprima@4.0.1:
+    resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
+    engines: {node: '>=4'}
+    hasBin: true
+    dev: true
+
+  /esquery@1.6.0:
+    resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==}
+    engines: {node: '>=0.10'}
+    dependencies:
+      estraverse: 5.3.0
+    dev: true
+
+  /esrecurse@4.3.0:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+    dependencies:
+      estraverse: 5.3.0
+    dev: true
+
+  /estraverse@5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+    dev: true
+
+  /esutils@2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /etag@1.8.1:
+    resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /execa@5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 6.0.1
+      human-signals: 2.1.0
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+    dev: true
+
+  /exit-x@0.2.2:
+    resolution: {integrity: sha512-+I6B/IkJc1o/2tiURyz/ivu/O0nKNEArIUB5O7zBrlDVJr22SCLH3xTeEry428LvFhRzIA1g8izguxJ/gbNcVQ==}
+    engines: {node: '>= 0.8.0'}
+    dev: true
+
+  /expand-template@2.0.3:
+    resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
+    engines: {node: '>=6'}
+    dev: false
+
+  /expect@30.2.0:
+    resolution: {integrity: sha512-u/feCi0GPsI+988gU2FLcsHyAHTU0MX1Wg68NhAnN7z/+C5wqG+CY8J53N9ioe8RXgaoz0nBR/TYMf3AycUuPw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/expect-utils': 30.2.0
+      '@jest/get-type': 30.1.0
+      jest-matcher-utils: 30.2.0
+      jest-message-util: 30.2.0
+      jest-mock: 30.2.0
+      jest-util: 30.2.0
+    dev: true
+
+  /express-session@1.18.2:
+    resolution: {integrity: sha512-SZjssGQC7TzTs9rpPDuUrR23GNZ9+2+IkA/+IJWmvQilTr5OSliEHGF+D9scbIpdC6yGtTI0/VhaHoVes2AN/A==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      cookie: 0.7.2
+      cookie-signature: 1.0.7
+      debug: 2.6.9
+      depd: 2.0.0
+      on-headers: 1.1.0
+      parseurl: 1.3.3
+      safe-buffer: 5.2.1
+      uid-safe: 2.1.5
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /express@5.1.0:
+    resolution: {integrity: sha512-DT9ck5YIRU+8GYzzU5kT3eHGA5iL+1Zd0EutOmTE9Dtk+Tvuzd23VBU+ec7HPNSTxXYO55gPV/hq4pSBJDjFpA==}
+    engines: {node: '>= 18'}
+    dependencies:
+      accepts: 2.0.0
+      body-parser: 2.2.0
+      content-disposition: 1.0.0
+      content-type: 1.0.5
+      cookie: 0.7.2
+      cookie-signature: 1.2.2
+      debug: 4.4.1(supports-color@5.5.0)
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 2.1.0
+      fresh: 2.0.0
+      http-errors: 2.0.0
+      merge-descriptors: 2.0.0
+      mime-types: 3.0.1
+      on-finished: 2.4.1
+      once: 1.4.0
+      parseurl: 1.3.3
+      proxy-addr: 2.0.7
+      qs: 6.14.0
+      range-parser: 1.2.1
+      router: 2.2.0
+      send: 1.2.0
+      serve-static: 2.2.0
+      statuses: 2.0.2
+      type-is: 2.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /fast-deep-equal@3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+    dev: true
+
+  /fast-json-stable-stringify@2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+    dev: true
+
+  /fast-levenshtein@2.0.6:
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+    dev: true
+
+  /fb-watchman@2.0.2:
+    resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==}
+    dependencies:
+      bser: 2.1.1
+    dev: true
+
+  /file-entry-cache@8.0.0:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+    dependencies:
+      flat-cache: 4.0.1
+    dev: true
+
+  /file-uri-to-path@1.0.0:
+    resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
+    dev: false
+
+  /fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dependencies:
+      to-regex-range: 5.0.1
+    dev: true
+
+  /finalhandler@2.1.0:
+    resolution: {integrity: sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      debug: 4.4.1(supports-color@5.5.0)
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      statuses: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /find-cache-dir@2.1.0:
+    resolution: {integrity: sha512-Tq6PixE0w/VMFfCgbONnkiQIVol/JJL7nRMi20fqzA4NRs9AfeqMGeRdPi3wIhYkxjeBaWh2rxwapn5Tu3IqOQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      commondir: 1.0.1
+      make-dir: 2.1.0
+      pkg-dir: 3.0.0
+    dev: true
+
+  /find-up@3.0.0:
+    resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==}
+    engines: {node: '>=6'}
+    dependencies:
+      locate-path: 3.0.0
+    dev: true
+
+  /find-up@4.1.0:
+    resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==}
+    engines: {node: '>=8'}
+    dependencies:
+      locate-path: 5.0.0
+      path-exists: 4.0.0
+    dev: true
+
+  /find-up@5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+    dev: true
+
+  /flat-cache@4.0.1:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+    dependencies:
+      flatted: 3.3.3
+      keyv: 4.5.4
+    dev: true
+
+  /flatted@3.3.3:
+    resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==}
+    dev: true
+
+  /for-each@0.3.5:
+    resolution: {integrity: sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      is-callable: 1.2.7
+    dev: true
+
+  /foreground-child@3.3.1:
+    resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
+    engines: {node: '>=14'}
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+    dev: true
+
+  /forwarded@0.2.0:
+    resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /fresh@2.0.0:
+    resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /fs-constants@1.0.0:
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
+    dev: false
+
+  /fs-minipass@2.1.0:
+    resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
+    engines: {node: '>= 8'}
+    dependencies:
+      minipass: 3.3.6
+    dev: false
+
+  /fs-readdir-recursive@1.1.0:
+    resolution: {integrity: sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==}
+    dev: true
+
+  /fs.realpath@1.0.0:
+    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
+
+  /fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  /function.prototype.name@1.1.8:
+    resolution: {integrity: sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      functions-have-names: 1.2.3
+      hasown: 2.0.2
+      is-callable: 1.2.7
+    dev: true
+
+  /functions-have-names@1.2.3:
+    resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
+    dev: true
+
+  /gauge@4.0.4:
+    resolution: {integrity: sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==}
+    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
+    deprecated: This package is no longer supported.
+    requiresBuild: true
+    dependencies:
+      aproba: 2.1.0
+      color-support: 1.1.3
+      console-control-strings: 1.1.0
+      has-unicode: 2.0.1
+      signal-exit: 3.0.7
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      wide-align: 1.1.5
+    dev: false
+    optional: true
+
+  /generator-function@2.0.1:
+    resolution: {integrity: sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /gensync@1.0.0-beta.2:
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
+    dev: true
+
+  /geotiff@2.1.3:
+    resolution: {integrity: sha512-PT6uoF5a1+kbC3tHmZSUsLHBp2QJlHasxxxxPW47QIY1VBKpFB+FcDvX+MxER6UzgLQZ0xDzJ9s48B9JbOCTqA==}
+    engines: {node: '>=10.19'}
+    dependencies:
+      '@petamoriken/float16': 3.9.3
+      lerc: 3.0.0
+      pako: 2.1.0
+      parse-headers: 2.0.6
+      quick-lru: 6.1.2
+      web-worker: 1.5.0
+      xml-utils: 1.10.2
+      zstddec: 0.1.0
+    dev: false
+
+  /get-caller-file@2.0.5:
+    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
+    engines: {node: 6.* || 8.* || >= 10.*}
+    dev: true
+
+  /get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.2
+      math-intrinsics: 1.1.0
+
+  /get-package-type@0.1.0:
+    resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==}
+    engines: {node: '>=8.0.0'}
+    dev: true
+
+  /get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.1
+
+  /get-stream@6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /get-symbol-description@1.1.0:
+    resolution: {integrity: sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+    dev: true
+
+  /github-from-package@0.0.0:
+    resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
+    dev: false
+
+  /glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+    requiresBuild: true
+    dependencies:
+      is-glob: 4.0.3
+    dev: true
+
+  /glob-parent@6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+    dependencies:
+      is-glob: 4.0.3
+    dev: true
+
+  /glob@10.4.5:
+    resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==}
+    hasBin: true
+    dependencies:
+      foreground-child: 3.3.1
+      jackspeak: 3.4.3
+      minimatch: 9.0.5
+      minipass: 7.1.2
+      package-json-from-dist: 1.0.1
+      path-scurry: 1.11.1
+    dev: true
+
+  /glob@7.2.3:
+    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
+    deprecated: Glob versions prior to v9 are no longer supported
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.2
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+
+  /global@2.0.7:
+    resolution: {integrity: sha512-uyLyozYI1KDVqDUaEPM/9qdQKtNRxmRXiZ6ENCCID6miO+TnXAVopshc0ym/KJTTK6lH3STKRdP3Vtmyl02n9w==}
+    dependencies:
+      min-document: 0.2.8
+      process: 0.5.2
+    dev: false
+
+  /globals@14.0.0:
+    resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
+    engines: {node: '>=18'}
+    dev: true
+
+  /globalthis@1.0.4:
+    resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      define-properties: 1.2.1
+      gopd: 1.2.0
+    dev: true
+
+  /gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  /graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  /has-bigints@1.1.0:
+    resolution: {integrity: sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /has-flag@3.0.0:
+    resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==}
+    engines: {node: '>=4'}
+
+  /has-flag@4.0.0:
+    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /has-property-descriptors@1.0.2:
+    resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==}
+    dependencies:
+      es-define-property: 1.0.1
+    dev: true
+
+  /has-proto@1.2.0:
+    resolution: {integrity: sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      dunder-proto: 1.0.1
+    dev: true
+
+  /has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  /has-tostringtag@1.0.2:
+    resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      has-symbols: 1.1.0
+    dev: true
+
+  /has-unicode@2.0.1:
+    resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /hasown@2.0.2:
+    resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      function-bind: 1.1.2
+
+  /homedir-polyfill@1.0.3:
+    resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      parse-passwd: 1.0.0
+    dev: true
+
+  /html-escaper@2.0.2:
+    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}
+    dev: true
+
+  /http-cache-semantics@4.2.0:
+    resolution: {integrity: sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /http-errors@2.0.0:
+    resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.1
+      toidentifier: 1.0.1
+    dev: false
+
+  /http-proxy-agent@4.0.1:
+    resolution: {integrity: sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==}
+    engines: {node: '>= 6'}
+    requiresBuild: true
+    dependencies:
+      '@tootallnate/once': 1.1.2
+      agent-base: 6.0.2
+      debug: 4.4.1(supports-color@5.5.0)
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+    optional: true
+
+  /https-proxy-agent@5.0.1:
+    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
+    engines: {node: '>= 6'}
+    requiresBuild: true
+    dependencies:
+      agent-base: 6.0.2
+      debug: 4.4.1(supports-color@5.5.0)
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+    optional: true
+
+  /human-signals@2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+    dev: true
+
+  /humanize-ms@1.2.1:
+    resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
+    requiresBuild: true
+    dependencies:
+      ms: 2.1.3
+    dev: false
+    optional: true
+
+  /iconv-lite@0.6.3:
+    resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      safer-buffer: 2.1.2
+    dev: false
+
+  /ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+    dev: false
+
+  /ignore-by-default@1.0.1:
+    resolution: {integrity: sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==}
+    dev: true
+
+  /ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+    dev: true
+
+  /immediate@3.0.6:
+    resolution: {integrity: sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==}
+    dev: false
+
+  /import-fresh@3.3.1:
+    resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      parent-module: 1.0.1
+      resolve-from: 4.0.0
+    dev: true
+
+  /import-local@3.2.0:
+    resolution: {integrity: sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==}
+    engines: {node: '>=8'}
+    hasBin: true
+    dependencies:
+      pkg-dir: 4.2.0
+      resolve-cwd: 3.0.0
+    dev: true
+
+  /imurmurhash@0.1.4:
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
+
+  /indent-string@4.0.0:
+    resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /infer-owner@1.0.4:
+    resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /inflight@1.0.6:
+    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
+    deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
+    dependencies:
+      once: 1.4.0
+      wrappy: 1.0.2
+
+  /inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  /ini@1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+    dev: false
+
+  /internal-slot@1.1.0:
+    resolution: {integrity: sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      hasown: 2.0.2
+      side-channel: 1.1.0
+    dev: true
+
+  /ip-address@10.0.1:
+    resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==}
+    engines: {node: '>= 12'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /ipaddr.js@1.9.1:
+    resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
+    engines: {node: '>= 0.10'}
+    dev: false
+
+  /is-array-buffer@3.0.5:
+    resolution: {integrity: sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+    dev: true
+
+  /is-arrayish@0.2.1:
+    resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==}
+    dev: true
+
+  /is-async-function@2.1.1:
+    resolution: {integrity: sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      async-function: 1.0.0
+      call-bound: 1.0.4
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+    dev: true
+
+  /is-bigint@1.1.0:
+    resolution: {integrity: sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      has-bigints: 1.1.0
+    dev: true
+
+  /is-binary-path@2.1.0:
+    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dependencies:
+      binary-extensions: 2.3.0
+    dev: true
+
+  /is-boolean-object@1.2.2:
+    resolution: {integrity: sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+    dev: true
+
+  /is-callable@1.2.7:
+    resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /is-core-module@2.16.1:
+    resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      hasown: 2.0.2
+    dev: true
+
+  /is-data-view@1.0.2:
+    resolution: {integrity: sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+      is-typed-array: 1.1.15
+    dev: true
+
+  /is-date-object@1.1.0:
+    resolution: {integrity: sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+    dev: true
+
+  /is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /is-finalizationregistry@1.1.1:
+    resolution: {integrity: sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+    dev: true
+
+  /is-fullwidth-code-point@3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+
+  /is-generator-fn@2.1.0:
+    resolution: {integrity: sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /is-generator-function@1.1.2:
+    resolution: {integrity: sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      generator-function: 2.0.1
+      get-proto: 1.0.1
+      has-tostringtag: 1.0.2
+      safe-regex-test: 1.1.0
+    dev: true
+
+  /is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      is-extglob: 2.1.1
+    dev: true
+
+  /is-lambda@1.0.1:
+    resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /is-map@2.0.3:
+    resolution: {integrity: sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /is-negative-zero@2.0.3:
+    resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /is-number-object@1.1.1:
+    resolution: {integrity: sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+    dev: true
+
+  /is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+    requiresBuild: true
+    dev: true
+
+  /is-plain-object@2.0.4:
+    resolution: {integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==}
+    engines: {node: '>=0.10.0'}
+    dependencies:
+      isobject: 3.0.1
+    dev: true
+
+  /is-promise@4.0.0:
+    resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
+    dev: false
+
+  /is-regex@1.2.1:
+    resolution: {integrity: sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+      hasown: 2.0.2
+    dev: true
+
+  /is-set@2.0.3:
+    resolution: {integrity: sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /is-shared-array-buffer@1.0.4:
+    resolution: {integrity: sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+    dev: true
+
+  /is-stream@2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /is-string@1.1.1:
+    resolution: {integrity: sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      has-tostringtag: 1.0.2
+    dev: true
+
+  /is-symbol@1.1.1:
+    resolution: {integrity: sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      has-symbols: 1.1.0
+      safe-regex-test: 1.1.0
+    dev: true
+
+  /is-typed-array@1.1.15:
+    resolution: {integrity: sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      which-typed-array: 1.1.19
+    dev: true
+
+  /is-weakmap@2.0.2:
+    resolution: {integrity: sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /is-weakref@1.1.1:
+    resolution: {integrity: sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+    dev: true
+
+  /is-weakset@2.0.4:
+    resolution: {integrity: sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+    dev: true
+
+  /isarray@2.0.5:
+    resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
+    dev: true
+
+  /isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  /isobject@3.0.1:
+    resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /istanbul-lib-coverage@3.2.2:
+    resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /istanbul-lib-instrument@6.0.3:
+    resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/parser': 7.28.4
+      '@istanbuljs/schema': 0.1.3
+      istanbul-lib-coverage: 3.2.2
+      semver: 7.7.3
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /istanbul-lib-report@3.0.1:
+    resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==}
+    engines: {node: '>=10'}
+    dependencies:
+      istanbul-lib-coverage: 3.2.2
+      make-dir: 4.0.0
+      supports-color: 7.2.0
+    dev: true
+
+  /istanbul-lib-source-maps@5.0.6:
+    resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      debug: 4.4.1(supports-color@5.5.0)
+      istanbul-lib-coverage: 3.2.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /istanbul-reports@3.2.0:
+    resolution: {integrity: sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==}
+    engines: {node: '>=8'}
+    dependencies:
+      html-escaper: 2.0.2
+      istanbul-lib-report: 3.0.1
+    dev: true
+
+  /jackspeak@3.4.3:
+    resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==}
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+    optionalDependencies:
+      '@pkgjs/parseargs': 0.11.0
+    dev: true
+
+  /jest-changed-files@30.2.0:
+    resolution: {integrity: sha512-L8lR1ChrRnSdfeOvTrwZMlnWV8G/LLjQ0nG9MBclwWZidA2N5FviRki0Bvh20WRMOX31/JYvzdqTJrk5oBdydQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      execa: 5.1.1
+      jest-util: 30.2.0
+      p-limit: 3.1.0
+    dev: true
+
+  /jest-circus@30.2.0:
+    resolution: {integrity: sha512-Fh0096NC3ZkFx05EP2OXCxJAREVxj1BcW/i6EWqqymcgYKWjyyDpral3fMxVcHXg6oZM7iULer9wGRFvfpl+Tg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/environment': 30.2.0
+      '@jest/expect': 30.2.0
+      '@jest/test-result': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      chalk: 4.1.2
+      co: 4.6.0
+      dedent: 1.7.0
+      is-generator-fn: 2.1.0
+      jest-each: 30.2.0
+      jest-matcher-utils: 30.2.0
+      jest-message-util: 30.2.0
+      jest-runtime: 30.2.0
+      jest-snapshot: 30.2.0
+      jest-util: 30.2.0
+      p-limit: 3.1.0
+      pretty-format: 30.2.0
+      pure-rand: 7.0.1
+      slash: 3.0.0
+      stack-utils: 2.0.6
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - supports-color
+    dev: true
+
+  /jest-cli@30.2.0:
+    resolution: {integrity: sha512-Os9ukIvADX/A9sLt6Zse3+nmHtHaE6hqOsjQtNiugFTbKRHYIYtZXNGNK9NChseXy7djFPjndX1tL0sCTlfpAA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@jest/core': 30.2.0
+      '@jest/test-result': 30.2.0
+      '@jest/types': 30.2.0
+      chalk: 4.1.2
+      exit-x: 0.2.2
+      import-local: 3.2.0
+      jest-config: 30.2.0(@types/node@24.9.1)
+      jest-util: 30.2.0
+      jest-validate: 30.2.0
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - '@types/node'
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    dev: true
+
+  /jest-config@30.2.0(@types/node@24.9.1):
+    resolution: {integrity: sha512-g4WkyzFQVWHtu6uqGmQR4CQxz/CH3yDSlhzXMWzNjDx843gYjReZnMRanjRCq5XZFuQrGDxgUaiYWE8BRfVckA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    peerDependencies:
+      '@types/node': '*'
+      esbuild-register: '>=3.4.0'
+      ts-node: '>=9.0.0'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      esbuild-register:
+        optional: true
+      ts-node:
+        optional: true
+    dependencies:
+      '@babel/core': 7.28.4
+      '@jest/get-type': 30.1.0
+      '@jest/pattern': 30.0.1
+      '@jest/test-sequencer': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      babel-jest: 30.2.0(@babel/core@7.28.4)
+      chalk: 4.1.2
+      ci-info: 4.3.1
+      deepmerge: 4.3.1
+      glob: 10.4.5
+      graceful-fs: 4.2.11
+      jest-circus: 30.2.0
+      jest-docblock: 30.2.0
+      jest-environment-node: 30.2.0
+      jest-regex-util: 30.0.1
+      jest-resolve: 30.2.0
+      jest-runner: 30.2.0
+      jest-util: 30.2.0
+      jest-validate: 30.2.0
+      micromatch: 4.0.8
+      parse-json: 5.2.0
+      pretty-format: 30.2.0
+      slash: 3.0.0
+      strip-json-comments: 3.1.1
+    transitivePeerDependencies:
+      - babel-plugin-macros
+      - supports-color
+    dev: true
+
+  /jest-diff@30.2.0:
+    resolution: {integrity: sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/diff-sequences': 30.0.1
+      '@jest/get-type': 30.1.0
+      chalk: 4.1.2
+      pretty-format: 30.2.0
+    dev: true
+
+  /jest-docblock@30.2.0:
+    resolution: {integrity: sha512-tR/FFgZKS1CXluOQzZvNH3+0z9jXr3ldGSD8bhyuxvlVUwbeLOGynkunvlTMxchC5urrKndYiwCFC0DLVjpOCA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      detect-newline: 3.1.0
+    dev: true
+
+  /jest-each@30.2.0:
+    resolution: {integrity: sha512-lpWlJlM7bCUf1mfmuqTA8+j2lNURW9eNafOy99knBM01i5CQeY5UH1vZjgT9071nDJac1M4XsbyI44oNOdhlDQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/get-type': 30.1.0
+      '@jest/types': 30.2.0
+      chalk: 4.1.2
+      jest-util: 30.2.0
+      pretty-format: 30.2.0
+    dev: true
+
+  /jest-environment-node@30.2.0:
+    resolution: {integrity: sha512-ElU8v92QJ9UrYsKrxDIKCxu6PfNj4Hdcktcn0JX12zqNdqWHB0N+hwOnnBBXvjLd2vApZtuLUGs1QSY+MsXoNA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/environment': 30.2.0
+      '@jest/fake-timers': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      jest-mock: 30.2.0
+      jest-util: 30.2.0
+      jest-validate: 30.2.0
+    dev: true
+
+  /jest-haste-map@30.2.0:
+    resolution: {integrity: sha512-sQA/jCb9kNt+neM0anSj6eZhLZUIhQgwDt7cPGjumgLM4rXsfb9kpnlacmvZz3Q5tb80nS+oG/if+NBKrHC+Xw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      anymatch: 3.1.3
+      fb-watchman: 2.0.2
+      graceful-fs: 4.2.11
+      jest-regex-util: 30.0.1
+      jest-util: 30.2.0
+      jest-worker: 30.2.0
+      micromatch: 4.0.8
+      walker: 1.0.8
+    optionalDependencies:
+      fsevents: 2.3.3
+    dev: true
+
+  /jest-leak-detector@30.2.0:
+    resolution: {integrity: sha512-M6jKAjyzjHG0SrQgwhgZGy9hFazcudwCNovY/9HPIicmNSBuockPSedAP9vlPK6ONFJ1zfyH/M2/YYJxOz5cdQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/get-type': 30.1.0
+      pretty-format: 30.2.0
+    dev: true
+
+  /jest-matcher-utils@30.2.0:
+    resolution: {integrity: sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/get-type': 30.1.0
+      chalk: 4.1.2
+      jest-diff: 30.2.0
+      pretty-format: 30.2.0
+    dev: true
+
+  /jest-message-util@30.2.0:
+    resolution: {integrity: sha512-y4DKFLZ2y6DxTWD4cDe07RglV88ZiNEdlRfGtqahfbIjfsw1nMCPx49Uev4IA/hWn3sDKyAnSPwoYSsAEdcimw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@jest/types': 30.2.0
+      '@types/stack-utils': 2.0.3
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      micromatch: 4.0.8
+      pretty-format: 30.2.0
+      slash: 3.0.0
+      stack-utils: 2.0.6
+    dev: true
+
+  /jest-mock@30.2.0:
+    resolution: {integrity: sha512-JNNNl2rj4b5ICpmAcq+WbLH83XswjPbjH4T7yvGzfAGCPh1rw+xVNbtk+FnRslvt9lkCcdn9i1oAoKUuFsOxRw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      jest-util: 30.2.0
+    dev: true
+
+  /jest-pnp-resolver@1.2.3(jest-resolve@30.2.0):
+    resolution: {integrity: sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==}
+    engines: {node: '>=6'}
+    peerDependencies:
+      jest-resolve: '*'
+    peerDependenciesMeta:
+      jest-resolve:
+        optional: true
+    dependencies:
+      jest-resolve: 30.2.0
+    dev: true
+
+  /jest-regex-util@30.0.1:
+    resolution: {integrity: sha512-jHEQgBXAgc+Gh4g0p3bCevgRCVRkB4VB70zhoAE48gxeSr1hfUOsM/C2WoJgVL7Eyg//hudYENbm3Ne+/dRVVA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dev: true
+
+  /jest-resolve-dependencies@30.2.0:
+    resolution: {integrity: sha512-xTOIGug/0RmIe3mmCqCT95yO0vj6JURrn1TKWlNbhiAefJRWINNPgwVkrVgt/YaerPzY3iItufd80v3lOrFJ2w==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      jest-regex-util: 30.0.1
+      jest-snapshot: 30.2.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /jest-resolve@30.2.0:
+    resolution: {integrity: sha512-TCrHSxPlx3tBY3hWNtRQKbtgLhsXa1WmbJEqBlTBrGafd5fiQFByy2GNCEoGR+Tns8d15GaL9cxEzKOO3GEb2A==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      chalk: 4.1.2
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.2.0
+      jest-pnp-resolver: 1.2.3(jest-resolve@30.2.0)
+      jest-util: 30.2.0
+      jest-validate: 30.2.0
+      slash: 3.0.0
+      unrs-resolver: 1.11.1
+    dev: true
+
+  /jest-runner@30.2.0:
+    resolution: {integrity: sha512-PqvZ2B2XEyPEbclp+gV6KO/F1FIFSbIwewRgmROCMBo/aZ6J1w8Qypoj2pEOcg3G2HzLlaP6VUtvwCI8dM3oqQ==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/console': 30.2.0
+      '@jest/environment': 30.2.0
+      '@jest/test-result': 30.2.0
+      '@jest/transform': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      chalk: 4.1.2
+      emittery: 0.13.1
+      exit-x: 0.2.2
+      graceful-fs: 4.2.11
+      jest-docblock: 30.2.0
+      jest-environment-node: 30.2.0
+      jest-haste-map: 30.2.0
+      jest-leak-detector: 30.2.0
+      jest-message-util: 30.2.0
+      jest-resolve: 30.2.0
+      jest-runtime: 30.2.0
+      jest-util: 30.2.0
+      jest-watcher: 30.2.0
+      jest-worker: 30.2.0
+      p-limit: 3.1.0
+      source-map-support: 0.5.13
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /jest-runtime@30.2.0:
+    resolution: {integrity: sha512-p1+GVX/PJqTucvsmERPMgCPvQJpFt4hFbM+VN3n8TMo47decMUcJbt+rgzwrEme0MQUA/R+1de2axftTHkKckg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/environment': 30.2.0
+      '@jest/fake-timers': 30.2.0
+      '@jest/globals': 30.2.0
+      '@jest/source-map': 30.0.1
+      '@jest/test-result': 30.2.0
+      '@jest/transform': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      chalk: 4.1.2
+      cjs-module-lexer: 2.1.0
+      collect-v8-coverage: 1.0.3
+      glob: 10.4.5
+      graceful-fs: 4.2.11
+      jest-haste-map: 30.2.0
+      jest-message-util: 30.2.0
+      jest-mock: 30.2.0
+      jest-regex-util: 30.0.1
+      jest-resolve: 30.2.0
+      jest-snapshot: 30.2.0
+      jest-util: 30.2.0
+      slash: 3.0.0
+      strip-bom: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /jest-snapshot@30.2.0:
+    resolution: {integrity: sha512-5WEtTy2jXPFypadKNpbNkZ72puZCa6UjSr/7djeecHWOu7iYhSXSnHScT8wBz3Rn8Ena5d5RYRcsyKIeqG1IyA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@babel/core': 7.28.4
+      '@babel/generator': 7.28.3
+      '@babel/plugin-syntax-jsx': 7.27.1(@babel/core@7.28.4)
+      '@babel/plugin-syntax-typescript': 7.27.1(@babel/core@7.28.4)
+      '@babel/types': 7.28.4
+      '@jest/expect-utils': 30.2.0
+      '@jest/get-type': 30.1.0
+      '@jest/snapshot-utils': 30.2.0
+      '@jest/transform': 30.2.0
+      '@jest/types': 30.2.0
+      babel-preset-current-node-syntax: 1.2.0(@babel/core@7.28.4)
+      chalk: 4.1.2
+      expect: 30.2.0
+      graceful-fs: 4.2.11
+      jest-diff: 30.2.0
+      jest-matcher-utils: 30.2.0
+      jest-message-util: 30.2.0
+      jest-util: 30.2.0
+      pretty-format: 30.2.0
+      semver: 7.7.3
+      synckit: 0.11.11
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /jest-util@30.2.0:
+    resolution: {integrity: sha512-QKNsM0o3Xe6ISQU869e+DhG+4CK/48aHYdJZGlFQVTjnbvgpcKyxpzk29fGiO7i/J8VENZ+d2iGnSsvmuHywlA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      chalk: 4.1.2
+      ci-info: 4.3.1
+      graceful-fs: 4.2.11
+      picomatch: 4.0.3
+    dev: true
+
+  /jest-validate@30.2.0:
+    resolution: {integrity: sha512-FBGWi7dP2hpdi8nBoWxSsLvBFewKAg0+uSQwBaof4Y4DPgBabXgpSYC5/lR7VmnIlSpASmCi/ntRWPbv7089Pw==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/get-type': 30.1.0
+      '@jest/types': 30.2.0
+      camelcase: 6.3.0
+      chalk: 4.1.2
+      leven: 3.1.0
+      pretty-format: 30.2.0
+    dev: true
+
+  /jest-watcher@30.2.0:
+    resolution: {integrity: sha512-PYxa28dxJ9g777pGm/7PrbnMeA0Jr7osHP9bS7eJy9DuAjMgdGtxgf0uKMyoIsTWAkIbUW5hSDdJ3urmgXBqxg==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/test-result': 30.2.0
+      '@jest/types': 30.2.0
+      '@types/node': 24.9.1
+      ansi-escapes: 4.3.2
+      chalk: 4.1.2
+      emittery: 0.13.1
+      jest-util: 30.2.0
+      string-length: 4.0.2
+    dev: true
+
+  /jest-worker@30.2.0:
+    resolution: {integrity: sha512-0Q4Uk8WF7BUwqXHuAjc23vmopWJw5WH7w2tqBoUOZpOjW/ZnR44GXXd1r82RvnmI2GZge3ivrYXk/BE2+VtW2g==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@types/node': 24.9.1
+      '@ungap/structured-clone': 1.3.0
+      jest-util: 30.2.0
+      merge-stream: 2.0.0
+      supports-color: 8.1.1
+    dev: true
+
+  /jest@30.2.0:
+    resolution: {integrity: sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0
+    peerDependenciesMeta:
+      node-notifier:
+        optional: true
+    dependencies:
+      '@jest/core': 30.2.0
+      '@jest/types': 30.2.0
+      import-local: 3.2.0
+      jest-cli: 30.2.0
+    transitivePeerDependencies:
+      - '@types/node'
+      - babel-plugin-macros
+      - esbuild-register
+      - supports-color
+      - ts-node
+    dev: true
+
+  /js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+    dev: true
+
+  /js-yaml@3.14.1:
+    resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==}
+    hasBin: true
+    dependencies:
+      argparse: 1.0.10
+      esprima: 4.0.1
+    dev: true
+
+  /js-yaml@4.1.0:
+    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
+    hasBin: true
+    dependencies:
+      argparse: 2.0.1
+    dev: true
+
+  /jsesc@3.1.0:
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
+    hasBin: true
+    dev: true
+
+  /json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+    dev: true
+
+  /json-parse-even-better-errors@2.3.1:
+    resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
+    dev: true
+
+  /json-schema-traverse@0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+    dev: true
+
+  /json-stable-stringify-without-jsonify@1.0.1:
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
+    dev: true
+
+  /json5@2.2.3:
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
+    hasBin: true
+    dev: true
+
+  /jsonify@0.0.1:
+    resolution: {integrity: sha512-2/Ki0GcmuqSrgFyelQq9M05y7PS0mEwuIzrf3f1fPqkVDVRvZrPZtVSMHxdgo8Aq0sxAOb/cr2aqqA3LeWHVPg==}
+    dev: false
+
+  /jsonwebtoken@9.0.2:
+    resolution: {integrity: sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==}
+    engines: {node: '>=12', npm: '>=6'}
+    dependencies:
+      jws: 3.2.2
+      lodash.includes: 4.3.0
+      lodash.isboolean: 3.0.3
+      lodash.isinteger: 4.0.4
+      lodash.isnumber: 3.0.3
+      lodash.isplainobject: 4.0.6
+      lodash.isstring: 4.0.1
+      lodash.once: 4.1.1
+      ms: 2.1.3
+      semver: 7.7.3
+    dev: false
+
+  /jwa@1.4.2:
+    resolution: {integrity: sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==}
+    dependencies:
+      buffer-equal-constant-time: 1.0.1
+      ecdsa-sig-formatter: 1.0.11
+      safe-buffer: 5.2.1
+    dev: false
+
+  /jws@3.2.2:
+    resolution: {integrity: sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==}
+    dependencies:
+      jwa: 1.4.2
+      safe-buffer: 5.2.1
+    dev: false
+
+  /keyv@4.5.4:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+    dependencies:
+      json-buffer: 3.0.1
+    dev: true
+
+  /kind-of@6.0.3:
+    resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /leaflet@1.9.4:
+    resolution: {integrity: sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==}
+    dev: false
+
+  /lerc@3.0.0:
+    resolution: {integrity: sha512-Rm4J/WaHhRa93nCN2mwWDZFoRVF18G1f47C+kvQWyHGEZxFpTUi73p7lMVSAndyxGt6lJ2/CFbOcf9ra5p8aww==}
+    dev: false
+
+  /leven@3.1.0:
+    resolution: {integrity: sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /levn@0.4.1:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+    dev: true
+
+  /lie@3.1.1:
+    resolution: {integrity: sha512-RiNhHysUjhrDQntfYSfY4MU24coXXdEOgw9WGcKHNeEwffDYbF//u87M1EWaMGzuFoSbqW0C9C6lEEhDOAswfw==}
+    dependencies:
+      immediate: 3.0.6
+    dev: false
+
+  /lines-and-columns@1.2.4:
+    resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
+    dev: true
+
+  /localforage@1.10.0:
+    resolution: {integrity: sha512-14/H1aX7hzBBmmh7sGPd+AOMkkIrHM3Z1PAyGgZigA1H1p5O5ANnMyWzvpAETtG68/dC4pC0ncy3+PPGzXZHPg==}
+    dependencies:
+      lie: 3.1.1
+    dev: false
+
+  /locate-path@3.0.0:
+    resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==}
+    engines: {node: '>=6'}
+    dependencies:
+      p-locate: 3.0.0
+      path-exists: 3.0.0
+    dev: true
+
+  /locate-path@5.0.0:
+    resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==}
+    engines: {node: '>=8'}
+    dependencies:
+      p-locate: 4.1.0
+    dev: true
+
+  /locate-path@6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+    dependencies:
+      p-locate: 5.0.0
+    dev: true
+
+  /lodash.debounce@4.0.8:
+    resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==}
+    dev: true
+
+  /lodash.includes@4.3.0:
+    resolution: {integrity: sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==}
+    dev: false
+
+  /lodash.isboolean@3.0.3:
+    resolution: {integrity: sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==}
+    dev: false
+
+  /lodash.isinteger@4.0.4:
+    resolution: {integrity: sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==}
+    dev: false
+
+  /lodash.isnumber@3.0.3:
+    resolution: {integrity: sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==}
+    dev: false
+
+  /lodash.isplainobject@4.0.6:
+    resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}
+    dev: false
+
+  /lodash.isstring@4.0.1:
+    resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==}
+    dev: false
+
+  /lodash.merge@4.6.2:
+    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
+    dev: true
+
+  /lodash.once@4.1.1:
+    resolution: {integrity: sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==}
+    dev: false
+
+  /lru-cache@10.4.3:
+    resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==}
+    dev: true
+
+  /lru-cache@5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+    dependencies:
+      yallist: 3.1.1
+    dev: true
+
+  /lru-cache@6.0.0:
+    resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
+    engines: {node: '>=10'}
+    requiresBuild: true
+    dependencies:
+      yallist: 4.0.0
+    dev: false
+    optional: true
+
+  /make-dir@2.1.0:
+    resolution: {integrity: sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==}
+    engines: {node: '>=6'}
+    dependencies:
+      pify: 4.0.1
+      semver: 5.7.2
+    dev: true
+
+  /make-dir@4.0.0:
+    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
+    engines: {node: '>=10'}
+    dependencies:
+      semver: 7.7.3
+    dev: true
+
+  /make-fetch-happen@9.1.0:
+    resolution: {integrity: sha512-+zopwDy7DNknmwPQplem5lAZX/eCOzSvSNNcSKm5eVwTkOBzoktEfXsa9L23J/GIRhxRsaxzkPEhrJEpE2F4Gg==}
+    engines: {node: '>= 10'}
+    requiresBuild: true
+    dependencies:
+      agentkeepalive: 4.6.0
+      cacache: 15.3.0
+      http-cache-semantics: 4.2.0
+      http-proxy-agent: 4.0.1
+      https-proxy-agent: 5.0.1
+      is-lambda: 1.0.1
+      lru-cache: 6.0.0
+      minipass: 3.3.6
+      minipass-collect: 1.0.2
+      minipass-fetch: 1.4.1
+      minipass-flush: 1.0.5
+      minipass-pipeline: 1.2.4
+      negotiator: 0.6.4
+      promise-retry: 2.0.1
+      socks-proxy-agent: 6.2.1
+      ssri: 8.0.1
+    transitivePeerDependencies:
+      - bluebird
+      - supports-color
+    dev: false
+    optional: true
+
+  /makeerror@1.0.12:
+    resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==}
+    dependencies:
+      tmpl: 1.0.5
+    dev: true
+
+  /match-sorter@8.1.0:
+    resolution: {integrity: sha512-0HX3BHPixkbECX+Vt7nS1vJ6P2twPgGTU3PMXjWrl1eyVCL24tFHeyYN1FN5RKLzve0TyzNI9qntqQGbebnfPQ==}
+    dependencies:
+      '@babel/runtime': 7.28.4
+      remove-accents: 0.5.0
+    dev: false
+
+  /math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  /media-typer@1.1.0:
+    resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /memory-pager@1.5.0:
+    resolution: {integrity: sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg==}
+    dev: false
+
+  /merge-descriptors@2.0.0:
+    resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
+    engines: {node: '>=18'}
+    dev: false
+
+  /merge-stream@2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+    dev: true
+
+  /micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.1
+    dev: true
+
+  /mime-db@1.54.0:
+    resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /mime-types@3.0.1:
+    resolution: {integrity: sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      mime-db: 1.54.0
+    dev: false
+
+  /mimic-fn@2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /mimic-response@3.1.0:
+    resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
+    engines: {node: '>=10'}
+    dev: false
+
+  /min-document@0.2.8:
+    resolution: {integrity: sha512-ri+szIofvuuGNJyf9sSpZNflnMoB1Cc+1B/yEksib+YXF/9CdnKABVFMk0n4+RTXP5bRSp8kP5NbpdMHGmabbw==}
+    dependencies:
+      tape: 1.0.4
+    dev: false
+
+  /minimatch@3.1.2:
+    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+    dependencies:
+      brace-expansion: 1.1.12
+
+  /minimatch@9.0.5:
+    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    dependencies:
+      brace-expansion: 2.0.2
+    dev: true
+
+  /minimist@1.2.8:
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
+    dev: false
+
+  /minipass-collect@1.0.2:
+    resolution: {integrity: sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==}
+    engines: {node: '>= 8'}
+    requiresBuild: true
+    dependencies:
+      minipass: 3.3.6
+    dev: false
+    optional: true
+
+  /minipass-fetch@1.4.1:
+    resolution: {integrity: sha512-CGH1eblLq26Y15+Azk7ey4xh0J/XfJfrCox5LDJiKqI2Q2iwOLOKrlmIaODiSQS8d18jalF6y2K2ePUm0CmShw==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dependencies:
+      minipass: 3.3.6
+      minipass-sized: 1.0.3
+      minizlib: 2.1.2
+    optionalDependencies:
+      encoding: 0.1.13
+    dev: false
+    optional: true
+
+  /minipass-flush@1.0.5:
+    resolution: {integrity: sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==}
+    engines: {node: '>= 8'}
+    requiresBuild: true
+    dependencies:
+      minipass: 3.3.6
+    dev: false
+    optional: true
+
+  /minipass-pipeline@1.2.4:
+    resolution: {integrity: sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dependencies:
+      minipass: 3.3.6
+    dev: false
+    optional: true
+
+  /minipass-sized@1.0.3:
+    resolution: {integrity: sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==}
+    engines: {node: '>=8'}
+    requiresBuild: true
+    dependencies:
+      minipass: 3.3.6
+    dev: false
+    optional: true
+
+  /minipass@3.3.6:
+    resolution: {integrity: sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==}
+    engines: {node: '>=8'}
+    dependencies:
+      yallist: 4.0.0
+    dev: false
+
+  /minipass@5.0.0:
+    resolution: {integrity: sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==}
+    engines: {node: '>=8'}
+    dev: false
+
+  /minipass@7.1.2:
+    resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    dev: true
+
+  /minizlib@2.1.2:
+    resolution: {integrity: sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==}
+    engines: {node: '>= 8'}
+    dependencies:
+      minipass: 3.3.6
+      yallist: 4.0.0
+    dev: false
+
+  /mkdirp-classic@0.5.3:
+    resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
+    dev: false
+
+  /mkdirp@1.0.4:
+    resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dev: false
+
+  /mongodb-connection-string-url@3.0.2:
+    resolution: {integrity: sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA==}
+    dependencies:
+      '@types/whatwg-url': 11.0.5
+      whatwg-url: 14.2.0
+    dev: false
+
+  /mongodb@6.20.0:
+    resolution: {integrity: sha512-Tl6MEIU3K4Rq3TSHd+sZQqRBoGlFsOgNrH5ltAcFBV62Re3Fd+FcaVf8uSEQFOJ51SDowDVttBTONMfoYWrWlQ==}
+    engines: {node: '>=16.20.1'}
+    peerDependencies:
+      '@aws-sdk/credential-providers': ^3.188.0
+      '@mongodb-js/zstd': ^1.1.0 || ^2.0.0
+      gcp-metadata: ^5.2.0
+      kerberos: ^2.0.1
+      mongodb-client-encryption: '>=6.0.0 <7'
+      snappy: ^7.3.2
+      socks: ^2.7.1
+    peerDependenciesMeta:
+      '@aws-sdk/credential-providers':
+        optional: true
+      '@mongodb-js/zstd':
+        optional: true
+      gcp-metadata:
+        optional: true
+      kerberos:
+        optional: true
+      mongodb-client-encryption:
+        optional: true
+      snappy:
+        optional: true
+      socks:
+        optional: true
+    dependencies:
+      '@mongodb-js/saslprep': 1.3.0
+      bson: 6.10.4
+      mongodb-connection-string-url: 3.0.2
+    dev: false
+
+  /ms@2.0.0:
+    resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==}
+    dev: false
+
+  /ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  /napi-build-utils@2.0.0:
+    resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
+    dev: false
+
+  /napi-postinstall@0.3.4:
+    resolution: {integrity: sha512-PHI5f1O0EP5xJ9gQmFGMS6IZcrVvTjpXjz7Na41gTE7eE2hK11lg04CECCYEEjdc17EV4DO+fkGEtt7TpTaTiQ==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+    hasBin: true
+    dev: true
+
+  /natural-compare@1.4.0:
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
+    dev: true
+
+  /negotiator@0.6.4:
+    resolution: {integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==}
+    engines: {node: '>= 0.6'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /negotiator@1.0.0:
+    resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /node-abi@3.78.0:
+    resolution: {integrity: sha512-E2wEyrgX/CqvicaQYU3Ze1PFGjc4QYPGsjUrlYkqAE0WjHEZwgOsGMPMzkMse4LjJbDmaEuDX3CM036j5K2DSQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      semver: 7.7.3
+    dev: false
+
+  /node-addon-api@7.1.1:
+    resolution: {integrity: sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==}
+    dev: false
+
+  /node-addon-api@8.5.0:
+    resolution: {integrity: sha512-/bRZty2mXUIFY/xU5HLvveNHlswNJej+RnxBjOMkidWfwZzgTbPG1E3K5TOxRLOR+5hX7bSofy8yf1hZevMS8A==}
+    engines: {node: ^18 || ^20 || >= 21}
+    dev: false
+
+  /node-environment-flags@1.0.6:
+    resolution: {integrity: sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw==}
+    dependencies:
+      object.getownpropertydescriptors: 2.1.8
+      semver: 5.7.2
+    dev: true
+
+  /node-gyp-build@4.8.4:
+    resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==}
+    hasBin: true
+    dev: false
+
+  /node-gyp@8.4.1:
+    resolution: {integrity: sha512-olTJRgUtAb/hOXG0E93wZDs5YiJlgbXxTwQAFHyNlRsXQnYzUaF2aGgujZbw+hR8aF4ZG/rST57bWMWD16jr9w==}
+    engines: {node: '>= 10.12.0'}
+    hasBin: true
+    requiresBuild: true
+    dependencies:
+      env-paths: 2.2.1
+      glob: 7.2.3
+      graceful-fs: 4.2.11
+      make-fetch-happen: 9.1.0
+      nopt: 5.0.0
+      npmlog: 6.0.2
+      rimraf: 3.0.2
+      semver: 7.7.3
+      tar: 6.2.1
+      which: 2.0.2
+    transitivePeerDependencies:
+      - bluebird
+      - supports-color
+    dev: false
+    optional: true
+
+  /node-int64@0.4.0:
+    resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
+    dev: true
+
+  /node-releases@2.0.25:
+    resolution: {integrity: sha512-4auku8B/vw5psvTiiN9j1dAOsXvMoGqJuKJcR+dTdqiXEK20mMTk1UEo3HS16LeGQsVG6+qKTPM9u/qQ2LqATA==}
+    dev: true
+
+  /node.js@0.0.1-security:
+    resolution: {integrity: sha512-8tWQiyg/3ggdLTrtfgj/NxmZpC20eB1U5VNkqt2dbelpcr3NrfjpEE3DgifpBOCJ4Xu9Obvu8iju63ViQW3Hvg==}
+    dev: false
+
+  /nodemon@3.1.10:
+    resolution: {integrity: sha512-WDjw3pJ0/0jMFmyNDp3gvY2YizjLmmOUQo6DEBY+JgdvW/yQ9mEeSw6H5ythl5Ny2ytb7f9C2nIbjSxMNzbJXw==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      chokidar: 3.6.0
+      debug: 4.4.1(supports-color@5.5.0)
+      ignore-by-default: 1.0.1
+      minimatch: 3.1.2
+      pstree.remy: 1.1.8
+      semver: 7.7.3
+      simple-update-notifier: 2.0.0
+      supports-color: 5.5.0
+      touch: 3.1.1
+      undefsafe: 2.0.5
+    dev: true
+
+  /nopt@5.0.0:
+    resolution: {integrity: sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==}
+    engines: {node: '>=6'}
+    hasBin: true
+    requiresBuild: true
+    dependencies:
+      abbrev: 1.1.1
+    dev: false
+    optional: true
+
+  /normalize-path@3.0.0:
+    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
+    engines: {node: '>=0.10.0'}
+    requiresBuild: true
+    dev: true
+
+  /npm-run-path@4.0.1:
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
+    dependencies:
+      path-key: 3.1.1
+    dev: true
+
+  /npmlog@6.0.2:
+    resolution: {integrity: sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==}
+    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
+    deprecated: This package is no longer supported.
+    requiresBuild: true
+    dependencies:
+      are-we-there-yet: 3.0.1
+      console-control-strings: 1.1.0
+      gauge: 4.0.4
+      set-blocking: 2.0.0
+    dev: false
+    optional: true
+
+  /oauth@0.10.2:
+    resolution: {integrity: sha512-JtFnB+8nxDEXgNyniwz573xxbKSOu3R8D40xQKqcjwJ2CDkYqUDI53o6IuzDJBx60Z8VKCm271+t8iFjakrl8Q==}
+    dev: false
+
+  /object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+    dev: false
+
+  /object-inspect@1.13.4:
+    resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
+    engines: {node: '>= 0.4'}
+
+  /object-keys@1.1.1:
+    resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /object.assign@4.1.7:
+    resolution: {integrity: sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+      has-symbols: 1.1.0
+      object-keys: 1.1.1
+    dev: true
+
+  /object.getownpropertydescriptors@2.1.8:
+    resolution: {integrity: sha512-qkHIGe4q0lSYMv0XI4SsBTJz3WaURhLvd0lKSgtVuOsJ2krg4SgMw3PIRQFMp07yi++UR3se2mkcLqsBNpBb/A==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      array.prototype.reduce: 1.0.8
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.24.0
+      es-object-atoms: 1.1.1
+      gopd: 1.2.0
+      safe-array-concat: 1.1.3
+    dev: true
+
+  /ol@10.6.1:
+    resolution: {integrity: sha512-xp174YOwPeLj7c7/8TCIEHQ4d41tgTDDhdv6SqNdySsql5/MaFJEJkjlsYcvOPt7xA6vrum/QG4UdJ0iCGT1cg==}
+    dependencies:
+      '@types/rbush': 4.0.0
+      earcut: 3.0.2
+      geotiff: 2.1.3
+      pbf: 4.0.1
+      rbush: 4.0.1
+    dev: false
+
+  /omicron@0.2.0:
+    resolution: {integrity: sha512-pv4/a3GWzcw7z3xavdjsNGRRVHJ2SjwsU080MoK6RJHwrU8Y5eQXBd9E3Tyx0/hJtQtSPSlEgiyi4UkW+62Zqg==}
+    dev: false
+
+  /on-finished@2.4.1:
+    resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      ee-first: 1.1.1
+    dev: false
+
+  /on-headers@1.1.0:
+    resolution: {integrity: sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+    dependencies:
+      wrappy: 1.0.2
+
+  /onetime@5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+    dependencies:
+      mimic-fn: 2.1.0
+    dev: true
+
+  /optionator@0.9.4:
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.5
+    dev: true
+
+  /own-keys@1.0.1:
+    resolution: {integrity: sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      get-intrinsic: 1.3.0
+      object-keys: 1.1.1
+      safe-push-apply: 1.0.0
+    dev: true
+
+  /p-limit@2.3.0:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+    dependencies:
+      p-try: 2.2.0
+    dev: true
+
+  /p-limit@3.1.0:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      yocto-queue: 0.1.0
+    dev: true
+
+  /p-locate@3.0.0:
+    resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      p-limit: 2.3.0
+    dev: true
+
+  /p-locate@4.1.0:
+    resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==}
+    engines: {node: '>=8'}
+    dependencies:
+      p-limit: 2.3.0
+    dev: true
+
+  /p-locate@5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+    dependencies:
+      p-limit: 3.1.0
+    dev: true
+
+  /p-map@4.0.0:
+    resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==}
+    engines: {node: '>=10'}
+    requiresBuild: true
+    dependencies:
+      aggregate-error: 3.1.0
+    dev: false
+    optional: true
+
+  /p-try@2.2.0:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /package-json-from-dist@1.0.1:
+    resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
+    dev: true
+
+  /pako@2.1.0:
+    resolution: {integrity: sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug==}
+    dev: false
+
+  /parent-module@1.0.1:
+    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
+    engines: {node: '>=6'}
+    dependencies:
+      callsites: 3.1.0
+    dev: true
+
+  /parse-headers@2.0.6:
+    resolution: {integrity: sha512-Tz11t3uKztEW5FEVZnj1ox8GKblWn+PvHY9TmJV5Mll2uHEwRdR/5Li1OlXoECjLYkApdhWy44ocONwXLiKO5A==}
+    dev: false
+
+  /parse-json@5.2.0:
+    resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
+    engines: {node: '>=8'}
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      error-ex: 1.3.4
+      json-parse-even-better-errors: 2.3.1
+      lines-and-columns: 1.2.4
+    dev: true
+
+  /parse-passwd@1.0.0:
+    resolution: {integrity: sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /parseurl@1.3.3:
+    resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /passport-facebook@3.0.0:
+    resolution: {integrity: sha512-K/qNzuFsFISYAyC1Nma4qgY/12V3RSLFdFVsPKXiKZt434wOvthFW1p7zKa1iQihQMRhaWorVE1o3Vi1o+ZgeQ==}
+    engines: {node: '>= 0.4.0'}
+    dependencies:
+      passport-oauth2: 1.8.0
+    dev: false
+
+  /passport-oauth2@1.8.0:
+    resolution: {integrity: sha512-cjsQbOrXIDE4P8nNb3FQRCCmJJ/utnFKEz2NX209f7KOHPoX18gF7gBzBbLLsj2/je4KrgiwLLGjf0lm9rtTBA==}
+    engines: {node: '>= 0.4.0'}
+    dependencies:
+      base64url: 3.0.1
+      oauth: 0.10.2
+      passport-strategy: 1.0.0
+      uid2: 0.0.4
+      utils-merge: 1.0.1
+    dev: false
+
+  /passport-strategy@1.0.0:
+    resolution: {integrity: sha512-CB97UUvDKJde2V0KDWWB3lyf6PC3FaZP7YxZ2G8OAtn9p4HI9j9JLP9qjOGZFvyl8uwNT8qM+hGnz/n16NI7oA==}
+    engines: {node: '>= 0.4.0'}
+    dev: false
+
+  /passport@0.7.0:
+    resolution: {integrity: sha512-cPLl+qZpSc+ireUvt+IzqbED1cHHkDoVYMo30jbJIdOOjQ1MQYZBPiNvmi8UM6lJuOpTPXJGZQk0DtC4y61MYQ==}
+    engines: {node: '>= 0.4.0'}
+    dependencies:
+      passport-strategy: 1.0.0
+      pause: 0.0.1
+      utils-merge: 1.0.1
+    dev: false
+
+  /path-exists@3.0.0:
+    resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /path-exists@4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /path-is-absolute@1.0.1:
+    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
+    engines: {node: '>=0.10.0'}
+
+  /path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /path-parse@1.0.7:
+    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
+    dev: true
+
+  /path-scurry@1.11.1:
+    resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==}
+    engines: {node: '>=16 || 14 >=14.18'}
+    dependencies:
+      lru-cache: 10.4.3
+      minipass: 7.1.2
+    dev: true
+
+  /path-to-regexp@8.2.0:
+    resolution: {integrity: sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==}
+    engines: {node: '>=16'}
+    dev: false
+
+  /pause@0.0.1:
+    resolution: {integrity: sha512-KG8UEiEVkR3wGEb4m5yZkVCzigAD+cVEJck2CzYZO37ZGJfctvVptVO192MwrtPhzONn6go8ylnOdMhKqi4nfg==}
+    dev: false
+
+  /pbf@4.0.1:
+    resolution: {integrity: sha512-SuLdBvS42z33m8ejRbInMapQe8n0D3vN/Xd5fmWM3tufNgRQFBpaW2YVJxQZV4iPNqb0vEFvssMEo5w9c6BTIA==}
+    hasBin: true
+    dependencies:
+      resolve-protobuf-schema: 2.1.0
+    dev: false
+
+  /picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+    dev: true
+
+  /picomatch@2.3.1:
+    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
+    engines: {node: '>=8.6'}
+    dev: true
+
+  /picomatch@4.0.3:
+    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /pify@4.0.1:
+    resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /pirates@4.0.7:
+    resolution: {integrity: sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==}
+    engines: {node: '>= 6'}
+    dev: true
+
+  /pkg-dir@3.0.0:
+    resolution: {integrity: sha512-/E57AYkoeQ25qkxMj5PBOVgF8Kiu/h7cYS30Z5+R7WaiCCBfLq58ZI/dSeaEKb9WVJV5n/03QwrN3IeWIFllvw==}
+    engines: {node: '>=6'}
+    dependencies:
+      find-up: 3.0.0
+    dev: true
+
+  /pkg-dir@4.2.0:
+    resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==}
+    engines: {node: '>=8'}
+    dependencies:
+      find-up: 4.1.0
+    dev: true
+
+  /possible-typed-array-names@1.1.0:
+    resolution: {integrity: sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /prebuild-install@7.1.3:
+    resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
+    engines: {node: '>=10'}
+    hasBin: true
+    dependencies:
+      detect-libc: 2.1.2
+      expand-template: 2.0.3
+      github-from-package: 0.0.0
+      minimist: 1.2.8
+      mkdirp-classic: 0.5.3
+      napi-build-utils: 2.0.0
+      node-abi: 3.78.0
+      pump: 3.0.3
+      rc: 1.2.8
+      simple-get: 4.0.1
+      tar-fs: 2.1.4
+      tunnel-agent: 0.6.0
+    dev: false
+
+  /prelude-ls@1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+    dev: true
+
+  /pretty-format@30.2.0:
+    resolution: {integrity: sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==}
+    engines: {node: ^18.14.0 || ^20.0.0 || ^22.0.0 || >=24.0.0}
+    dependencies:
+      '@jest/schemas': 30.0.5
+      ansi-styles: 5.2.0
+      react-is: 18.3.1
+    dev: true
+
+  /process@0.5.2:
+    resolution: {integrity: sha512-oNpcutj+nYX2FjdEW7PGltWhXulAnFlM0My/k48L90hARCOJtvBbQXc/6itV2jDvU5xAAtonP+r6wmQgCcbAUA==}
+    engines: {node: '>= 0.6.0'}
+    dev: false
+
+  /promise-inflight@1.0.1:
+    resolution: {integrity: sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==}
+    requiresBuild: true
+    peerDependencies:
+      bluebird: '*'
+    peerDependenciesMeta:
+      bluebird:
+        optional: true
+    dev: false
+    optional: true
+
+  /promise-retry@2.0.1:
+    resolution: {integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==}
+    engines: {node: '>=10'}
+    requiresBuild: true
+    dependencies:
+      err-code: 2.0.3
+      retry: 0.12.0
+    dev: false
+    optional: true
+
+  /protocol-buffers-schema@3.6.0:
+    resolution: {integrity: sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==}
+    dev: false
+
+  /proxy-addr@2.0.7:
+    resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
+    engines: {node: '>= 0.10'}
+    dependencies:
+      forwarded: 0.2.0
+      ipaddr.js: 1.9.1
+    dev: false
+
+  /pstree.remy@1.1.8:
+    resolution: {integrity: sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==}
+    dev: true
+
+  /pump@3.0.3:
+    resolution: {integrity: sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA==}
+    dependencies:
+      end-of-stream: 1.4.5
+      once: 1.4.0
+    dev: false
+
+  /punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  /pure-rand@7.0.1:
+    resolution: {integrity: sha512-oTUZM/NAZS8p7ANR3SHh30kXB+zK2r2BPcEn/awJIbOvq82WoMN4p62AWWp3Hhw50G0xMsw1mhIBLqHw64EcNQ==}
+    dev: true
+
+  /python@0.0.4:
+    resolution: {integrity: sha512-7avKA/6XxrwcGSDes8xGn7FHAUdAUQXKHtpjDulyv5/nm7TcPblmPRvXjjwx5knWHqeRiipqH/TZR2HhmJ4CGQ==}
+    engines: {node: '>= 0.4.1'}
+    dev: false
+
+  /qs@6.14.0:
+    resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==}
+    engines: {node: '>=0.6'}
+    dependencies:
+      side-channel: 1.1.0
+    dev: false
+
+  /quick-lru@6.1.2:
+    resolution: {integrity: sha512-AAFUA5O1d83pIHEhJwWCq/RQcRukCkn/NSm2QsTEMle5f2hP0ChI2+3Xb051PZCkLryI/Ir1MVKviT2FIloaTQ==}
+    engines: {node: '>=12'}
+    dev: false
+
+  /quickselect@3.0.0:
+    resolution: {integrity: sha512-XdjUArbK4Bm5fLLvlm5KpTFOiOThgfWWI4axAZDWg4E/0mKdZyI9tNEfds27qCi1ze/vwTR16kvmmGhRra3c2g==}
+    dev: false
+
+  /random-bytes@1.0.0:
+    resolution: {integrity: sha512-iv7LhNVO047HzYR3InF6pUcUsPQiHTM1Qal51DcGSuZFBil1aBBWG5eHPNek7bvILMaYJ/8RU1e8w1AMdHmLQQ==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /range-parser@1.2.1:
+    resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
+    engines: {node: '>= 0.6'}
+    dev: false
+
+  /raw-body@3.0.0:
+    resolution: {integrity: sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.0
+      iconv-lite: 0.6.3
+      unpipe: 1.0.0
+    dev: false
+
+  /rbush@4.0.1:
+    resolution: {integrity: sha512-IP0UpfeWQujYC8Jg162rMNc01Rf0gWMMAb2Uxus/Q0qOFw4lCcq6ZnQEZwUoJqWyUGJ9th7JjwI4yIWo+uvoAQ==}
+    dependencies:
+      quickselect: 3.0.0
+    dev: false
+
+  /rc@1.2.8:
+    resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
+    hasBin: true
+    dependencies:
+      deep-extend: 0.6.0
+      ini: 1.3.8
+      minimist: 1.2.8
+      strip-json-comments: 2.0.1
+    dev: false
+
+  /react-is@18.3.1:
+    resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==}
+    dev: true
+
+  /readable-stream@3.6.2:
+    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
+    engines: {node: '>= 6'}
+    dependencies:
+      inherits: 2.0.4
+      string_decoder: 1.3.0
+      util-deprecate: 1.0.2
+    dev: false
+
+  /readdirp@3.6.0:
+    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
+    engines: {node: '>=8.10.0'}
+    requiresBuild: true
+    dependencies:
+      picomatch: 2.3.1
+    dev: true
+
+  /reflect.getprototypeof@1.0.10:
+    resolution: {integrity: sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-abstract: 1.24.0
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      get-intrinsic: 1.3.0
+      get-proto: 1.0.1
+      which-builtin-type: 1.2.1
+    dev: true
+
+  /regenerate-unicode-properties@10.2.2:
+    resolution: {integrity: sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==}
+    engines: {node: '>=4'}
+    dependencies:
+      regenerate: 1.4.2
+    dev: true
+
+  /regenerate@1.4.2:
+    resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==}
+    dev: true
+
+  /regenerator-runtime@0.14.1:
+    resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==}
+    dev: true
+
+  /regexp.prototype.flags@1.5.4:
+    resolution: {integrity: sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-errors: 1.3.0
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      set-function-name: 2.0.2
+    dev: true
+
+  /regexpu-core@6.4.0:
+    resolution: {integrity: sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==}
+    engines: {node: '>=4'}
+    dependencies:
+      regenerate: 1.4.2
+      regenerate-unicode-properties: 10.2.2
+      regjsgen: 0.8.0
+      regjsparser: 0.13.0
+      unicode-match-property-ecmascript: 2.0.0
+      unicode-match-property-value-ecmascript: 2.2.1
+    dev: true
+
+  /regjsgen@0.8.0:
+    resolution: {integrity: sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==}
+    dev: true
+
+  /regjsparser@0.13.0:
+    resolution: {integrity: sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==}
+    hasBin: true
+    dependencies:
+      jsesc: 3.1.0
+    dev: true
+
+  /remove-accents@0.5.0:
+    resolution: {integrity: sha512-8g3/Otx1eJaVD12e31UbJj1YzdtVvzH85HV7t+9MJYk/u3XmkOUJ5Ys9wQrf9PCPK8+xn4ymzqYCiZl6QWKn+A==}
+    dev: false
+
+  /require-directory@2.1.1:
+    resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /resolve-cwd@3.0.0:
+    resolution: {integrity: sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==}
+    engines: {node: '>=8'}
+    dependencies:
+      resolve-from: 5.0.0
+    dev: true
+
+  /resolve-from@4.0.0:
+    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /resolve-from@5.0.0:
+    resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /resolve-protobuf-schema@2.1.0:
+    resolution: {integrity: sha512-kI5ffTiZWmJaS/huM8wZfEMer1eRd7oJQhDuxeCLe3t7N7mX3z94CN0xPxBQxFYQTSNz9T0i+v6inKqSdK8xrQ==}
+    dependencies:
+      protocol-buffers-schema: 3.6.0
+    dev: false
+
+  /resolve@1.22.11:
+    resolution: {integrity: sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==}
+    engines: {node: '>= 0.4'}
+    hasBin: true
+    dependencies:
+      is-core-module: 2.16.1
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
+    dev: true
+
+  /retry@0.12.0:
+    resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==}
+    engines: {node: '>= 4'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /rimraf@3.0.2:
+    resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
+    deprecated: Rimraf versions prior to v4 are no longer supported
+    hasBin: true
+    requiresBuild: true
+    dependencies:
+      glob: 7.2.3
+    dev: false
+    optional: true
+
+  /router@2.2.0:
+    resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
+    engines: {node: '>= 18'}
+    dependencies:
+      debug: 4.4.1(supports-color@5.5.0)
+      depd: 2.0.0
+      is-promise: 4.0.0
+      parseurl: 1.3.3
+      path-to-regexp: 8.2.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /safe-array-concat@1.1.3:
+    resolution: {integrity: sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==}
+    engines: {node: '>=0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      get-intrinsic: 1.3.0
+      has-symbols: 1.1.0
+      isarray: 2.0.5
+    dev: true
+
+  /safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+    dev: false
+
+  /safe-push-apply@1.0.0:
+    resolution: {integrity: sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      isarray: 2.0.5
+    dev: true
+
+  /safe-regex-test@1.1.0:
+    resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-regex: 1.2.1
+    dev: true
+
+  /safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+    requiresBuild: true
+    dev: false
+
+  /semver@5.7.2:
+    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
+    hasBin: true
+    dev: true
+
+  /semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
+    hasBin: true
+    dev: true
+
+  /semver@7.7.3:
+    resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  /send@1.2.0:
+    resolution: {integrity: sha512-uaW0WwXKpL9blXE2o0bRhoL2EGXIrZxQ2ZQ4mgcfoBxdFmQold+qWsD2jLrfZ0trjKL6vOw0j//eAwcALFjKSw==}
+    engines: {node: '>= 18'}
+    dependencies:
+      debug: 4.4.1(supports-color@5.5.0)
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      fresh: 2.0.0
+      http-errors: 2.0.0
+      mime-types: 3.0.1
+      ms: 2.1.3
+      on-finished: 2.4.1
+      range-parser: 1.2.1
+      statuses: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /serve-static@2.2.0:
+    resolution: {integrity: sha512-61g9pCh0Vnh7IutZjtLGGpTA355+OPn2TyDv/6ivP2h/AdAVX9azsoxmg2/M6nZeQZNYBEwIcsne1mJd9oQItQ==}
+    engines: {node: '>= 18'}
+    dependencies:
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      parseurl: 1.3.3
+      send: 1.2.0
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /set-blocking@2.0.0:
+    resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /set-function-length@1.2.2:
+    resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+      get-intrinsic: 1.3.0
+      gopd: 1.2.0
+      has-property-descriptors: 1.0.2
+    dev: true
+
+  /set-function-name@2.0.2:
+    resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      define-data-property: 1.1.4
+      es-errors: 1.3.0
+      functions-have-names: 1.2.3
+      has-property-descriptors: 1.0.2
+    dev: true
+
+  /set-proto@1.0.0:
+    resolution: {integrity: sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      dunder-proto: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+    dev: true
+
+  /setprototypeof@1.2.0:
+    resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
+    dev: false
+
+  /shallow-clone@3.0.1:
+    resolution: {integrity: sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==}
+    engines: {node: '>=8'}
+    dependencies:
+      kind-of: 6.0.3
+    dev: true
+
+  /shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+    dependencies:
+      shebang-regex: 3.0.0
+    dev: true
+
+  /shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /side-channel-list@1.0.0:
+    resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+
+  /side-channel-map@1.0.1:
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+
+  /side-channel-weakmap@1.0.2:
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-map: 1.0.1
+
+  /side-channel@1.1.0:
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-list: 1.0.0
+      side-channel-map: 1.0.1
+      side-channel-weakmap: 1.0.2
+
+  /signal-exit@3.0.7:
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
+
+  /signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+    dev: true
+
+  /simple-concat@1.0.1:
+    resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==}
+    dev: false
+
+  /simple-get@4.0.1:
+    resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==}
+    dependencies:
+      decompress-response: 6.0.0
+      once: 1.4.0
+      simple-concat: 1.0.1
+    dev: false
+
+  /simple-update-notifier@2.0.0:
+    resolution: {integrity: sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==}
+    engines: {node: '>=10'}
+    dependencies:
+      semver: 7.7.3
+    dev: true
+
+  /slash@2.0.0:
+    resolution: {integrity: sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /slash@3.0.0:
+    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /smart-buffer@4.2.0:
+    resolution: {integrity: sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==}
+    engines: {node: '>= 6.0.0', npm: '>= 3.0.0'}
+    requiresBuild: true
+    dev: false
+    optional: true
+
+  /socks-proxy-agent@6.2.1:
+    resolution: {integrity: sha512-a6KW9G+6B3nWZ1yB8G7pJwL3ggLy1uTzKAgCb7ttblwqdz9fMGJUuTy3uFzEP48FAs9FLILlmzDlE2JJhVQaXQ==}
+    engines: {node: '>= 10'}
+    requiresBuild: true
+    dependencies:
+      agent-base: 6.0.2
+      debug: 4.4.1(supports-color@5.5.0)
+      socks: 2.8.7
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+    optional: true
+
+  /socks@2.8.7:
+    resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
+    engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
+    requiresBuild: true
+    dependencies:
+      ip-address: 10.0.1
+      smart-buffer: 4.2.0
+    dev: false
+    optional: true
+
+  /sort-by@0.0.2:
+    resolution: {integrity: sha512-iOX5oHA4a0eqTMFiWrHYqv924UeRKFBLhym7iwSVG37Egg2wApgZKAjyzM9WZjMwKv6+8Zi+nIaJ7FYsO9EkoA==}
+    dev: false
+
+  /source-map-support@0.5.13:
+    resolution: {integrity: sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==}
+    dependencies:
+      buffer-from: 1.1.2
+      source-map: 0.6.1
+    dev: true
+
+  /source-map-support@0.5.21:
+    resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==}
+    dependencies:
+      buffer-from: 1.1.2
+      source-map: 0.6.1
+    dev: true
+
+  /source-map@0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /sparse-bitfield@3.0.3:
+    resolution: {integrity: sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ==}
+    dependencies:
+      memory-pager: 1.5.0
+    dev: false
+
+  /sprintf-js@1.0.3:
+    resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
+    dev: true
+
+  /sqlite3@5.1.7:
+    resolution: {integrity: sha512-GGIyOiFaG+TUra3JIfkI/zGP8yZYLPQ0pl1bH+ODjiX57sPhrLU5sQJn1y9bDKZUFYkX1crlrPfSYt0BKKdkog==}
+    requiresBuild: true
+    dependencies:
+      bindings: 1.5.0
+      node-addon-api: 7.1.1
+      prebuild-install: 7.1.3
+      tar: 6.2.1
+    optionalDependencies:
+      node-gyp: 8.4.1
+    transitivePeerDependencies:
+      - bluebird
+      - supports-color
+    dev: false
+
+  /ssri@8.0.1:
+    resolution: {integrity: sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==}
+    engines: {node: '>= 8'}
+    requiresBuild: true
+    dependencies:
+      minipass: 3.3.6
+    dev: false
+    optional: true
+
+  /stack-utils@2.0.6:
+    resolution: {integrity: sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      escape-string-regexp: 2.0.0
+    dev: true
+
+  /state@0.2.0:
+    resolution: {integrity: sha512-USXyoYrQg6xwsUtKTp613UAebyRdc3hlQwMwrZvMim6tikbw7HsOcaovhGVu+4mmxJOejEiX9ya5j+Y5XhcCcw==}
+    dependencies:
+      omicron: 0.2.0
+    dev: false
+
+  /statuses@2.0.1:
+    resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /statuses@2.0.2:
+    resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /stop-iteration-iterator@1.1.0:
+    resolution: {integrity: sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      es-errors: 1.3.0
+      internal-slot: 1.1.0
+    dev: true
+
+  /string-length@4.0.2:
+    resolution: {integrity: sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==}
+    engines: {node: '>=10'}
+    dependencies:
+      char-regex: 1.0.2
+      strip-ansi: 6.0.1
+    dev: true
+
+  /string-width@4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+
+  /string-width@5.1.2:
+    resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==}
+    engines: {node: '>=12'}
+    dependencies:
+      eastasianwidth: 0.2.0
+      emoji-regex: 9.2.2
+      strip-ansi: 7.1.2
+    dev: true
+
+  /string.prototype.trim@1.2.10:
+    resolution: {integrity: sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-data-property: 1.1.4
+      define-properties: 1.2.1
+      es-abstract: 1.24.0
+      es-object-atoms: 1.1.1
+      has-property-descriptors: 1.0.2
+    dev: true
+
+  /string.prototype.trimend@1.0.9:
+    resolution: {integrity: sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+    dev: true
+
+  /string.prototype.trimstart@1.0.8:
+    resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      define-properties: 1.2.1
+      es-object-atoms: 1.1.1
+    dev: true
+
+  /string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+    requiresBuild: true
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: false
+
+  /strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+    dependencies:
+      ansi-regex: 5.0.1
+
+  /strip-ansi@7.1.2:
+    resolution: {integrity: sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==}
+    engines: {node: '>=12'}
+    dependencies:
+      ansi-regex: 6.2.2
+    dev: true
+
+  /strip-bom@4.0.0:
+    resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /strip-final-newline@2.0.0:
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /strip-json-comments@2.0.1:
+    resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
+    engines: {node: '>=0.10.0'}
+    dev: false
+
+  /strip-json-comments@3.1.1:
+    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
+    engines: {node: '>=8'}
+    dev: true
+
+  /supports-color@5.5.0:
+    resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
+    engines: {node: '>=4'}
+    dependencies:
+      has-flag: 3.0.0
+
+  /supports-color@7.2.0:
+    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
+    engines: {node: '>=8'}
+    dependencies:
+      has-flag: 4.0.0
+    dev: true
+
+  /supports-color@8.1.1:
+    resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      has-flag: 4.0.0
+    dev: true
+
+  /supports-preserve-symlinks-flag@1.0.0:
+    resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
+    engines: {node: '>= 0.4'}
+    dev: true
+
+  /synckit@0.11.11:
+    resolution: {integrity: sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    dependencies:
+      '@pkgr/core': 0.2.9
+    dev: true
+
+  /tape@1.0.4:
+    resolution: {integrity: sha512-ZJJxfxdPJWgq45Un77uYlI0/R9AkW7/sByPSb915VED2MgNm5r2UwXQwvECabIrpZKiF3sc4VaeDNljLRgMRhw==}
+    hasBin: true
+    dependencies:
+      deep-equal: 0.0.0
+      defined: 0.0.0
+      jsonify: 0.0.1
+      through: 2.3.8
+    dev: false
+
+  /tar-fs@2.1.4:
+    resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==}
+    dependencies:
+      chownr: 1.1.4
+      mkdirp-classic: 0.5.3
+      pump: 3.0.3
+      tar-stream: 2.2.0
+    dev: false
+
+  /tar-stream@2.2.0:
+    resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
+    engines: {node: '>=6'}
+    dependencies:
+      bl: 4.1.0
+      end-of-stream: 1.4.5
+      fs-constants: 1.0.0
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+    dev: false
+
+  /tar@6.2.1:
+    resolution: {integrity: sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==}
+    engines: {node: '>=10'}
+    dependencies:
+      chownr: 2.0.0
+      fs-minipass: 2.1.0
+      minipass: 5.0.0
+      minizlib: 2.1.2
+      mkdirp: 1.0.4
+      yallist: 4.0.0
+    dev: false
+
+  /test-exclude@6.0.0:
+    resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==}
+    engines: {node: '>=8'}
+    dependencies:
+      '@istanbuljs/schema': 0.1.3
+      glob: 7.2.3
+      minimatch: 3.1.2
+    dev: true
+
+  /through@2.3.8:
+    resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
+    dev: false
+
+  /tmpl@1.0.5:
+    resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==}
+    dev: true
+
+  /to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+    requiresBuild: true
+    dependencies:
+      is-number: 7.0.0
+    dev: true
+
+  /toidentifier@1.0.1:
+    resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
+    engines: {node: '>=0.6'}
+    dev: false
+
+  /touch@3.1.1:
+    resolution: {integrity: sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==}
+    hasBin: true
+    dev: true
+
+  /tr46@5.1.1:
+    resolution: {integrity: sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==}
+    engines: {node: '>=18'}
+    dependencies:
+      punycode: 2.3.1
+    dev: false
+
+  /tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: false
+
+  /type-check@0.4.0:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+    dependencies:
+      prelude-ls: 1.2.1
+    dev: true
+
+  /type-detect@4.0.8:
+    resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /type-fest@0.21.3:
+    resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /type-is@2.0.1:
+    resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
+    engines: {node: '>= 0.6'}
+    dependencies:
+      content-type: 1.0.5
+      media-typer: 1.1.0
+      mime-types: 3.0.1
+    dev: false
+
+  /typed-array-buffer@1.0.3:
+    resolution: {integrity: sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      is-typed-array: 1.1.15
+    dev: true
+
+  /typed-array-byte-length@1.0.3:
+    resolution: {integrity: sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      has-proto: 1.2.0
+      is-typed-array: 1.1.15
+    dev: true
+
+  /typed-array-byte-offset@1.0.4:
+    resolution: {integrity: sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      has-proto: 1.2.0
+      is-typed-array: 1.1.15
+      reflect.getprototypeof: 1.0.10
+    dev: true
+
+  /typed-array-length@1.0.7:
+    resolution: {integrity: sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.8
+      for-each: 0.3.5
+      gopd: 1.2.0
+      is-typed-array: 1.1.15
+      possible-typed-array-names: 1.1.0
+      reflect.getprototypeof: 1.0.10
+    dev: true
+
+  /uid-safe@2.1.5:
+    resolution: {integrity: sha512-KPHm4VL5dDXKz01UuEd88Df+KzynaohSL9fBh096KWAxSKZQDI2uBrVqtvRM4rwrIrRRKsdLNML/lnaaVSRioA==}
+    engines: {node: '>= 0.8'}
+    dependencies:
+      random-bytes: 1.0.0
+    dev: false
+
+  /uid2@0.0.4:
+    resolution: {integrity: sha512-IevTus0SbGwQzYh3+fRsAMTVVPOoIVufzacXcHPmdlle1jUpq7BRL+mw3dgeLanvGZdwwbWhRV6XrcFNdBmjWA==}
+    dev: false
+
+  /unbox-primitive@1.1.0:
+    resolution: {integrity: sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      has-bigints: 1.1.0
+      has-symbols: 1.1.0
+      which-boxed-primitive: 1.1.1
+    dev: true
+
+  /undefsafe@2.0.5:
+    resolution: {integrity: sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==}
+    dev: true
+
+  /undici-types@7.16.0:
+    resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
+    dev: true
+
+  /unicode-canonical-property-names-ecmascript@2.0.1:
+    resolution: {integrity: sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /unicode-match-property-ecmascript@2.0.0:
+    resolution: {integrity: sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==}
+    engines: {node: '>=4'}
+    dependencies:
+      unicode-canonical-property-names-ecmascript: 2.0.1
+      unicode-property-aliases-ecmascript: 2.2.0
+    dev: true
+
+  /unicode-match-property-value-ecmascript@2.2.1:
+    resolution: {integrity: sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /unicode-property-aliases-ecmascript@2.2.0:
+    resolution: {integrity: sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==}
+    engines: {node: '>=4'}
+    dev: true
+
+  /unique-filename@1.1.1:
+    resolution: {integrity: sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==}
+    requiresBuild: true
+    dependencies:
+      unique-slug: 2.0.2
+    dev: false
+    optional: true
+
+  /unique-slug@2.0.2:
+    resolution: {integrity: sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w==}
+    requiresBuild: true
+    dependencies:
+      imurmurhash: 0.1.4
+    dev: false
+    optional: true
+
+  /unpipe@1.0.0:
+    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /unrs-resolver@1.11.1:
+    resolution: {integrity: sha512-bSjt9pjaEBnNiGgc9rUiHGKv5l4/TGzDmYw3RhnkJGtLhbnnA/5qJj7x3dNDCRx/PJxu774LlH8lCOlB4hEfKg==}
+    requiresBuild: true
+    dependencies:
+      napi-postinstall: 0.3.4
+    optionalDependencies:
+      '@unrs/resolver-binding-android-arm-eabi': 1.11.1
+      '@unrs/resolver-binding-android-arm64': 1.11.1
+      '@unrs/resolver-binding-darwin-arm64': 1.11.1
+      '@unrs/resolver-binding-darwin-x64': 1.11.1
+      '@unrs/resolver-binding-freebsd-x64': 1.11.1
+      '@unrs/resolver-binding-linux-arm-gnueabihf': 1.11.1
+      '@unrs/resolver-binding-linux-arm-musleabihf': 1.11.1
+      '@unrs/resolver-binding-linux-arm64-gnu': 1.11.1
+      '@unrs/resolver-binding-linux-arm64-musl': 1.11.1
+      '@unrs/resolver-binding-linux-ppc64-gnu': 1.11.1
+      '@unrs/resolver-binding-linux-riscv64-gnu': 1.11.1
+      '@unrs/resolver-binding-linux-riscv64-musl': 1.11.1
+      '@unrs/resolver-binding-linux-s390x-gnu': 1.11.1
+      '@unrs/resolver-binding-linux-x64-gnu': 1.11.1
+      '@unrs/resolver-binding-linux-x64-musl': 1.11.1
+      '@unrs/resolver-binding-wasm32-wasi': 1.11.1
+      '@unrs/resolver-binding-win32-arm64-msvc': 1.11.1
+      '@unrs/resolver-binding-win32-ia32-msvc': 1.11.1
+      '@unrs/resolver-binding-win32-x64-msvc': 1.11.1
+    dev: true
+
+  /update-browserslist-db@1.1.3(browserslist@4.26.3):
+    resolution: {integrity: sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+    dependencies:
+      browserslist: 4.26.3
+      escalade: 3.2.0
+      picocolors: 1.1.1
+    dev: true
+
+  /uri-js@4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+    dependencies:
+      punycode: 2.3.1
+    dev: true
+
+  /util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+    requiresBuild: true
+    dev: false
+
+  /utils-merge@1.0.1:
+    resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==}
+    engines: {node: '>= 0.4.0'}
+    dev: false
+
+  /v8-to-istanbul@9.3.0:
+    resolution: {integrity: sha512-kiGUalWN+rgBJ/1OHZsBtU4rXZOfj/7rKQxULKlIzwzQSvMJUUNgPwJEEh7gU6xEVxC0ahoOBvN2YI8GH6FNgA==}
+    engines: {node: '>=10.12.0'}
+    dependencies:
+      '@jridgewell/trace-mapping': 0.3.31
+      '@types/istanbul-lib-coverage': 2.0.6
+      convert-source-map: 2.0.0
+    dev: true
+
+  /v8flags@3.2.0:
+    resolution: {integrity: sha512-mH8etigqMfiGWdeXpaaqGfs6BndypxusHHcv2qSHyZkGEznCd/qAXCWWRzeowtL54147cktFOC4P5y+kl8d8Jg==}
+    engines: {node: '>= 0.10'}
+    dependencies:
+      homedir-polyfill: 1.0.3
+    dev: true
+
+  /vary@1.1.2:
+    resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
+    engines: {node: '>= 0.8'}
+    dev: false
+
+  /walker@1.0.8:
+    resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==}
+    dependencies:
+      makeerror: 1.0.12
+    dev: true
+
+  /web-worker@1.5.0:
+    resolution: {integrity: sha512-RiMReJrTAiA+mBjGONMnjVDP2u3p9R1vkcGz6gDIrOMT3oGuYwX2WRMYI9ipkphSuE5XKEhydbhNEJh4NY9mlw==}
+    dev: false
+
+  /webidl-conversions@7.0.0:
+    resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
+    engines: {node: '>=12'}
+    dev: false
+
+  /whatwg-url@14.2.0:
+    resolution: {integrity: sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==}
+    engines: {node: '>=18'}
+    dependencies:
+      tr46: 5.1.1
+      webidl-conversions: 7.0.0
+    dev: false
+
+  /which-boxed-primitive@1.1.1:
+    resolution: {integrity: sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      is-bigint: 1.1.0
+      is-boolean-object: 1.2.2
+      is-number-object: 1.1.1
+      is-string: 1.1.1
+      is-symbol: 1.1.1
+    dev: true
+
+  /which-builtin-type@1.2.1:
+    resolution: {integrity: sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bound: 1.0.4
+      function.prototype.name: 1.1.8
+      has-tostringtag: 1.0.2
+      is-async-function: 2.1.1
+      is-date-object: 1.1.0
+      is-finalizationregistry: 1.1.1
+      is-generator-function: 1.1.2
+      is-regex: 1.2.1
+      is-weakref: 1.1.1
+      isarray: 2.0.5
+      which-boxed-primitive: 1.1.1
+      which-collection: 1.0.2
+      which-typed-array: 1.1.19
+    dev: true
+
+  /which-collection@1.0.2:
+    resolution: {integrity: sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      is-map: 2.0.3
+      is-set: 2.0.3
+      is-weakmap: 2.0.2
+      is-weakset: 2.0.4
+    dev: true
+
+  /which-typed-array@1.1.19:
+    resolution: {integrity: sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      available-typed-arrays: 1.0.7
+      call-bind: 1.0.8
+      call-bound: 1.0.4
+      for-each: 0.3.5
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-tostringtag: 1.0.2
+    dev: true
+
+  /which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+    dependencies:
+      isexe: 2.0.0
+
+  /wide-align@1.1.5:
+    resolution: {integrity: sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==}
+    requiresBuild: true
+    dependencies:
+      string-width: 4.2.3
+    dev: false
+    optional: true
+
+  /word-wrap@1.2.5:
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
+  /wrap-ansi@7.0.0:
+    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
+    engines: {node: '>=10'}
+    dependencies:
+      ansi-styles: 4.3.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+    dev: true
+
+  /wrap-ansi@8.1.0:
+    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
+    engines: {node: '>=12'}
+    dependencies:
+      ansi-styles: 6.2.3
+      string-width: 5.1.2
+      strip-ansi: 7.1.2
+    dev: true
+
+  /wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  /write-file-atomic@5.0.1:
+    resolution: {integrity: sha512-+QU2zd6OTD8XWIJCbffaiQeH9U73qIqafo1x6V1snCWYGJf6cVE0cDR4D8xRzcEnfI21IFrUPzPGtcPf8AC+Rw==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
+    dependencies:
+      imurmurhash: 0.1.4
+      signal-exit: 4.1.0
+    dev: true
+
+  /xml-utils@1.10.2:
+    resolution: {integrity: sha512-RqM+2o1RYs6T8+3DzDSoTRAUfrvaejbVHcp3+thnAtDKo8LskR+HomLajEy5UjTz24rpka7AxVBRR3g2wTUkJA==}
+    dev: false
+
+  /y18n@5.0.8:
+    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /yallist@3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+    dev: true
+
+  /yallist@4.0.0:
+    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
+    dev: false
+
+  /yargs-parser@21.1.1:
+    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
+    engines: {node: '>=12'}
+    dev: true
+
+  /yargs@17.7.2:
+    resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
+    engines: {node: '>=12'}
+    dependencies:
+      cliui: 8.0.1
+      escalade: 3.2.0
+      get-caller-file: 2.0.5
+      require-directory: 2.1.1
+      string-width: 4.2.3
+      y18n: 5.0.8
+      yargs-parser: 21.1.1
+    dev: true
+
+  /yocto-queue@0.1.0:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+    dev: true
+
+  /zstddec@0.1.0:
+    resolution: {integrity: sha512-w2NTI8+3l3eeltKAdK8QpiLo/flRAr2p8AGeakfMZOXBxOg9HIu4LVDxBi81sYgVhFhdJjv1OrB5ssI8uFPoLg==}
+    dev: false
+
+  /zustand@5.0.8:
+    resolution: {integrity: sha512-gyPKpIaxY9XcO2vSMrLbiER7QMAMGOQZVRdJ6Zi782jkbzZygq5GI9nG8g+sMgitRtndwaBSl7uiqC49o1SSiw==}
+    engines: {node: '>=12.20.0'}
+    peerDependencies:
+      '@types/react': '>=18.0.0'
+      immer: '>=9.0.6'
+      react: '>=18.0.0'
+      use-sync-external-store: '>=1.2.0'
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      immer:
+        optional: true
+      react:
+        optional: true
+      use-sync-external-store:
+        optional: true
+    dev: false
diff --git a/project-final/.gitignore b/project-final/.gitignore
new file mode 100644
index 0000000000..a547bf36d8
--- /dev/null
+++ b/project-final/.gitignore
@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
diff --git a/project-final/README.md b/project-final/README.md
new file mode 100644
index 0000000000..4866cf0f14
--- /dev/null
+++ b/project-final/README.md
@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
diff --git a/project-final/eslint.config.js b/project-final/eslint.config.js
new file mode 100644
index 0000000000..b19330b103
--- /dev/null
+++ b/project-final/eslint.config.js
@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs['recommended-latest'],
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])
diff --git a/project-final/index.html b/project-final/index.html
new file mode 100644
index 0000000000..06c06dcb37
--- /dev/null
+++ b/project-final/index.html
@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>project-final</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
diff --git a/project-final/package.json b/project-final/package.json
new file mode 100644
index 0000000000..5f8d30b4d4
--- /dev/null
+++ b/project-final/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "project-final",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.36.0",
+    "@types/react": "^19.1.13",
+    "@types/react-dom": "^19.1.9",
+    "@vitejs/plugin-react": "^5.0.3",
+    "eslint": "^9.36.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "eslint-plugin-react-refresh": "^0.4.20",
+    "globals": "^16.4.0",
+    "typescript": "~5.8.3",
+    "typescript-eslint": "^8.44.0",
+    "vite": "npm:rolldown-vite@7.1.12"
+  },
+  "overrides": {
+    "vite": "npm:rolldown-vite@7.1.12"
+  }
+}
diff --git a/project-final/public/vite.svg b/project-final/public/vite.svg
new file mode 100644
index 0000000000..e7b8dfb1b2
--- /dev/null
+++ b/project-final/public/vite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>
\ No newline at end of file
diff --git a/project-final/src/App.css b/project-final/src/App.css
new file mode 100644
index 0000000000..b9d355df2a
--- /dev/null
+++ b/project-final/src/App.css
@@ -0,0 +1,42 @@
+#root {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 2rem;
+  text-align: center;
+}
+
+.logo {
+  height: 6em;
+  padding: 1.5em;
+  will-change: filter;
+  transition: filter 300ms;
+}
+.logo:hover {
+  filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.react:hover {
+  filter: drop-shadow(0 0 2em #61dafbaa);
+}
+
+@keyframes logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  a:nth-of-type(2) .logo {
+    animation: logo-spin infinite 20s linear;
+  }
+}
+
+.card {
+  padding: 2em;
+}
+
+.read-the-docs {
+  color: #888;
+}
diff --git a/project-final/src/App.tsx b/project-final/src/App.tsx
new file mode 100644
index 0000000000..3d7ded3ff6
--- /dev/null
+++ b/project-final/src/App.tsx
@@ -0,0 +1,35 @@
+import { useState } from 'react'
+import reactLogo from './assets/react.svg'
+import viteLogo from '/vite.svg'
+import './App.css'
+
+function App() {
+  const [count, setCount] = useState(0)
+
+  return (
+    <>
+      <div>
+        <a href="https://vite.dev" target="_blank">
+          <img src={viteLogo} className="logo" alt="Vite logo" />
+        </a>
+        <a href="https://react.dev" target="_blank">
+          <img src={reactLogo} className="logo react" alt="React logo" />
+        </a>
+      </div>
+      <h1>Vite + React</h1>
+      <div className="card">
+        <button onClick={() => setCount((count) => count + 1)}>
+          count is {count}
+        </button>
+        <p>
+          Edit <code>src/App.tsx</code> and save to test HMR
+        </p>
+      </div>
+      <p className="read-the-docs">
+        Click on the Vite and React logos to learn more
+      </p>
+    </>
+  )
+}
+
+export default App
diff --git a/project-final/src/assets/react.svg b/project-final/src/assets/react.svg
new file mode 100644
index 0000000000..6c87de9bb3
--- /dev/null
+++ b/project-final/src/assets/react.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>
\ No newline at end of file
diff --git a/project-final/src/index.css b/project-final/src/index.css
new file mode 100644
index 0000000000..08a3ac9e1e
--- /dev/null
+++ b/project-final/src/index.css
@@ -0,0 +1,68 @@
+:root {
+  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+
+  color-scheme: light dark;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+  font-weight: 500;
+  color: #646cff;
+  text-decoration: inherit;
+}
+a:hover {
+  color: #535bf2;
+}
+
+body {
+  margin: 0;
+  display: flex;
+  place-items: center;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+h1 {
+  font-size: 3.2em;
+  line-height: 1.1;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+button:hover {
+  border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  a:hover {
+    color: #747bff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}
diff --git a/project-final/src/main.tsx b/project-final/src/main.tsx
new file mode 100644
index 0000000000..bef5202a32
--- /dev/null
+++ b/project-final/src/main.tsx
@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)
diff --git a/project-final/tsconfig.app.json b/project-final/tsconfig.app.json
new file mode 100644
index 0000000000..a9b5a59ca6
--- /dev/null
+++ b/project-final/tsconfig.app.json
@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}
diff --git a/project-final/tsconfig.json b/project-final/tsconfig.json
new file mode 100644
index 0000000000..1ffef600d9
--- /dev/null
+++ b/project-final/tsconfig.json
@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}
diff --git a/project-final/tsconfig.node.json b/project-final/tsconfig.node.json
new file mode 100644
index 0000000000..7a77bab3be
--- /dev/null
+++ b/project-final/tsconfig.node.json
@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": [],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}
diff --git a/project-final/vite.config.ts b/project-final/vite.config.ts
new file mode 100644
index 0000000000..8b0f57b91a
--- /dev/null
+++ b/project-final/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})
diff --git a/styles.css b/styles.css
new file mode 100644
index 0000000000..6574028e2a
--- /dev/null
+++ b/styles.css
@@ -0,0 +1,97 @@
+/* Base styles */
+body {
+    font-family: Arial, sans-serif;
+    background-color: #f0f0f0;
+    background-image: url('Flower 1.png');
+    background-size: cover;
+    background-position: center;
+    background-repeat: no-repeat;
+    height: 100vh;
+    margin: 0;
+    padding: 0; 
+}
+
+.container {
+    max-width: 90%;
+    margin: 0 auto;
+    text-align: center;
+    padding: 20px;
+    background-color: rgba(255, 255, 255, 0.5);
+    border-radius: 10px;
+    box-shadow: 0 0 10px rgba(0, 0, 0, 0.3);
+    margin-top: 5%;
+}
+
+h1 {
+    font-size: 2rem;
+}
+
+input[type="text"] {
+    width: 100%;
+    padding: 10px;
+    margin: 10px 0;
+    border: 1px solid #ccc;
+    border-radius: 5px;
+}
+
+button {
+    background-color: #007BFF;
+    color: #fff;
+    border: none;
+    padding: 10px 20px;
+    border-radius: 5px;
+    cursor: pointer;
+    transition: background-color 0.3s;
+}
+
+button:hover, button:focus {
+    background-color: #0056b3;
+    outline: 2px solid #0056b3;
+}
+
+.weather-info {
+    margin-top: 20px;
+}
+
+/* Responsive styles */
+@media (min-width: 320px) {
+    h1 {
+        font-size: 1.5rem;
+    }
+}
+
+@media (min-width: 480px) {
+    .container {
+        max-width: 400px;
+    }
+    h1 {
+        font-size: 1.8rem;
+    }
+}
+
+@media (min-width: 768px) {
+    .container {
+        max-width: 600px;
+    }
+    h1 {
+        font-size: 2.2rem;
+    }
+}
+
+@media (min-width: 1024px) {
+    .container {
+        max-width: 800px;
+    }
+    h1 {
+        font-size: 2.5rem;
+    }
+}
+
+@media (min-width: 1600px) {
+    .container {
+        max-width: 1200px;
+    }
+    h1 {
+        font-size: 3rem;
+    }
+}
diff --git a/tailwindconfig.js b/tailwindconfig.js
new file mode 100644
index 0000000000..197808c9f7
--- /dev/null
+++ b/tailwindconfig.js
@@ -0,0 +1,37 @@
+/ ** @type {import('tailwindcss').Config*/
+module.exports = {
+  content: ["./src/**/*.{html,js}]],
+    theme: {
+      extend: {}
+    },
+    plugins: [],
+    }
+}
+
+const colors = require('tailwindcss/colors')
+module.exports = {
+  mode:'jit',
+  purge: [`./src/**/*.{js,jsx,ts,tsx}`, `./public/index.html'],
+  darkMode: 'class', // or 'media' or 'class'
+  theme: {
+    extend: {}
+    colors:{
+      bg-primary: #'202225',
+      bg-secondary: #'5865f2',
+      gray: colors.trueGray,
+      900: '#202225',
+      800: '#2f3136',
+      700: '#36393f',
+      600: '#4f545c',
+      400: '#d4d7dc',
+      300: '#e3e5e8',
+      200: '#ohedef',
+      100: ,#f2f3f5',
+    },
+    },
+  },
+  variants: {
+    extend: {},
+  },
+  plugins: [],
+}
\ No newline at end of file
diff --git a/touch routes/auth.js b/touch routes/auth.js
new file mode 100644
index 0000000000..56c9db470d
--- /dev/null
+++ b/touch routes/auth.js	
@@ -0,0 +1,129 @@
+var express = require('express');
+var express = require('express');
+var passport = require('passport');
+var FacebookStrategy = require('passport-facebook');
+var db = require('../db')
+passport.use(new FacebookStrategy({
+  clientID: process.env['FACEBOOK_CLIENT_ID'],
+  clientSecret: process.env['FACEBOOK_CLIENT_SECRET'],
+  callbackURL: '/oauth2/redirect/facebook',
+  state: true
+}, function verify(accessToken, refreshToken, profile, cb) {
+  db.get('SELECT * FROM federated_credentials WHERE provider = ? AND subject = ?', [
+    'https://www.facebook.com',
+    profile.id
+  ], function(err, row) {
+    if (err) { return cb(err); }
+    if (!row) {
+      db.run('INSERT INTO users (name) VALUES (?)', [
+        profile.displayName
+      ], function(err) {
+        if (err) { return cb(err); }
+        
+        var id = this.lastID;
+        db.run('INSERT INTO federated_credentials (user_id, provider, subject) VALUES (?, ?, ?)', [
+          id,
+          'https://www.facebook.com',
+          profile.id
+        ], function(err) {
+          if (err) { return cb(err); }
+          var user = {
+            id: id,
+            name: profile.displayName
+          };
+          return cb(null, user);
+        });
+      });
+    } else {
+      db.get('SELECT * FROM users WHERE id = ?', [ row.user_id ], function(err, row) {
+        if (err) { return cb(err); }
+        if (!row) { return cb(null, false); }
+        return cb(null, row);
+      });
+    }
+  });
+}));
+var router = express.Router();
+
+router.get('/login', function(req, res, next) {
+  router.get('/login/federated/facebook', passport.authenticate('facebook'));
+  res.render('login');
+});
+module.exports = router;
+var express = require('express');
+var passport = require('passport');
+var FacebookStrategy = require('passport-facebook');
+var session = require('express-session');
+var passport = require('passport');
+var db = require('../db');
+var router = express.Router();
+passport.use(new FacebookStrategy({
+  clientID: process.env['FACEBOOK_CLIENT_ID'],
+  clientSecret: process.env['FACEBOOK_CLIENT_SECRET'],
+  callbackURL: '/oauth2/redirect/facebook',
+  state: true
+}, function verify(accessToken, refreshToken, profile, cb) {
+  db.get('SELECT * FROM federated_credentials WHERE provider = ? AND subject = ?', [
+    router.get('/oauth2/redirect/facebook', passport.authenticate('facebook', {
+      successRedirect: '/',
+      failureRedirect: '/login'
+    }));
+    'https://www.facebook.com',
+    profile.id
+  ], function(err, row) {
+    if (err) { return cb(err); }
+    if (!row) {
+      db.run('INSERT INTO users (name) VALUES (?)', [
+        profile.displayName
+      ], function(err) {
+        if (err) { return cb(err); }
+        
+        var id = this.lastID;
+        db.run('INSERT INTO federated_credentials (user_id, provider, subject) VALUES (?, ?, ?)', [
+          id,
+          'https://www.facebook.com',
+          profile.id
+        ], function(err) {
+          if (err) { return cb(err); }
+          var user = {
+            id: id,
+            name: profile.displayName
+          };
+          return cb(null, user);
+        });
+      });
+    } else {
+      db.get('SELECT * FROM users WHERE id = ?', [ row.user_id ], function(err, row) {
+        if (err) { return cb(err); }
+        if (!row) { return cb(null, false); }
+        return cb(null, row);
+      });
+    }
+  });
+  passport.serializeUser(function(user, cb) {
+    process.nextTick(function() {
+      cb(null, { id: user.id, username: user.username, name: user.name });
+    });
+  });
+  
+  passport.deserializeUser(function(user, cb) {
+    process.nextTick(function() {
+      return cb(null, user);
+    });
+  });
+}));
+router.get('/login', function(req, res, next) {
+  res.render('login');
+});
+router.get('/login/federated/facebook', passport.authenticate('facebook'));
+router.get('/oauth2/redirect/facebook', passport.authenticate('facebook', {
+  successRedirect: '/',
+  failureRedirect: '/login'
+}));
+router.post('/logout', function(req, res, next) {
+  req.logout(function(err) {
+    if (err) { return next(err); }
+    res.redirect('/');
+  });
+});
+module.exports = router;
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000000..21696fb7db
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,9 @@
+{
+    "compilerOptions": {
+      "lib": ["esnext"],
+      "noEmit": true,
+      "isolatedModules": true,
+      "moduleResolution": "nodenext",
+      "allowImportingTsExtensions": true
+    }
+  }
\ No newline at end of file
diff --git a/vite.config.ts b/vite.config.ts
new file mode 100644
index 0000000000..4022c8669a
--- /dev/null
+++ b/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import tailwindcss from '@tailwindcss/vite'
+export default defineConfig({
+  plugins: [
+    tailwindcss(),
+  ],
+})
\ No newline at end of file
diff --git a/webpack.config.js b/webpack.config.js
new file mode 100644
index 0000000000..ca221f5f00
--- /dev/null
+++ b/webpack.config.js
@@ -0,0 +1,13 @@
+module: {
+    rules: [
+      {
+        loader: "babel-loader",
+        options: {
+          rootMode: "upward",
+        },
+      },
+    ];
+  }
+  module.exports = {
+    entry: ["@babel/polyfill", "./app/js"],
+  };
\ No newline at end of file
diff --git a/wrapper.js b/wrapper.js
new file mode 100644
index 0000000000..409ac3a6fa
--- /dev/null
+++ b/wrapper.js
@@ -0,0 +1,3 @@
+module.exports = require("babel-jest").default.createTransformer({
+    rootMode: "upward",
+  });
\ No newline at end of file
diff --git a/~/craco.config.js b/~/craco.config.js
new file mode 100644
index 0000000000..880ea08599
--- /dev/null
+++ b/~/craco.config.js
@@ -0,0 +1,11 @@
+module.exports = {
+    style: {
+        postcss: {
+            plugins: [
+                require('tailwindcss'),
+                require('autoprefixer'),
+            ],
+
+        },
+    },
+}
\ No newline at end of file