first commit

node_modules/metro-runtime/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "metro-runtime",
+  "version": "0.83.3",
+  "description": "🚇 Module required for evaluating Metro bundles.",
+  "exports": {
+    "./package.json": "./package.json",
+    "./modules/asyncRequire": "./src/modules/asyncRequire.js",
+    "./modules/empty-module": "./src/modules/empty-module.js",
+    "./modules/HMRClient": "./src/modules/HMRClient.js",
+    "./modules/null-module": "./src/modules/null-module.js",
+    "./polyfills/require": "./src/polyfills/require.js",
+    "./private/*": "./src/*.js",
+    "./src/*.js": "./src/*.js",
+    "./src/*": "./src/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:facebook/metro.git"
+  },
+  "scripts": {
+    "prepare-release": "test -d build && rm -rf src.real && mv src src.real && mv build src",
+    "cleanup-release": "test ! -e build && mv src build && mv src.real src"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@babel/runtime": "^7.25.0",
+    "flow-enums-runtime": "^0.0.6"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.2",
+    "react": "19.1.1",
+    "react-refresh": "^0.14.0",
+    "react-test-renderer": "19.1.1"
+  },
+  "engines": {
+    "node": ">=20.19.4"
+  }
+}

node_modules/metro-runtime/src/modules/HMRClient.js

@@ -0,0 +1,160 @@
+"use strict";
+
+const EventEmitter = require("./vendor/eventemitter3");
+const inject = ({ module: [id, code], sourceURL }) => {
+  if (global.globalEvalWithSourceUrl) {
+    global.globalEvalWithSourceUrl(code, sourceURL);
+  } else {
+    eval(code);
+  }
+};
+const injectUpdate = (update) => {
+  update.added.forEach(inject);
+  update.modified.forEach(inject);
+};
+class HMRClient extends EventEmitter {
+  _isEnabled = false;
+  _pendingUpdate = null;
+  _queue = [];
+  _state = "opening";
+  constructor(url) {
+    super();
+    this._ws = new global.WebSocket(url);
+    this._ws.onopen = () => {
+      this._state = "open";
+      this.emit("open");
+      this._flushQueue();
+    };
+    this._ws.onerror = (error) => {
+      this.emit("connection-error", error);
+    };
+    this._ws.onclose = (closeEvent) => {
+      this._state = "closed";
+      this.emit("close", closeEvent);
+    };
+    this._ws.onmessage = (message) => {
+      const data = JSON.parse(String(message.data));
+      switch (data.type) {
+        case "bundle-registered":
+          this.emit("bundle-registered");
+          break;
+        case "update-start":
+          this.emit("update-start", data.body);
+          break;
+        case "update":
+          this.emit("update", data.body);
+          break;
+        case "update-done":
+          this.emit("update-done");
+          break;
+        case "error":
+          this.emit("error", data.body);
+          break;
+        default:
+          this.emit("error", {
+            type: "unknown-message",
+            message: data,
+          });
+      }
+    };
+    this.on("update", (update) => {
+      if (this._isEnabled) {
+        injectUpdate(update);
+      } else if (this._pendingUpdate == null) {
+        this._pendingUpdate = update;
+      } else {
+        this._pendingUpdate = mergeUpdates(this._pendingUpdate, update);
+      }
+    });
+  }
+  close() {
+    this._ws.close();
+  }
+  send(message) {
+    switch (this._state) {
+      case "opening":
+        this._queue.push(message);
+        break;
+      case "open":
+        this._ws.send(message);
+        break;
+      case "closed":
+        break;
+      default:
+        throw new Error("[WebSocketHMRClient] Unknown state: " + this._state);
+    }
+  }
+  _flushQueue() {
+    this._queue.forEach((message) => this.send(message));
+    this._queue.length = 0;
+  }
+  enable() {
+    this._isEnabled = true;
+    const update = this._pendingUpdate;
+    this._pendingUpdate = null;
+    if (update != null) {
+      injectUpdate(update);
+    }
+  }
+  disable() {
+    this._isEnabled = false;
+  }
+  isEnabled() {
+    return this._isEnabled;
+  }
+  hasPendingUpdates() {
+    return this._pendingUpdate != null;
+  }
+}
+function mergeUpdates(base, next) {
+  const addedIDs = new Set();
+  const deletedIDs = new Set();
+  const moduleMap = new Map();
+  applyUpdateLocally(base);
+  applyUpdateLocally(next);
+  function applyUpdateLocally(update) {
+    update.deleted.forEach((id) => {
+      if (addedIDs.has(id)) {
+        addedIDs.delete(id);
+      } else {
+        deletedIDs.add(id);
+      }
+      moduleMap.delete(id);
+    });
+    update.added.forEach((item) => {
+      const id = item.module[0];
+      if (deletedIDs.has(id)) {
+        deletedIDs.delete(id);
+      } else {
+        addedIDs.add(id);
+      }
+      moduleMap.set(id, item);
+    });
+    update.modified.forEach((item) => {
+      const id = item.module[0];
+      moduleMap.set(id, item);
+    });
+  }
+  const result = {
+    isInitialUpdate: next.isInitialUpdate,
+    revisionId: next.revisionId,
+    added: [],
+    modified: [],
+    deleted: [],
+  };
+  deletedIDs.forEach((id) => {
+    result.deleted.push(id);
+  });
+  moduleMap.forEach((item, id) => {
+    if (deletedIDs.has(id)) {
+      return;
+    }
+    if (addedIDs.has(id)) {
+      result.added.push(item);
+    } else {
+      result.modified.push(item);
+    }
+  });
+  return result;
+}
+module.exports = HMRClient;

node_modules/metro-runtime/src/modules/HMRClient.js.flow

