@granite-js/mpack 0.0.1

package/dist/vendors/metro-core/src/canonicalize.js

@@ -0,0 +1,17 @@
+"use strict";
+function canonicalize(key, value) {
+  if (
+    // eslint-disable-next-line lint/strictly-null
+    value === null || typeof value !== "object" || Array.isArray(value)
+  ) {
+    return value;
+  }
+  const keys = Object.keys(value).sort();
+  const length = keys.length;
+  const object = {};
+  for (let i = 0; i < length; i++) {
+    object[keys[i]] = value[keys[i]];
+  }
+  return object;
+}
+module.exports = canonicalize;

package/dist/vendors/metro-core/src/errors/AmbiguousModuleResolutionError.js

@@ -0,0 +1,11 @@
+"use strict";
+class AmbiguousModuleResolutionError extends Error {
+  fromModulePath;
+  hasteError;
+  constructor(fromModulePath, hasteError) {
+    super(`Ambiguous module resolution from \`${fromModulePath}\`: ` + hasteError.message);
+    this.fromModulePath = fromModulePath;
+    this.hasteError = hasteError;
+  }
+}
+module.exports = AmbiguousModuleResolutionError;

package/dist/vendors/metro-core/src/errors/PackageResolutionError.js

@@ -0,0 +1,18 @@
+"use strict";
+const { formatFileCandidates } = require("metro-resolver");
+class PackageResolutionError extends Error {
+  originModulePath;
+  packageError;
+  targetModuleName;
+  constructor(opts) {
+    const perr = opts.packageError;
+    super(
+      `While trying to resolve module \`${opts.targetModuleName}\` from file \`${opts.originModulePath}\`, the package \`${perr.packageJsonPath}\` was successfully found. However, this package itself specifies a \`main\` module field that could not be resolved (\`${perr.mainPrefixPath}\`. Indeed, none of these files exist:
+
+  * ${formatFileCandidates(perr.fileCandidates)}
+  * ${formatFileCandidates(perr.indexCandidates)}`
+    );
+    Object.assign(this, opts);
+  }
+}
+module.exports = PackageResolutionError;

package/dist/vendors/metro-core/src/errors.js

@@ -0,0 +1,7 @@
+"use strict";
+const AmbiguousModuleResolutionError = require("./errors/AmbiguousModuleResolutionError");
+const PackageResolutionError = require("./errors/PackageResolutionError");
+module.exports = {
+  AmbiguousModuleResolutionError,
+  PackageResolutionError
+};

package/dist/vendors/metro-core/src/index.js

@@ -0,0 +1,11 @@
+"use strict";
+const AmbiguousModuleResolutionError = require("./errors/AmbiguousModuleResolutionError");
+const PackageResolutionError = require("./errors/PackageResolutionError");
+const Logger = require("./Logger");
+const Terminal = require("./Terminal");
+module.exports = {
+  AmbiguousModuleResolutionError,
+  Logger,
+  PackageResolutionError,
+  Terminal
+};

package/dist/vendors/metro-inspector-proxy/src/Device.js