@@ -0,0 +1,207 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+'use strict';
+import type {HmrModule} from './types';
+import type {HmrMessage, HmrUpdate} from './types';
+
+const EventEmitter = require('./vendor/eventemitter3');
+
+type SocketState = 'opening' | 'open' | 'closed';
+
+const inject = ({module: [id, code], sourceURL}: HmrModule) => {
+  // Some engines do not support `sourceURL` as a comment. We expose a
+  // `globalEvalWithSourceUrl` function to handle updates in that case.
+  if (global.globalEvalWithSourceUrl) {
+    global.globalEvalWithSourceUrl(code, sourceURL);
+  } else {
+    // eslint-disable-next-line no-eval
+    eval(code);
+  }
+};
+
+const injectUpdate = (update: HmrUpdate) => {
+  update.added.forEach(inject);
+  update.modified.forEach(inject);
+};
+
+class HMRClient extends EventEmitter {
+  _isEnabled: boolean = false;
+  _pendingUpdate: HmrUpdate | null = null;
+  _queue: Array<string> = [];
+  _state: SocketState = 'opening';
+  _ws: WebSocket;
+
+  constructor(url: string) {
+    super();
+
+    // Access the global WebSocket object only after enabling the client,
+    // since some polyfills do the initialization lazily.
+    this._ws = new global.WebSocket(url);
+    this._ws.onopen = () => {
+      this._state = 'open';
+      this.emit('open');
+      this._flushQueue();
+    };
+    this._ws.onerror = error => {
+      this.emit('connection-error', error);
+    };
+    this._ws.onclose = closeEvent => {
+      this._state = 'closed';
+      this.emit('close', closeEvent);
+    };
+    this._ws.onmessage = message => {
+      const data: HmrMessage = JSON.parse(String(message.data));
+
+      switch (data.type) {
+        case 'bundle-registered':
+          this.emit('bundle-registered');
+          break;
+
+        case 'update-start':
+          this.emit('update-start', data.body);
+          break;
+
+        case 'update':
+          this.emit('update', data.body);
+          break;
+
+        case 'update-done':
+          this.emit('update-done');
+          break;
+
+        case 'error':
+          this.emit('error', data.body);
+          break;
+
+        default:
+          this.emit('error', {type: 'unknown-message', message: data});
+      }
+    };
+
+    this.on('update', (update: HmrUpdate) => {
+      if (this._isEnabled) {
+        injectUpdate(update);
+      } else if (this._pendingUpdate == null) {
+        this._pendingUpdate = update;
+      } else {
+        this._pendingUpdate = mergeUpdates(this._pendingUpdate, update);
+      }
+    });
+  }
+
+  close(): void {
+    this._ws.close();
+  }
+
+  send(message: string): void {
+    switch (this._state) {
+      case 'opening':
+        this._queue.push(message);
+        break;
+      case 'open':
+        this._ws.send(message);
+        break;
+      case 'closed':
+        // Ignore.
+        break;
+      default:
+        throw new Error('[WebSocketHMRClient] Unknown state: ' + this._state);
+    }
+  }
+
+  _flushQueue(): void {
+    this._queue.forEach(message => this.send(message));
+    this._queue.length = 0;
+  }
+
+  enable() {
+    this._isEnabled = true;
+    const update = this._pendingUpdate;
+    this._pendingUpdate = null;
+    if (update != null) {
+      injectUpdate(update);
+    }
+  }
+
+  disable() {
+    this._isEnabled = false;
+  }
+
+  isEnabled(): boolean {
+    return this._isEnabled;
+  }
+
+  hasPendingUpdates(): boolean {
+    return this._pendingUpdate != null;
+  }
+}
+
+function mergeUpdates(base: HmrUpdate, next: HmrUpdate): HmrUpdate {
+  const addedIDs = new Set<number>();
+  const deletedIDs = new Set<number>();
+  const moduleMap = new Map<number, HmrModule>();
+
+  // Fill in the temporary maps and sets from both updates in their order.
+  applyUpdateLocally(base);
+  applyUpdateLocally(next);
+
+  function applyUpdateLocally(update: HmrUpdate) {
+    update.deleted.forEach(id => {
+      if (addedIDs.has(id)) {
+        addedIDs.delete(id);
+      } else {
+        deletedIDs.add(id);
+      }
+      moduleMap.delete(id);
+    });
+    update.added.forEach(item => {
+      const id = item.module[0];
+      if (deletedIDs.has(id)) {
+        deletedIDs.delete(id);
+      } else {
+        addedIDs.add(id);
+      }
+      moduleMap.set(id, item);
+    });
+    update.modified.forEach(item => {
+      const id = item.module[0];
+      moduleMap.set(id, item);
+    });
+  }
+
+  // Now reconstruct a unified update from our in-memory maps and sets.
+  // Applying it should be equivalent to applying both of them individually.
+  const result = {
+    isInitialUpdate: next.isInitialUpdate,
+    revisionId: next.revisionId,
+    added: ([]: Array<HmrModule>),
+    modified: ([]: Array<HmrModule>),
+    deleted: ([]: Array<number>),
+  };
+  deletedIDs.forEach(id => {
+    result.deleted.push(id);
+  });
+  moduleMap.forEach((item, id) => {
+    if (deletedIDs.has(id)) {
+      return;
+    }
+
+    if (addedIDs.has(id)) {
+      result.added.push(item);
+    } else {
+      result.modified.push(item);
+    }
+  });
+  return result;
+}
+
+module.exports = HMRClient;

node_modules/metro-runtime/src/modules/asyncRequire.js

@@ -0,0 +1,39 @@
+"use strict";
+
+function maybeLoadBundle(moduleID, paths) {
+  const loadBundle = global[`${__METRO_GLOBAL_PREFIX__}__loadBundleAsync`];
+  if (loadBundle != null) {
+    const stringModuleID = String(moduleID);
+    if (paths != null) {
+      const bundlePath = paths[stringModuleID];
+      if (bundlePath != null) {
+        return loadBundle(bundlePath);
+      }
+    }
+  }
+  return undefined;
+}
+function asyncRequireImpl(moduleID, paths) {
+  const maybeLoadBundlePromise = maybeLoadBundle(moduleID, paths);
+  const importAll = () => require.importAll(moduleID);
+  if (maybeLoadBundlePromise != null) {
+    return maybeLoadBundlePromise.then(importAll);
+  }
+  return importAll();
+}
+async function asyncRequire(moduleID, paths, moduleName) {
+  return asyncRequireImpl(moduleID, paths);
+}
+asyncRequire.unstable_importMaybeSync = function unstable_importMaybeSync(
+  moduleID,
+  paths,
+) {
+  return asyncRequireImpl(moduleID, paths);
+};
+asyncRequire.prefetch = function (moduleID, paths, moduleName) {
+  maybeLoadBundle(moduleID, paths)?.then(
+    () => {},
+    () => {},
+  );
+};
+module.exports = asyncRequire;

node_modules/metro-runtime/src/modules/asyncRequire.js.flow

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+type MetroRequire = {
+  (number): mixed,
+  importAll: <T>(number) => T,
+  ...
+};
+
+declare var require: MetroRequire;
+
+type DependencyMapPaths = ?$ReadOnly<{[moduleID: number | string]: mixed}>;
+
+declare var __METRO_GLOBAL_PREFIX__: string;
+
+function maybeLoadBundle(
+  moduleID: number,
+  paths: DependencyMapPaths,
+): void | Promise<void> {
+  const loadBundle: (bundlePath: mixed) => Promise<void> =
+    global[`${__METRO_GLOBAL_PREFIX__}__loadBundleAsync`];
+
+  if (loadBundle != null) {
+    const stringModuleID = String(moduleID);
+    if (paths != null) {
+      const bundlePath = paths[stringModuleID];
+      if (bundlePath != null) {
+        // NOTE: Errors will be swallowed by asyncRequire.prefetch
+        return loadBundle(bundlePath);
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function asyncRequireImpl<T>(
+  moduleID: number,
+  paths: DependencyMapPaths,
+): Promise<T> | T {
+  const maybeLoadBundlePromise = maybeLoadBundle(moduleID, paths);
+  const importAll = () => require.importAll<T>(moduleID);
+
+  if (maybeLoadBundlePromise != null) {
+    return maybeLoadBundlePromise.then(importAll);
+  }
+
+  return importAll();
+}
+
+async function asyncRequire<T>(
+  moduleID: number,
+  paths: DependencyMapPaths,
+  moduleName?: string, // unused
+): Promise<T> {
+  return asyncRequireImpl<T>(moduleID, paths);
+}
+
+// Synchronous version of asyncRequire, which can still return a promise
+// if the module is split.
+asyncRequire.unstable_importMaybeSync = function unstable_importMaybeSync<T>(
+  moduleID: number,
+  paths: DependencyMapPaths,
+): Promise<T> | T {
+  return asyncRequireImpl(moduleID, paths);
+};
+
+asyncRequire.prefetch = function (
+  moduleID: number,
+  paths: DependencyMapPaths,
+  moduleName?: string, // unused
+): void {
+  maybeLoadBundle(moduleID, paths)?.then(
+    () => {},
+    () => {},
+  );
+};
+
+module.exports = asyncRequire;

node_modules/metro-runtime/src/modules/empty-module.js

@@ -0,0 +1 @@
+"use strict";

node_modules/metro-runtime/src/modules/empty-module.js.flow

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict
+ */

node_modules/metro-runtime/src/modules/null-module.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = null;

node_modules/metro-runtime/src/modules/null-module.js.flow

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict
+ */
+
+module.exports = null;

node_modules/metro-runtime/src/modules/types.js

@@ -0,0 +1 @@
+"use strict";

node_modules/metro-runtime/src/modules/types.js.flow

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+export type ModuleMap = $ReadOnlyArray<[number, string]>;
+
+export type Bundle = {
+  +modules: ModuleMap,
+  +post: string,
+  +pre: string,
+};
+
+export type DeltaBundle = {
+  +added: ModuleMap,
+  +modified: ModuleMap,
+  +deleted: $ReadOnlyArray<number>,
+};
+
+export type BundleVariant =
+  | {+base: true, +revisionId: string, ...Bundle}
+  | {+base: false, +revisionId: string, ...DeltaBundle};
+
+export type BundleMetadata = {
+  +pre: number,
+  +post: number,
+  +modules: $ReadOnlyArray<[number, number]>,
+};
+
+export type FormattedError = {
+  +type: string,
+  +message: string,
+  +errors: Array<{description: string, ...}>,
+};
+
+export type HmrModule = {
+  +module: [number, string],
+  +sourceMappingURL: string,
+  +sourceURL: string,
+};
+
+export type HmrUpdate = {
+  +added: $ReadOnlyArray<HmrModule>,
+  +deleted: $ReadOnlyArray<number>,
+  +isInitialUpdate: boolean,
+  +modified: $ReadOnlyArray<HmrModule>,
+  +revisionId: string,
+};
+
+export type HmrUpdateMessage = {
+  +type: 'update',
+  +body: HmrUpdate,
+};
+
+export type HmrErrorMessage = {
+  +type: 'error',
+  +body: FormattedError,
+};
+
+export type HmrClientMessage =
+  | {
+      +type: 'register-entrypoints',
+      +entryPoints: Array<string>,
+    }
+  | {
+      +type: 'log',
+      +level:
+        | 'trace'
+        | 'info'
+        | 'warn'
+        | 'log'
+        | 'group'
+        | 'groupCollapsed'
+        | 'groupEnd'
+        | 'debug',
+      +data: Array<mixed>,
+    }
+  | {
+      +type: 'log-opt-in',
+    };
+
+export type HmrMessage =
+  | {
+      +type: 'bundle-registered',
+    }
+  | {
+      +type: 'update-start',
+      +body: {
+        +isInitialUpdate: boolean,
+      },
+    }
+  | {
+      +type: 'update-done',
+    }
+  | HmrUpdateMessage
+  | HmrErrorMessage;

node_modules/metro-runtime/src/modules/vendor/eventemitter3.js

@@ -0,0 +1,183 @@
+"use strict";
+
+var has = Object.prototype.hasOwnProperty,
+  prefix = "~";
+function Events() {}
+if (Object.create) {
+  Events.prototype = Object.create(null);
+  if (!new Events().__proto__) prefix = false;
+}
+function EE(fn, context, once) {
+  this.fn = fn;
+  this.context = context;
+  this.once = once || false;
+}
+function addListener(emitter, event, fn, context, once) {
+  if (typeof fn !== "function") {
+    throw new TypeError("The listener must be a function");
+  }
+  var listener = new EE(fn, context || emitter, once),
+    evt = prefix ? prefix + event : event;
+  if (!emitter._events[evt])
+    ((emitter._events[evt] = listener), emitter._eventsCount++);
+  else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+  else emitter._events[evt] = [emitter._events[evt], listener];
+  return emitter;
+}
+function clearEvent(emitter, evt) {
+  if (--emitter._eventsCount === 0) emitter._events = new Events();
+  else delete emitter._events[evt];
+}
+function EventEmitter() {
+  this._events = new Events();
+  this._eventsCount = 0;
+}
+EventEmitter.prototype.eventNames = function eventNames() {
+  var names = [],
+    events,
+    name;
+  if (this._eventsCount === 0) return names;
+  for (name in (events = this._events)) {
+    if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+  }
+  if (Object.getOwnPropertySymbols) {
+    return names.concat(Object.getOwnPropertySymbols(events));
+  }
+  return names;
+};
+EventEmitter.prototype.listeners = function listeners(event) {
+  var evt = prefix ? prefix + event : event,
+    handlers = this._events[evt];
+  if (!handlers) return [];
+  if (handlers.fn) return [handlers.fn];
+  for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+    ee[i] = handlers[i].fn;
+  }
+  return ee;
+};
+EventEmitter.prototype.listenerCount = function listenerCount(event) {
+  var evt = prefix ? prefix + event : event,
+    listeners = this._events[evt];
+  if (!listeners) return 0;
+  if (listeners.fn) return 1;
+  return listeners.length;
+};
+EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+  var evt = prefix ? prefix + event : event;
+  if (!this._events[evt]) return false;
+  var listeners = this._events[evt],
+    len = arguments.length,
+    args,
+    i;
+  if (listeners.fn) {
+    if (listeners.once)
+      this.removeListener(event, listeners.fn, undefined, true);
+    switch (len) {
+      case 1:
+        return (listeners.fn.call(listeners.context), true);
+      case 2:
+        return (listeners.fn.call(listeners.context, a1), true);
+      case 3:
+        return (listeners.fn.call(listeners.context, a1, a2), true);
+      case 4:
+        return (listeners.fn.call(listeners.context, a1, a2, a3), true);
+      case 5:
+        return (listeners.fn.call(listeners.context, a1, a2, a3, a4), true);
+      case 6:
+        return (listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true);
+    }
+    for (i = 1, args = new Array(len - 1); i < len; i++) {
+      args[i - 1] = arguments[i];
+    }
+    listeners.fn.apply(listeners.context, args);
+  } else {
+    var length = listeners.length,
+      j;
+    for (i = 0; i < length; i++) {
+      if (listeners[i].once)
+        this.removeListener(event, listeners[i].fn, undefined, true);
+      switch (len) {
+        case 1:
+          listeners[i].fn.call(listeners[i].context);
+          break;
+        case 2:
+          listeners[i].fn.call(listeners[i].context, a1);
+          break;
+        case 3:
+          listeners[i].fn.call(listeners[i].context, a1, a2);
+          break;
+        case 4:
+          listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+          break;
+        default:
+          if (!args)
+            for (j = 1, args = new Array(len - 1); j < len; j++) {
+              args[j - 1] = arguments[j];
+            }
+          listeners[i].fn.apply(listeners[i].context, args);
+      }
+    }
+  }
+  return true;
+};
+EventEmitter.prototype.on = function on(event, fn, context) {
+  return addListener(this, event, fn, context, false);
+};
+EventEmitter.prototype.once = function once(event, fn, context) {
+  return addListener(this, event, fn, context, true);
+};
+EventEmitter.prototype.removeListener = function removeListener(
+  event,
+  fn,
+  context,
+  once,
+) {
+  var evt = prefix ? prefix + event : event;
+  if (!this._events[evt]) return this;
+  if (!fn) {
+    clearEvent(this, evt);
+    return this;
+  }
+  var listeners = this._events[evt];
+  if (listeners.fn) {
+    if (
+      listeners.fn === fn &&
+      (!once || listeners.once) &&
+      (!context || listeners.context === context)
+    ) {
+      clearEvent(this, evt);
+    }
+  } else {
+    for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+      if (
+        listeners[i].fn !== fn ||
+        (once && !listeners[i].once) ||
+        (context && listeners[i].context !== context)
+      ) {
+        events.push(listeners[i]);
+      }
+    }
+    if (events.length)
+      this._events[evt] = events.length === 1 ? events[0] : events;
+    else clearEvent(this, evt);
+  }
+  return this;
+};
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+  var evt;
+  if (event) {
+    evt = prefix ? prefix + event : event;
+    if (this._events[evt]) clearEvent(this, evt);
+  } else {
+    this._events = new Events();
+    this._eventsCount = 0;
+  }
+  return this;
+};
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+EventEmitter.prefixed = prefix;
+EventEmitter.EventEmitter = EventEmitter;
+if ("undefined" !== typeof module) {
+  module.exports = EventEmitter;
+}