@@ -0,0 +1,398 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_ws = __toESM(require("ws"));
+const debug = require("debug")("Metro:InspectorProxy");
+const PAGES_POLLING_INTERVAL = 1e3;
+const EMULATOR_LOCALHOST_ADDRESSES = ["10.0.2.2", "10.0.3.2"];
+const FILE_PREFIX = "file://";
+const REACT_NATIVE_RELOADABLE_PAGE_ID = "-1";
+class Device {
+  // ID of the device.
+  _id;
+  // Name of the device.
+  _name;
+  // Package name of the app.
+  _app;
+  // Stores socket connection between Inspector Proxy and device.
+  _deviceSocket;
+  // Stores last list of device's pages.
+  _pages;
+  // Stores information about currently connected debugger (if any).
+  _debuggerConnection = null;
+  // Last known Page ID of the React Native page.
+  // This is used by debugger connections that don't have PageID specified
+  // (and will interact with the latest React Native page).
+  _lastConnectedReactNativePage = null;
+  // Whether we are in the middle of a reload in the REACT_NATIVE_RELOADABLE_PAGE.
+  _isReloading = false;
+  // The previous "GetPages" message, for deduplication in debug logs.
+  _lastGetPagesMessage = "";
+  // Mapping built from scriptParsed events and used to fetch file content in `Debugger.getScriptSource`.
+  _scriptIdToSourcePathMapping = /* @__PURE__ */ new Map();
+  // Root of the project used for relative to absolute source path conversion.
+  _projectRoot;
+  // MARK: - GRANITE
+  // 네트워크 응답 데이터 저장하기 위한 변수 (key: requestId, value: { data: string, base64Encoded: bool })
+  _networkResponseData = /* @__PURE__ */ new Map();
+  constructor(id, name, app, socket, projectRoot) {
+    this._id = id;
+    this._name = name;
+    this._app = app;
+    this._pages = [];
+    this._deviceSocket = socket;
+    this._projectRoot = projectRoot;
+    this._deviceSocket.on("message", (message) => {
+      const parsedMessage = JSON.parse(message);
+      if (parsedMessage.event === "getPages") {
+        if (message !== this._lastGetPagesMessage) {
+          debug("(Debugger)    (Proxy) <- (Device), getPages ping has changed: " + message);
+          this._lastGetPagesMessage = message;
+        }
+      } else {
+        debug("(Debugger)    (Proxy) <- (Device): " + message);
+      }
+      this._handleMessageFromDevice(parsedMessage);
+    });
+    this._deviceSocket.on("close", () => {
+      if (this._debuggerConnection) {
+        this._debuggerConnection.socket.close();
+        this._debuggerConnection = null;
+      }
+    });
+    this._setPagesPolling();
+  }
+  getName() {
+    return this._name;
+  }
+  getPagesList() {
+    if (this._lastConnectedReactNativePage) {
+      const reactNativeReloadablePage = {
+        id: REACT_NATIVE_RELOADABLE_PAGE_ID,
+        title: "React Native Experimental (Improved Chrome Reloads)",
+        vm: "don't use",
+        app: this._app
+      };
+      return this._pages.concat(reactNativeReloadablePage);
+    } else {
+      return this._pages;
+    }
+  }
+  // Handles new debugger connection to this device:
+  // 1. Sends connect event to device
+  // 2. Forwards all messages from the debugger to device as wrappedEvent
+  // 3. Sends disconnect event to device when debugger connection socket closes.
+  handleDebuggerConnection(socket, pageId) {
+    if (this._debuggerConnection) {
+      this._debuggerConnection.socket.close();
+      this._debuggerConnection = null;
+    }
+    const debuggerInfo = {
+      socket,
+      prependedFilePrefix: false,
+      pageId
+    };
+    this._debuggerConnection = debuggerInfo;
+    debug(`Got new debugger connection for page ${pageId} of ${this._name}`);
+    this._sendMessageToDevice({
+      event: "connect",
+      payload: {
+        pageId: this._mapToDevicePageId(pageId)
+      }
+    });
+    socket.on("message", (message) => {
+      if (!this._lastConnectedReactNativePage) {
+        return;
+      }
+      debug("(Debugger) -> (Proxy)    (Device): " + message);
+      const debuggerRequest = JSON.parse(message);
+      const interceptedResponse = this._interceptMessageFromDebugger(debuggerRequest, debuggerInfo);
+      if (interceptedResponse) {
+        socket.send(JSON.stringify(interceptedResponse));
+      } else {
+        this._sendMessageToDevice({
+          event: "wrappedEvent",
+          payload: {
+            pageId: this._mapToDevicePageId(pageId),
+            wrappedEvent: JSON.stringify(debuggerRequest)
+          }
+        });
+      }
+    });
+    socket.on("close", () => {
+      debug(`Debugger for page ${pageId} and ${this._name} disconnected.`);
+      this._sendMessageToDevice({
+        event: "disconnect",
+        payload: {
+          pageId: this._mapToDevicePageId(pageId)
+        }
+      });
+      this._debuggerConnection = null;
+    });
+    const sendFunc = socket.send;
+    socket.send = function(message) {
+      debug("(Debugger) <- (Proxy)    (Device): " + message);
+      return sendFunc.call(socket, message);
+    };
+  }
+  // Handles messages received from device:
+  // 1. For getPages responses updates local _pages list.
+  // 2. All other messages are forwarded to debugger as wrappedEvent.
+  //
+  // In the future more logic will be added to this method for modifying
+  // some of the messages (like updating messages with source maps and file
+  // locations).
+  _handleMessageFromDevice(message) {
+    if (message.event === "getPages") {
+      this._pages = message.payload;
+      for (let i = 0; i < this._pages.length; ++i) {
+        if (this._pages[i].title.indexOf("React") >= 0) {
+          if (this._pages[i].id != this._lastConnectedReactNativePage?.id) {
+            this._newReactNativePage(this._pages[i]);
+            break;
+          }
+        }
+      }
+    } else if (message.event === "disconnect") {
+      const pageId = message.payload.pageId;
+      const debuggerSocket = this._debuggerConnection ? this._debuggerConnection.socket : null;
+      if (debuggerSocket && debuggerSocket.readyState === import_ws.default.OPEN) {
+        if (this._debuggerConnection != null && this._debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID) {
+          debug(`Page ${pageId} is reloading.`);
+          debuggerSocket.send(JSON.stringify({ method: "reload" }));
+        }
+      }
+    } else if (message.event === "wrappedEvent") {
+      if (this._debuggerConnection == null) {
+        return;
+      }
+      const debuggerSocket = this._debuggerConnection.socket;
+      if (debuggerSocket == null || debuggerSocket.readyState !== import_ws.default.OPEN) {
+        return;
+      }
+      const parsedPayload = JSON.parse(message.payload.wrappedEvent);
+      if (this._debuggerConnection) {
+        this._processMessageFromDevice(parsedPayload, this._debuggerConnection);
+      }
+      const messageToSend = JSON.stringify(parsedPayload);
+      debuggerSocket.send(messageToSend);
+    }
+  }
+  // Sends single message to device.
+  _sendMessageToDevice(message) {
+    try {
+      if (message.event !== "getPages") {
+        debug("(Debugger)    (Proxy) -> (Device): " + JSON.stringify(message));
+      }
+      this._deviceSocket.send(JSON.stringify(message));
+    } catch (error) {
+    }
+  }
+  // Sends 'getPages' request to device every PAGES_POLLING_INTERVAL milliseconds.
+  _setPagesPolling() {
+    setInterval(() => this._sendMessageToDevice({ event: "getPages" }), PAGES_POLLING_INTERVAL);
+  }
+  // We received new React Native Page ID.
+  _newReactNativePage(page) {
+    debug(`React Native page updated to ${page.id}`);
+    if (this._debuggerConnection == null || this._debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID) {
+      this._lastConnectedReactNativePage = page;
+      return;
+    }
+    const oldPageId = this._lastConnectedReactNativePage?.id;
+    this._lastConnectedReactNativePage = page;
+    this._isReloading = true;
+    if (oldPageId != null) {
+      this._sendMessageToDevice({
+        event: "disconnect",
+        payload: {
+          pageId: oldPageId
+        }
+      });
+    }
+    this._sendMessageToDevice({
+      event: "connect",
+      payload: {
+        pageId: page.id
+      }
+    });
+    const toSend = [
+      { method: "Runtime.enable", id: 1e9 },
+      { method: "Debugger.enable", id: 1e9 }
+    ];
+    for (const message of toSend) {
+      this._sendMessageToDevice({
+        event: "wrappedEvent",
+        payload: {
+          pageId: this._mapToDevicePageId(page.id),
+          wrappedEvent: JSON.stringify(message)
+        }
+      });
+    }
+  }
+  // Allows to make changes in incoming message from device.
+  _processMessageFromDevice(payload, debuggerInfo) {
+    if (payload.method === "Debugger.scriptParsed") {
+      const params = payload.params || {};
+      if ("sourceMapURL" in params) {
+        for (let i = 0; i < EMULATOR_LOCALHOST_ADDRESSES.length; ++i) {
+          const address = EMULATOR_LOCALHOST_ADDRESSES[i];
+          if (params.sourceMapURL.indexOf(address) >= 0) {
+            payload.params.sourceMapURL = params.sourceMapURL.replace(address, "localhost");
+            debuggerInfo.originalSourceURLAddress = address;
+          }
+        }
+      }
+      if ("url" in params) {
+        for (let i = 0; i < EMULATOR_LOCALHOST_ADDRESSES.length; ++i) {
+          const address = EMULATOR_LOCALHOST_ADDRESSES[i];
+          if (params.url.indexOf(address) >= 0) {
+            payload.params.url = params.url.replace(address, "localhost");
+            debuggerInfo.originalSourceURLAddress = address;
+          }
+        }
+        if (payload.params.url.match(/^[0-9a-z]+$/)) {
+          payload.params.url = FILE_PREFIX + payload.params.url;
+          debuggerInfo.prependedFilePrefix = true;
+        }
+        if (params.scriptId != null) {
+          this._scriptIdToSourcePathMapping.set(params.scriptId, params.url);
+        }
+      }
+      if (debuggerInfo.pageId == REACT_NATIVE_RELOADABLE_PAGE_ID) {
+        if (payload.params.sourceMapURL) {
+          payload.params.sourceMapURL += "&cachePrevention=" + this._mapToDevicePageId(debuggerInfo.pageId);
+        }
+        if (payload.params.url) {
+          payload.params.url += "&cachePrevention=" + this._mapToDevicePageId(debuggerInfo.pageId);
+        }
+      }
+    }
+    if (payload.method === "Runtime.executionContextCreated" && this._isReloading) {
+      debuggerInfo.socket.send(JSON.stringify({ method: "Runtime.executionContextsCleared" }));
+      this._sendMessageToDevice({
+        event: "wrappedEvent",
+        payload: {
+          pageId: this._mapToDevicePageId(debuggerInfo.pageId),
+          wrappedEvent: JSON.stringify({ method: "Debugger.resume", id: 0 })
+        }
+      });
+      this._isReloading = false;
+    }
+    if (payload.method === "Bedrock.networkResponseData" || payload.method === "Granite.networkResponseData") {
+      const params = payload.params ?? {};
+      if (typeof params.requestId === "string") {
+        this._networkResponseData.set(params.requestId, {
+          data: params.data,
+          base64Encoded: params.base64Encoded
+        });
+      }
+    }
+  }
+  // Allows to make changes in incoming messages from debugger.
+  _interceptMessageFromDebugger(req, debuggerInfo) {
+    let response = null;
+    if (req.method === "Debugger.setBreakpointByUrl") {
+      this._processDebuggerSetBreakpointByUrl(req, debuggerInfo);
+    } else if (req.method === "Debugger.getScriptSource") {
+      response = {
+        id: req.id,
+        result: this._processDebuggerGetScriptSource(req)
+      };
+    } else if (req.method === "Network.getResponseBody") {
+      return this._processDebuggerGetResponseBody(req, debuggerInfo.socket);
+    }
+    return response;
+  }
+  // MARK: - GRANITE
+  _processDebuggerGetResponseBody(req, socket) {
+    const { requestId } = req.params;
+    if (this._networkResponseData.has(requestId)) {
+      const responseData = this._networkResponseData.get(requestId);
+      this._networkResponseData.delete(requestId);
+      socket.send(
+        JSON.stringify({
+          id: req.id,
+          result: this._createNetworkResponseData(responseData)
+        })
+      );
+      return true;
+    }
+    return false;
+  }
+  // MARK: - GRANITE
+  _createNetworkResponseData(responseData) {
+    let parsedOriginalData;
+    try {
+      parsedOriginalData = JSON.parse(responseData.base64Encoded ? atob(responseData.data) : responseData.data);
+    } catch {
+      return {
+        body: responseData.data,
+        base64Encoded: responseData.base64Encoded
+      };
+    }
+    const body = typeof parsedOriginalData === "object" ? JSON.stringify(parsedOriginalData) : responseData.data;
+    return { body, base64Encoded: false };
+  }
+  _processDebuggerSetBreakpointByUrl(req, debuggerInfo) {
+    if (debuggerInfo.originalSourceURLAddress) {
+      if (req.params.url) {
+        req.params.url = req.params.url.replace("localhost", debuggerInfo.originalSourceURLAddress);
+        if (req.params.url && req.params.url.startsWith(FILE_PREFIX) && debuggerInfo.prependedFilePrefix) {
+          req.params.url = req.params.url.slice(FILE_PREFIX.length);
+        }
+      }
+      if (req.params.urlRegex) {
+        req.params.urlRegex = req.params.urlRegex.replace(
+          /localhost/g,
+          // $FlowFixMe[incompatible-call]
+          debuggerInfo.originalSourceURLAddress
+        );
+      }
+    }
+  }
+  _processDebuggerGetScriptSource(req) {
+    let scriptSource = `Source for script with id '${req.params.scriptId}' was not found.`;
+    const pathToSource = this._scriptIdToSourcePathMapping.get(req.params.scriptId);
+    if (pathToSource) {
+      try {
+        scriptSource = fs.readFileSync(path.resolve(this._projectRoot, pathToSource), "utf8");
+      } catch (err) {
+        scriptSource = err.message;
+      }
+    }
+    return {
+      scriptSource
+    };
+  }
+  _mapToDevicePageId(pageId) {
+    if (pageId === REACT_NATIVE_RELOADABLE_PAGE_ID && this._lastConnectedReactNativePage != null) {
+      return this._lastConnectedReactNativePage.id;
+    } else {
+      return pageId;
+    }
+  }
+}
+module.exports = Device;