node_modules/metro-runtime/src/modules/vendor/eventemitter3.js.flow

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ *
+ * @flow
+ * @format
+ */
+'use strict';
+
+declare type ListenerFn = (...args: any[]) => mixed;
+declare class EventEmitter {
+  static constructor(): EventEmitter;
+  static prefixed: string | boolean;
+  eventNames(): (string | Symbol)[];
+  listeners(event: string | Symbol): ListenerFn[];
+  listenerCount(event: string | Symbol): number;
+  on(event: string | Symbol, listener: ListenerFn, context?: any): this;
+  addListener(
+    event: string | Symbol,
+    listener: ListenerFn,
+    context?: any,
+  ): this;
+  once(event: string | Symbol, listener: ListenerFn, context?: any): this;
+  removeAllListeners(event?: string | Symbol): this;
+  removeListener(
+    event: string | Symbol,
+    listener?: ListenerFn,
+    context?: any,
+    once?: boolean,
+  ): this;
+  off(
+    event: string | Symbol,
+    listener?: ListenerFn,
+    context?: any,
+    once?: boolean,
+  ): this;
+  emit(event: string, ...params?: any[]): this;
+}
+declare module.exports: Class<EventEmitter>;

node_modules/metro-runtime/src/polyfills/require.js

@@ -0,0 +1,711 @@
+"use strict";
+
+global.__r = metroRequire;
+global[`${__METRO_GLOBAL_PREFIX__}__d`] = define;
+global.__c = clear;
+global.__registerSegment = registerSegment;
+var modules = clear();
+const EMPTY = {};
+const CYCLE_DETECTED = {};
+const { hasOwnProperty } = {};
+if (__DEV__) {
+  global.$RefreshReg$ = global.$RefreshReg$ ?? (() => {});
+  global.$RefreshSig$ = global.$RefreshSig$ ?? (() => (type) => type);
+}
+function clear() {
+  modules = new Map();
+  return modules;
+}
+if (__DEV__) {
+  var verboseNamesToModuleIds = new Map();
+  var getModuleIdForVerboseName = (verboseName) => {
+    const moduleId = verboseNamesToModuleIds.get(verboseName);
+    if (moduleId == null) {
+      throw new Error(`Unknown named module: "${verboseName}"`);
+    }
+    return moduleId;
+  };
+  var initializingModuleIds = [];
+}
+function define(factory, moduleId, dependencyMap) {
+  if (modules.has(moduleId)) {
+    if (__DEV__) {
+      const inverseDependencies = arguments[4];
+      if (inverseDependencies) {
+        global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
+      }
+    }
+    return;
+  }
+  const mod = {
+    dependencyMap,
+    factory,
+    hasError: false,
+    importedAll: EMPTY,
+    importedDefault: EMPTY,
+    isInitialized: false,
+    publicModule: {
+      exports: {},
+    },
+  };
+  modules.set(moduleId, mod);
+  if (__DEV__) {
+    mod.hot = createHotReloadingObject();
+    const verboseName = arguments[3];
+    if (verboseName) {
+      mod.verboseName = verboseName;
+      verboseNamesToModuleIds.set(verboseName, moduleId);
+    }
+  }
+}
+function metroRequire(moduleId, maybeNameForDev) {
+  if (moduleId === null) {
+    if (__DEV__ && typeof maybeNameForDev === "string") {
+      throw new Error("Cannot find module '" + maybeNameForDev + "'");
+    }
+    throw new Error("Cannot find module");
+  }
+  if (__DEV__ && typeof moduleId === "string") {
+    const verboseName = moduleId;
+    moduleId = getModuleIdForVerboseName(verboseName);
+    console.warn(
+      `Requiring module "${verboseName}" by name is only supported for ` +
+        "debugging purposes and will BREAK IN PRODUCTION!",
+    );
+  }
+  const moduleIdReallyIsNumber = moduleId;
+  if (__DEV__) {
+    const initializingIndex = initializingModuleIds.indexOf(
+      moduleIdReallyIsNumber,
+    );
+    if (initializingIndex !== -1) {
+      const cycle = initializingModuleIds
+        .slice(initializingIndex)
+        .map((id) => modules.get(id)?.verboseName ?? "[unknown]");
+      if (shouldPrintRequireCycle(cycle)) {
+        cycle.push(cycle[0]);
+        console.warn(
+          `Require cycle: ${cycle.join(" -> ")}\n\n` +
+            "Require cycles are allowed, but can result in uninitialized values. " +
+            "Consider refactoring to remove the need for a cycle.",
+        );
+      }
+    }
+  }
+  const module = modules.get(moduleIdReallyIsNumber);
+  return module && module.isInitialized
+    ? module.publicModule.exports
+    : guardedLoadModule(moduleIdReallyIsNumber, module);
+}
+function shouldPrintRequireCycle(modules) {
+  const regExps =
+    global[__METRO_GLOBAL_PREFIX__ + "__requireCycleIgnorePatterns"];
+  if (!Array.isArray(regExps)) {
+    return true;
+  }
+  const isIgnored = (module) =>
+    module != null && regExps.some((regExp) => regExp.test(module));
+  return modules.every((module) => !isIgnored(module));
+}
+function metroImportDefault(moduleId) {
+  if (__DEV__ && typeof moduleId === "string") {
+    const verboseName = moduleId;
+    moduleId = getModuleIdForVerboseName(verboseName);
+  }
+  const moduleIdReallyIsNumber = moduleId;
+  const maybeInitializedModule = modules.get(moduleIdReallyIsNumber);
+  if (
+    maybeInitializedModule &&
+    maybeInitializedModule.importedDefault !== EMPTY
+  ) {
+    return maybeInitializedModule.importedDefault;
+  }
+  const exports = metroRequire(moduleIdReallyIsNumber);
+  const importedDefault =
+    exports && exports.__esModule ? exports.default : exports;
+  const initializedModule = modules.get(moduleIdReallyIsNumber);
+  return (initializedModule.importedDefault = importedDefault);
+}
+metroRequire.importDefault = metroImportDefault;
+function metroImportAll(moduleId) {
+  if (__DEV__ && typeof moduleId === "string") {
+    const verboseName = moduleId;
+    moduleId = getModuleIdForVerboseName(verboseName);
+  }
+  const moduleIdReallyIsNumber = moduleId;
+  const maybeInitializedModule = modules.get(moduleIdReallyIsNumber);
+  if (maybeInitializedModule && maybeInitializedModule.importedAll !== EMPTY) {
+    return maybeInitializedModule.importedAll;
+  }
+  const exports = metroRequire(moduleIdReallyIsNumber);
+  let importedAll;
+  if (exports && exports.__esModule) {
+    importedAll = exports;
+  } else {
+    importedAll = {};
+    if (exports) {
+      for (const key in exports) {
+        if (hasOwnProperty.call(exports, key)) {
+          importedAll[key] = exports[key];
+        }
+      }
+    }
+    importedAll.default = exports;
+  }
+  const initializedModule = modules.get(moduleIdReallyIsNumber);
+  return (initializedModule.importedAll = importedAll);
+}
+metroRequire.importAll = metroImportAll;
+metroRequire.context = function fallbackRequireContext() {
+  if (__DEV__) {
+    throw new Error(
+      "The experimental Metro feature `require.context` is not enabled in your project.\nThis can be enabled by setting the `transformer.unstable_allowRequireContext` property to `true` in your Metro configuration.",
+    );
+  }
+  throw new Error(
+    "The experimental Metro feature `require.context` is not enabled in your project.",
+  );
+};
+metroRequire.resolveWeak = function fallbackRequireResolveWeak() {
+  if (__DEV__) {
+    throw new Error(
+      "require.resolveWeak cannot be called dynamically. Ensure you are using the same version of `metro` and `metro-runtime`.",
+    );
+  }
+  throw new Error("require.resolveWeak cannot be called dynamically.");
+};
+let inGuard = false;
+function guardedLoadModule(moduleId, module) {
+  if (!inGuard && global.ErrorUtils) {
+    inGuard = true;
+    let returnValue;
+    try {
+      returnValue = loadModuleImplementation(moduleId, module);
+    } catch (e) {
+      global.ErrorUtils.reportFatalError(e);
+    }
+    inGuard = false;
+    return returnValue;
+  } else {
+    return loadModuleImplementation(moduleId, module);
+  }
+}
+const ID_MASK_SHIFT = 16;
+const LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;
+function unpackModuleId(moduleId) {
+  const segmentId = moduleId >>> ID_MASK_SHIFT;
+  const localId = moduleId & LOCAL_ID_MASK;
+  return {
+    segmentId,
+    localId,
+  };
+}
+metroRequire.unpackModuleId = unpackModuleId;
+function packModuleId(value) {
+  return (value.segmentId << ID_MASK_SHIFT) + value.localId;
+}
+metroRequire.packModuleId = packModuleId;
+const moduleDefinersBySegmentID = [];
+const definingSegmentByModuleID = new Map();
+function registerSegment(segmentId, moduleDefiner, moduleIds) {
+  moduleDefinersBySegmentID[segmentId] = moduleDefiner;
+  if (__DEV__) {
+    if (segmentId === 0 && moduleIds) {
+      throw new Error(
+        "registerSegment: Expected moduleIds to be null for main segment",
+      );
+    }
+    if (segmentId !== 0 && !moduleIds) {
+      throw new Error(
+        "registerSegment: Expected moduleIds to be passed for segment #" +
+          segmentId,
+      );
+    }
+  }
+  if (moduleIds) {
+    moduleIds.forEach((moduleId) => {
+      if (!modules.has(moduleId) && !definingSegmentByModuleID.has(moduleId)) {
+        definingSegmentByModuleID.set(moduleId, segmentId);
+      }
+    });
+  }
+}
+function loadModuleImplementation(moduleId, module) {
+  if (!module && moduleDefinersBySegmentID.length > 0) {
+    const segmentId = definingSegmentByModuleID.get(moduleId) ?? 0;
+    const definer = moduleDefinersBySegmentID[segmentId];
+    if (definer != null) {
+      definer(moduleId);
+      module = modules.get(moduleId);
+      definingSegmentByModuleID.delete(moduleId);
+    }
+  }
+  const nativeRequire = global.nativeRequire;
+  if (!module && nativeRequire) {
+    const { segmentId, localId } = unpackModuleId(moduleId);
+    nativeRequire(localId, segmentId);
+    module = modules.get(moduleId);
+  }
+  if (!module) {
+    throw unknownModuleError(moduleId);
+  }
+  if (module.hasError) {
+    throw module.error;
+  }
+  if (__DEV__) {
+    var Systrace = requireSystrace();
+    var Refresh = requireRefresh();
+  }
+  module.isInitialized = true;
+  const { factory, dependencyMap } = module;
+  if (__DEV__) {
+    initializingModuleIds.push(moduleId);
+  }
+  try {
+    if (__DEV__) {
+      Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
+    }
+    const moduleObject = module.publicModule;
+    if (__DEV__) {
+      moduleObject.hot = module.hot;
+      var prevRefreshReg = global.$RefreshReg$;
+      var prevRefreshSig = global.$RefreshSig$;
+      if (Refresh != null) {
+        const RefreshRuntime = Refresh;
+        global.$RefreshReg$ = (type, id) => {
+          const prefixedModuleId =
+            __METRO_GLOBAL_PREFIX__ + " " + moduleId + " " + id;
+          RefreshRuntime.register(type, prefixedModuleId);
+        };
+        global.$RefreshSig$ =
+          RefreshRuntime.createSignatureFunctionForTransform;
+      }
+    }
+    moduleObject.id = moduleId;
+    factory(
+      global,
+      metroRequire,
+      metroImportDefault,
+      metroImportAll,
+      moduleObject,
+      moduleObject.exports,
+      dependencyMap,
+    );
+    if (!__DEV__) {
+      module.factory = undefined;
+      module.dependencyMap = undefined;
+    }
+    if (__DEV__) {
+      Systrace.endEvent();
+      if (Refresh != null) {
+        const prefixedModuleId = __METRO_GLOBAL_PREFIX__ + " " + moduleId;
+        registerExportsForReactRefresh(
+          Refresh,
+          moduleObject.exports,
+          prefixedModuleId,
+        );
+      }
+    }
+    return moduleObject.exports;
+  } catch (e) {
+    module.hasError = true;
+    module.error = e;
+    module.isInitialized = false;
+    module.publicModule.exports = undefined;
+    throw e;
+  } finally {
+    if (__DEV__) {
+      if (initializingModuleIds.pop() !== moduleId) {
+        throw new Error(
+          "initializingModuleIds is corrupt; something is terribly wrong",
+        );
+      }
+      global.$RefreshReg$ = prevRefreshReg;
+      global.$RefreshSig$ = prevRefreshSig;
+    }
+  }
+}
+function unknownModuleError(id) {
+  let message = 'Requiring unknown module "' + id + '".';
+  if (__DEV__) {
+    message +=
+      " If you are sure the module exists, try restarting Metro. " +
+      "You may also want to run `yarn` or `npm install`.";
+  }
+  return Error(message);
+}
+if (__DEV__) {
+  metroRequire.Systrace = {
+    beginEvent: () => {},
+    endEvent: () => {},
+  };
+  metroRequire.getModules = () => {
+    return modules;
+  };
+  var createHotReloadingObject = function () {
+    const hot = {
+      _acceptCallback: null,
+      _disposeCallback: null,
+      _didAccept: false,
+      accept: (callback) => {
+        hot._didAccept = true;
+        hot._acceptCallback = callback;
+      },
+      dispose: (callback) => {
+        hot._disposeCallback = callback;
+      },
+    };
+    return hot;
+  };
+  let reactRefreshTimeout = null;
+  const metroHotUpdateModule = function (
+    id,
+    factory,
+    dependencyMap,
+    inverseDependencies,
+  ) {
+    const mod = modules.get(id);
+    if (!mod) {
+      if (factory) {
+        return;
+      }
+      throw unknownModuleError(id);
+    }
+    if (!mod.hasError && !mod.isInitialized) {
+      mod.factory = factory;
+      mod.dependencyMap = dependencyMap;
+      return;
+    }
+    const Refresh = requireRefresh();
+    const refreshBoundaryIDs = new Set();
+    let didBailOut = false;
+    let updatedModuleIDs;
+    try {
+      updatedModuleIDs = topologicalSort(
+        [id],
+        (pendingID) => {
+          const pendingModule = modules.get(pendingID);
+          if (pendingModule == null) {
+            return [];
+          }
+          const pendingHot = pendingModule.hot;
+          if (pendingHot == null) {
+            throw new Error(
+              "[Refresh] Expected module.hot to always exist in DEV.",
+            );
+          }
+          let canAccept = pendingHot._didAccept;
+          if (!canAccept && Refresh != null) {
+            const isBoundary = isReactRefreshBoundary(
+              Refresh,
+              pendingModule.publicModule.exports,
+            );
+            if (isBoundary) {
+              canAccept = true;
+              refreshBoundaryIDs.add(pendingID);
+            }
+          }
+          if (canAccept) {
+            return [];
+          }
+          const parentIDs = inverseDependencies[pendingID];
+          if (parentIDs.length === 0) {
+            performFullRefresh("No root boundary", {
+              source: mod,
+              failed: pendingModule,
+            });
+            didBailOut = true;
+            return [];
+          }
+          return parentIDs;
+        },
+        () => didBailOut,
+      ).reverse();
+    } catch (e) {
+      if (e === CYCLE_DETECTED) {
+        performFullRefresh("Dependency cycle", {
+          source: mod,
+        });
+        return;
+      }
+      throw e;
+    }
+    if (didBailOut) {
+      return;
+    }
+    const seenModuleIDs = new Set();
+    for (let i = 0; i < updatedModuleIDs.length; i++) {
+      const updatedID = updatedModuleIDs[i];
+      if (seenModuleIDs.has(updatedID)) {
+        continue;
+      }
+      seenModuleIDs.add(updatedID);
+      const updatedMod = modules.get(updatedID);
+      if (updatedMod == null) {
+        throw new Error("[Refresh] Expected to find the updated module.");
+      }
+      const prevExports = updatedMod.publicModule.exports;
+      const didError = runUpdatedModule(
+        updatedID,
+        updatedID === id ? factory : undefined,
+        updatedID === id ? dependencyMap : undefined,
+      );
+      const nextExports = updatedMod.publicModule.exports;
+      if (didError) {
+        return;
+      }
+      if (refreshBoundaryIDs.has(updatedID)) {
+        const isNoLongerABoundary = !isReactRefreshBoundary(
+          Refresh,
+          nextExports,
+        );
+        const didInvalidate = shouldInvalidateReactRefreshBoundary(
+          Refresh,
+          prevExports,
+          nextExports,
+        );
+        if (isNoLongerABoundary || didInvalidate) {
+          const parentIDs = inverseDependencies[updatedID];
+          if (parentIDs.length === 0) {
+            performFullRefresh(
+              isNoLongerABoundary
+                ? "No longer a boundary"
+                : "Invalidated boundary",
+              {
+                source: mod,
+                failed: updatedMod,
+              },
+            );
+            return;
+          }
+          for (let j = 0; j < parentIDs.length; j++) {
+            const parentID = parentIDs[j];
+            const parentMod = modules.get(parentID);
+            if (parentMod == null) {
+              throw new Error("[Refresh] Expected to find parent module.");
+            }
+            const canAcceptParent = isReactRefreshBoundary(
+              Refresh,
+              parentMod.publicModule.exports,
+            );
+            if (canAcceptParent) {
+              refreshBoundaryIDs.add(parentID);
+              updatedModuleIDs.push(parentID);
+            } else {
+              performFullRefresh("Invalidated boundary", {
+                source: mod,
+                failed: parentMod,
+              });
+              return;
+            }
+          }
+        }
+      }
+    }
+    if (Refresh != null) {
+      if (reactRefreshTimeout == null) {
+        reactRefreshTimeout = setTimeout(() => {
+          reactRefreshTimeout = null;
+          Refresh.performReactRefresh();
+        }, 30);
+      }
+    }
+  };
+  const topologicalSort = function (roots, getEdges, earlyStop) {
+    const result = [];
+    const visited = new Set();
+    const stack = new Set();
+    function traverseDependentNodes(node) {
+      if (stack.has(node)) {
+        throw CYCLE_DETECTED;
+      }
+      if (visited.has(node)) {
+        return;
+      }
+      visited.add(node);
+      stack.add(node);
+      const dependentNodes = getEdges(node);
+      if (earlyStop(node)) {
+        stack.delete(node);
+        return;
+      }
+      dependentNodes.forEach((dependent) => {
+        traverseDependentNodes(dependent);
+      });
+      stack.delete(node);
+      result.push(node);
+    }
+    roots.forEach((root) => {
+      traverseDependentNodes(root);
+    });
+    return result;
+  };
+  const runUpdatedModule = function (id, factory, dependencyMap) {
+    const mod = modules.get(id);
+    if (mod == null) {
+      throw new Error("[Refresh] Expected to find the module.");
+    }
+    const { hot } = mod;
+    if (!hot) {
+      throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
+    }
+    if (hot._disposeCallback) {
+      try {
+        hot._disposeCallback();
+      } catch (error) {
+        console.error(
+          `Error while calling dispose handler for module ${id}: `,
+          error,
+        );
+      }
+    }
+    if (factory) {
+      mod.factory = factory;
+    }
+    if (dependencyMap) {
+      mod.dependencyMap = dependencyMap;
+    }
+    mod.hasError = false;
+    mod.error = undefined;
+    mod.importedAll = EMPTY;
+    mod.importedDefault = EMPTY;
+    mod.isInitialized = false;
+    const prevExports = mod.publicModule.exports;
+    mod.publicModule.exports = {};
+    hot._didAccept = false;
+    hot._acceptCallback = null;
+    hot._disposeCallback = null;
+    metroRequire(id);
+    if (mod.hasError) {
+      mod.hasError = false;
+      mod.isInitialized = true;
+      mod.error = null;
+      mod.publicModule.exports = prevExports;
+      return true;
+    }
+    if (hot._acceptCallback) {
+      try {
+        hot._acceptCallback();
+      } catch (error) {
+        console.error(
+          `Error while calling accept handler for module ${id}: `,
+          error,
+        );
+      }
+    }
+    return false;
+  };
+  const performFullRefresh = (reason, modules) => {
+    if (
+      typeof window !== "undefined" &&
+      window.location != null &&
+      typeof window.location.reload === "function"
+    ) {
+      window.location.reload();
+    } else {
+      const Refresh = requireRefresh();
+      if (Refresh != null) {
+        const sourceName = modules.source?.verboseName ?? "unknown";
+        const failedName = modules.failed?.verboseName ?? "unknown";
+        Refresh.performFullRefresh(
+          `Fast Refresh - ${reason} <${sourceName}> <${failedName}>`,
+        );
+      } else {
+        console.warn("Could not reload the application after an edit.");
+      }
+    }
+  };
+  const isExportSafeToAccess = (moduleExports, key) => {
+    return (
+      moduleExports?.__esModule ||
+      Object.getOwnPropertyDescriptor(moduleExports, key)?.get == null
+    );
+  };
+  var isReactRefreshBoundary = function (Refresh, moduleExports) {
+    if (Refresh.isLikelyComponentType(moduleExports)) {
+      return true;
+    }
+    if (moduleExports == null || typeof moduleExports !== "object") {
+      return false;
+    }
+    let hasExports = false;
+    let areAllExportsComponents = true;
+    for (const key in moduleExports) {
+      hasExports = true;
+      if (key === "__esModule") {
+        continue;
+      } else if (!isExportSafeToAccess(moduleExports, key)) {
+        return false;
+      }
+      const exportValue = moduleExports[key];
+      if (!Refresh.isLikelyComponentType(exportValue)) {
+        areAllExportsComponents = false;
+      }
+    }
+    return hasExports && areAllExportsComponents;
+  };
+  var shouldInvalidateReactRefreshBoundary = (
+    Refresh,
+    prevExports,
+    nextExports,
+  ) => {
+    const prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
+    const nextSignature = getRefreshBoundarySignature(Refresh, nextExports);
+    if (prevSignature.length !== nextSignature.length) {
+      return true;
+    }
+    for (let i = 0; i < nextSignature.length; i++) {
+      if (prevSignature[i] !== nextSignature[i]) {
+        return true;
+      }
+    }
+    return false;
+  };
+  var getRefreshBoundarySignature = (Refresh, moduleExports) => {
+    const signature = [];
+    signature.push(Refresh.getFamilyByType(moduleExports));
+    if (moduleExports == null || typeof moduleExports !== "object") {
+      return signature;
+    }
+    for (const key in moduleExports) {
+      if (key === "__esModule") {
+        continue;
+      } else if (!isExportSafeToAccess(moduleExports, key)) {
+        continue;
+      }
+      const exportValue = moduleExports[key];
+      signature.push(key);
+      signature.push(Refresh.getFamilyByType(exportValue));
+    }
+    return signature;
+  };
+  var registerExportsForReactRefresh = (Refresh, moduleExports, moduleID) => {
+    Refresh.register(moduleExports, moduleID + " %exports%");
+    if (moduleExports == null || typeof moduleExports !== "object") {
+      return;
+    }
+    for (const key in moduleExports) {
+      if (!isExportSafeToAccess(moduleExports, key)) {
+        continue;
+      }
+      const exportValue = moduleExports[key];
+      const typeID = moduleID + " %exports% " + key;
+      Refresh.register(exportValue, typeID);
+    }
+  };
+  global.__accept = metroHotUpdateModule;
+}
+if (__DEV__) {
+  var requireSystrace = function requireSystrace() {
+    return (
+      global[__METRO_GLOBAL_PREFIX__ + "__SYSTRACE"] || metroRequire.Systrace
+    );
+  };
+  var requireRefresh = function requireRefresh() {
+    return (
+      global[__METRO_GLOBAL_PREFIX__ + "__ReactRefresh"] ||
+      global[global.__METRO_GLOBAL_PREFIX__ + "__ReactRefresh"] ||
+      metroRequire.Refresh
+    );
+  };
+}