package/dist/vendors/metro-inspector-proxy/src/InspectorProxy.d.ts

@@ -0,0 +1,21 @@
+import * as http from 'http';
+import * as ws from 'ws';
+
+declare class Device {
+  getName(): string;
+  getPageList(): unknown[];
+}
+
+declare class InspectorProxy {
+  static devices: Map<number, Device>;
+
+  processRequest: (request: http.IncomingMessage, response: http.ServerResponse, next: (error?: Error) => void) => void;
+  createWebSocketListeners: (server: http.Server) => {
+    ['/inspector/device']: ws.WebSocketServer;
+    ['/inspector/debug']: ws.WebSocketServer;
+  };
+
+  constructor(projectRoot: string);
+}
+
+export default InspectorProxy;

package/dist/vendors/metro-inspector-proxy/src/InspectorProxy.js

@@ -0,0 +1,153 @@
+"use strict";
+const Device = require("./Device");
+const debug = require("debug")("Metro:InspectorProxy");
+const url = require("url");
+const WS = require("ws");
+const WS_DEVICE_URL = "/inspector/device";
+const WS_DEBUGGER_URL = "/inspector/debug";
+const PAGES_LIST_JSON_URL = "/json";
+const PAGES_LIST_JSON_URL_2 = "/json/list";
+const PAGES_LIST_JSON_VERSION_URL = "/json/version";
+const INTERNAL_ERROR_CODE = 1011;
+class InspectorProxy {
+  // MARK: - GRANITE
+  static devices;
+  // Root of the project used for relative to absolute source path conversion.
+  _projectRoot;
+  // MARK: - GRANITE
+  // 내부 변수를 static 필드로 변경하여 외부에서 접근하도록 변경함 (미사용)
+  // Maps device ID to Device instance.
+  _devices;
+  // Internal counter for device IDs -- just gets incremented for each new device.
+  _deviceCounter = 0;
+  // We store server's address with port (like '127.0.0.1:8081') to be able to build URLs
+  // (devtoolsFrontendUrl and webSocketDebuggerUrl) for page descriptions. These URLs are used
+  // by debugger to know where to connect.
+  _serverAddressWithPort = "";
+  constructor(projectRoot) {
+    this._projectRoot = projectRoot;
+    InspectorProxy.devices = /* @__PURE__ */ new Map();
+  }
+  // Process HTTP request sent to server. We only respond to 2 HTTP requests:
+  // 1. /json/version returns Chrome debugger protocol version that we use
+  // 2. /json and /json/list returns list of page descriptions (list of inspectable apps).
+  // This list is combined from all the connected devices.
+  processRequest(request, response, next) {
+    if (request.url === PAGES_LIST_JSON_URL || request.url === PAGES_LIST_JSON_URL_2) {
+      let result = [];
+      Array.from(InspectorProxy.devices.entries()).forEach(([deviceId, device]) => {
+        result = result.concat(device.getPagesList().map((page) => this._buildPageDescription(deviceId, device, page)));
+      });
+      this._sendJsonResponse(response, result);
+    } else if (request.url === PAGES_LIST_JSON_VERSION_URL) {
+      this._sendJsonResponse(response, {
+        Browser: "Mobile JavaScript",
+        "Protocol-Version": "1.1"
+      });
+    } else {
+      next();
+    }
+  }
+  // Adds websocket listeners to the provided HTTP/HTTPS server.
+  createWebSocketListeners(server) {
+    const { port } = server.address();
+    if (server.address().family === "IPv6") {
+      this._serverAddressWithPort = `[::1]:${port}`;
+    } else {
+      this._serverAddressWithPort = `localhost:${port}`;
+    }
+    return {
+      [WS_DEVICE_URL]: this._createDeviceConnectionWSServer(),
+      [WS_DEBUGGER_URL]: this._createDebuggerConnectionWSServer()
+    };
+  }
+  // Converts page information received from device into PageDescription object
+  // that is sent to debugger.
+  _buildPageDescription(deviceId, device, page) {
+    const debuggerUrl = `${this._serverAddressWithPort}${WS_DEBUGGER_URL}?device=${deviceId}&page=${page.id}`;
+    const webSocketDebuggerUrl = "ws://" + debuggerUrl;
+    const devtoolsFrontendUrl = "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=" + encodeURIComponent(debuggerUrl);
+    return {
+      id: `${deviceId}-${page.id}`,
+      description: page.app,
+      title: page.title,
+      faviconUrl: "https://reactjs.org/favicon.ico",
+      devtoolsFrontendUrl,
+      type: "node",
+      webSocketDebuggerUrl,
+      vm: page.vm
+    };
+  }
+  // Sends object as response to HTTP request.
+  // Just serializes object using JSON and sets required headers.
+  _sendJsonResponse(response, object) {
+    const data = JSON.stringify(object, null, 2);
+    response.writeHead(200, {
+      "Content-Type": "application/json; charset=UTF-8",
+      "Cache-Control": "no-cache",
+      "Content-Length": data.length.toString(),
+      Connection: "close"
+    });
+    response.end(data);
+  }
+  // Adds websocket handler for device connections.
+  // Device connects to /inspector/device and passes device and app names as
+  // HTTP GET params.
+  // For each new websocket connection we parse device and app names and create
+  // new instance of Device class.
+  _createDeviceConnectionWSServer() {
+    const wss = new WS.Server({
+      noServer: true,
+      perMessageDeflate: true
+    });
+    wss.on("connection", async (socket, req) => {
+      try {
+        const query = url.parse(req.url || "", true).query || {};
+        const deviceName = query.name || "Unknown";
+        const appName = query.app || "Unknown";
+        const deviceId = this._deviceCounter++;
+        InspectorProxy.devices.set(deviceId, new Device(deviceId, deviceName, appName, socket, this._projectRoot));
+        debug(`Got new connection: device=${deviceName}, app=${appName}`);
+        socket.on("close", () => {
+          InspectorProxy.devices.delete(deviceId);
+          debug(`Device ${deviceName} disconnected.`);
+        });
+      } catch (e) {
+        console.error("error", e);
+        socket.close(INTERNAL_ERROR_CODE, e?.toString() ?? "Unknown error");
+      }
+    });
+    return wss;
+  }
+  // Returns websocket handler for debugger connections.
+  // Debugger connects to webSocketDebuggerUrl that we return as part of page description
+  // in /json response.
+  // When debugger connects we try to parse device and page IDs from the query and pass
+  // websocket object to corresponding Device instance.
+  _createDebuggerConnectionWSServer() {
+    const wss = new WS.Server({
+      noServer: true,
+      perMessageDeflate: false
+    });
+    wss.on("connection", async (socket, req) => {
+      try {
+        const query = url.parse(req.url || "", true).query || {};
+        const deviceId = query.device;
+        const pageId = query.page;
+        if (deviceId == null || pageId == null) {
+          throw new Error("Incorrect URL - must provide device and page IDs");
+        }
+        const device = InspectorProxy.devices.get(parseInt(deviceId, 10));
+        if (device == null) {
+          throw new Error("Unknown device with ID " + deviceId);
+        }
+        device.handleDebuggerConnection(socket, pageId);
+      } catch (e) {
+        console.error(e);
+        socket.close(INTERNAL_ERROR_CODE, e?.toString() ?? "Unknown error");
+      }
+    });
+    return wss;
+  }
+}
+module.exports = InspectorProxy;

package/dist/vendors/metro-inspector-proxy/src/cli.js

@@ -0,0 +1,15 @@
+"use strict";
+const { runInspectorProxy } = require("./index");
+const yargs = require("yargs");
+const argv = yargs.option("port", {
+  alias: "p",
+  describe: "port to run inspector proxy on",
+  type: "number",
+  default: 8081
+}).option("root", {
+  alias: "r",
+  describe: "root folder of metro project",
+  type: "string",
+  default: ""
+}).argv;
+runInspectorProxy(argv.port, argv.root);

package/dist/vendors/metro-inspector-proxy/src/index.js

@@ -0,0 +1,23 @@
+"use strict";
+const InspectorProxy = require("./InspectorProxy");
+const { parse } = require("url");
+function runInspectorProxy(port, projectRoot) {
+  const inspectorProxy = new InspectorProxy(projectRoot);
+  const app = require("connect")();
+  app.use(inspectorProxy.processRequest.bind(inspectorProxy));
+  const httpServer = require("http").createServer(app);
+  httpServer.listen(port, "127.0.0.1", () => {
+    const websocketEndpoints = inspectorProxy.createWebSocketListeners(httpServer);
+    httpServer.on("upgrade", (request, socket, head) => {
+      const { pathname } = parse(request.url);
+      if (pathname != null && websocketEndpoints[pathname]) {
+        websocketEndpoints[pathname].handleUpgrade(request, socket, head, (ws) => {
+          websocketEndpoints[pathname].emit("connection", ws, request);
+        });
+      } else {
+        socket.destroy();
+      }
+    });
+  });
+}
+module.exports = { InspectorProxy, runInspectorProxy };

package/dist/vendors/metro-inspector-proxy/src/types.js

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