@depup/expo__cli 55.0.16-depup.0

package/build/src/start/server/metro/debugging/createHandlersFactory.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createHandlersFactory", {
+    enumerable: true,
+    get: function() {
+        return createHandlersFactory;
+    }
+});
+const _NetworkResponse = require("./messageHandlers/NetworkResponse");
+const _VscodeDebuggerGetPossibleBreakpoints = require("./messageHandlers/VscodeDebuggerGetPossibleBreakpoints");
+const _VscodeDebuggerSetBreakpointByUrl = require("./messageHandlers/VscodeDebuggerSetBreakpointByUrl");
+const _VscodeRuntimeCallFunctionOn = require("./messageHandlers/VscodeRuntimeCallFunctionOn");
+const _VscodeRuntimeEvaluate = require("./messageHandlers/VscodeRuntimeEvaluate");
+const _VscodeRuntimeGetProperties = require("./messageHandlers/VscodeRuntimeGetProperties");
+const _pageIsSupported = require("./pageIsSupported");
+const debug = require('debug')('expo:metro:debugging:messageHandlers');
+function createHandlersFactory() {
+    return (connection)=>{
+        debug('Initializing for connection: ', connection.page.title);
+        if (!(0, _pageIsSupported.pageIsSupported)(connection.page)) {
+            debug('Aborted, unsupported page capabiltiies:', connection.page.capabilities);
+            return null;
+        }
+        const handlers = [
+            // Generic handlers
+            new _NetworkResponse.NetworkResponseHandler(connection),
+            // Vscode-specific handlers
+            new _VscodeDebuggerGetPossibleBreakpoints.VscodeDebuggerGetPossibleBreakpointsHandler(connection),
+            new _VscodeDebuggerSetBreakpointByUrl.VscodeDebuggerSetBreakpointByUrlHandler(connection),
+            new _VscodeRuntimeGetProperties.VscodeRuntimeGetPropertiesHandler(connection),
+            new _VscodeRuntimeCallFunctionOn.VscodeRuntimeCallFunctionOnHandler(connection),
+            new _VscodeRuntimeEvaluate.VscodeRuntimeEvaluateHandler(connection)
+        ].filter((middleware)=>middleware.isEnabled());
+        if (!handlers.length) {
+            debug('Aborted, all handlers are disabled');
+            return null;
+        }
+        debug('Initialized with handlers: ', handlers.map((middleware)=>middleware.constructor.name).join(', '));
+        return {
+            handleDeviceMessage: (message)=>withMessageDebug('device', message, handlers.some((middleware)=>middleware.handleDeviceMessage == null ? void 0 : middleware.handleDeviceMessage.call(middleware, message))),
+            handleDebuggerMessage: (message)=>withMessageDebug('debugger', message, handlers.some((middleware)=>middleware.handleDebuggerMessage == null ? void 0 : middleware.handleDebuggerMessage.call(middleware, message)))
+        };
+    };
+}
+function withMessageDebug(type, message, result) {
+    const status = result ? 'handled' : 'ignored';
+    const prefix = type === 'device' ? '(debugger) <- (device)' : '(debugger) -> (device)';
+    try {
+        debug(`%s = %s:`, prefix, status, JSON.stringify(message));
+    } catch  {
+        debug(`%s = %s:`, prefix, status, 'message not serializable');
+    }
+    return result || undefined;
+}
+
+//# sourceMappingURL=createHandlersFactory.js.map

package/build/src/start/server/metro/debugging/createHandlersFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/createHandlersFactory.ts"],"sourcesContent":["import type { CreateCustomMessageHandlerFn } from '@react-native/dev-middleware';\n\nimport { NetworkResponseHandler } from './messageHandlers/NetworkResponse';\nimport { VscodeDebuggerGetPossibleBreakpointsHandler } from './messageHandlers/VscodeDebuggerGetPossibleBreakpoints';\nimport { VscodeDebuggerSetBreakpointByUrlHandler } from './messageHandlers/VscodeDebuggerSetBreakpointByUrl';\nimport { VscodeRuntimeCallFunctionOnHandler } from './messageHandlers/VscodeRuntimeCallFunctionOn';\nimport { VscodeRuntimeEvaluateHandler } from './messageHandlers/VscodeRuntimeEvaluate';\nimport { VscodeRuntimeGetPropertiesHandler } from './messageHandlers/VscodeRuntimeGetProperties';\nimport { pageIsSupported } from './pageIsSupported';\n\nconst debug = require('debug')('expo:metro:debugging:messageHandlers') as typeof console.log;\n\nexport function createHandlersFactory(): CreateCustomMessageHandlerFn {\n  return (connection) => {\n    debug('Initializing for connection: ', connection.page.title);\n\n    if (!pageIsSupported(connection.page)) {\n      debug('Aborted, unsupported page capabiltiies:', connection.page.capabilities);\n      return null;\n    }\n\n    const handlers = [\n      // Generic handlers\n      new NetworkResponseHandler(connection),\n      // Vscode-specific handlers\n      new VscodeDebuggerGetPossibleBreakpointsHandler(connection),\n      new VscodeDebuggerSetBreakpointByUrlHandler(connection),\n      new VscodeRuntimeGetPropertiesHandler(connection),\n      new VscodeRuntimeCallFunctionOnHandler(connection),\n      new VscodeRuntimeEvaluateHandler(connection),\n    ].filter((middleware) => middleware.isEnabled());\n\n    if (!handlers.length) {\n      debug('Aborted, all handlers are disabled');\n      return null;\n    }\n\n    debug(\n      'Initialized with handlers: ',\n      handlers.map((middleware) => middleware.constructor.name).join(', ')\n    );\n\n    return {\n      handleDeviceMessage: (message: any) =>\n        withMessageDebug(\n          'device',\n          message,\n          handlers.some((middleware) => middleware.handleDeviceMessage?.(message))\n        ),\n      handleDebuggerMessage: (message: any) =>\n        withMessageDebug(\n          'debugger',\n          message,\n          handlers.some((middleware) => middleware.handleDebuggerMessage?.(message))\n        ),\n    };\n  };\n}\n\nfunction withMessageDebug(type: 'device' | 'debugger', message: any, result?: null | boolean) {\n  const status = result ? 'handled' : 'ignored';\n  const prefix = type === 'device' ? '(debugger) <- (device)' : '(debugger) -> (device)';\n\n  try {\n    debug(`%s = %s:`, prefix, status, JSON.stringify(message));\n  } catch {\n    debug(`%s = %s:`, prefix, status, 'message not serializable');\n  }\n\n  return result || undefined;\n}\n"],"names":["createHandlersFactory","debug","require","connection","page","title","pageIsSupported","capabilities","handlers","NetworkResponseHandler","VscodeDebuggerGetPossibleBreakpointsHandler","VscodeDebuggerSetBreakpointByUrlHandler","VscodeRuntimeGetPropertiesHandler","VscodeRuntimeCallFunctionOnHandler","VscodeRuntimeEvaluateHandler","filter","middleware","isEnabled","length","map","constructor","name","join","handleDeviceMessage","message","withMessageDebug","some","handleDebuggerMessage","type","result","status","prefix","JSON","stringify","undefined"],"mappings":";;;;+BAYgBA;;;eAAAA;;;iCAVuB;sDACqB;kDACJ;6CACL;uCACN;4CACK;iCAClB;AAEhC,MAAMC,QAAQC,QAAQ,SAAS;AAExB,SAASF;IACd,OAAO,CAACG;QACNF,MAAM,iCAAiCE,WAAWC,IAAI,CAACC,KAAK;QAE5D,IAAI,CAACC,IAAAA,gCAAe,EAACH,WAAWC,IAAI,GAAG;YACrCH,MAAM,2CAA2CE,WAAWC,IAAI,CAACG,YAAY;YAC7E,OAAO;QACT;QAEA,MAAMC,WAAW;YACf,mBAAmB;YACnB,IAAIC,uCAAsB,CAACN;YAC3B,2BAA2B;YAC3B,IAAIO,iFAA2C,CAACP;YAChD,IAAIQ,yEAAuC,CAACR;YAC5C,IAAIS,6DAAiC,CAACT;YACtC,IAAIU,+DAAkC,CAACV;YACvC,IAAIW,mDAA4B,CAACX;SAClC,CAACY,MAAM,CAAC,CAACC,aAAeA,WAAWC,SAAS;QAE7C,IAAI,CAACT,SAASU,MAAM,EAAE;YACpBjB,MAAM;YACN,OAAO;QACT;QAEAA,MACE,+BACAO,SAASW,GAAG,CAAC,CAACH,aAAeA,WAAWI,WAAW,CAACC,IAAI,EAAEC,IAAI,CAAC;QAGjE,OAAO;YACLC,qBAAqB,CAACC,UACpBC,iBACE,UACAD,SACAhB,SAASkB,IAAI,CAAC,CAACV,aAAeA,WAAWO,mBAAmB,oBAA9BP,WAAWO,mBAAmB,MAA9BP,YAAiCQ;YAEnEG,uBAAuB,CAACH,UACtBC,iBACE,YACAD,SACAhB,SAASkB,IAAI,CAAC,CAACV,aAAeA,WAAWW,qBAAqB,oBAAhCX,WAAWW,qBAAqB,MAAhCX,YAAmCQ;QAEvE;IACF;AACF;AAEA,SAASC,iBAAiBG,IAA2B,EAAEJ,OAAY,EAAEK,MAAuB;IAC1F,MAAMC,SAASD,SAAS,YAAY;IACpC,MAAME,SAASH,SAAS,WAAW,2BAA2B;IAE9D,IAAI;QACF3B,MAAM,CAAC,QAAQ,CAAC,EAAE8B,QAAQD,QAAQE,KAAKC,SAAS,CAACT;IACnD,EAAE,OAAM;QACNvB,MAAM,CAAC,QAAQ,CAAC,EAAE8B,QAAQD,QAAQ;IACpC;IAEA,OAAOD,UAAUK;AACnB"}

package/build/src/start/server/metro/debugging/getDebuggerType.js

@@ -0,0 +1,20 @@
+/** Known compatible debuggers that require specific workarounds */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getDebuggerType", {
+    enumerable: true,
+    get: function() {
+        return getDebuggerType;
+    }
+});
+// Patterns to test against user agents
+const CHROME_USER_AGENT = /chrome/i;
+const VSCODE_USER_AGENT = /vscode/i;
+function getDebuggerType(userAgent) {
+    if (userAgent && CHROME_USER_AGENT.test(userAgent)) return 'chrome';
+    if (userAgent && VSCODE_USER_AGENT.test(userAgent)) return 'vscode';
+    return 'unknown';
+}
+
+//# sourceMappingURL=getDebuggerType.js.map

package/build/src/start/server/metro/debugging/getDebuggerType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/getDebuggerType.ts"],"sourcesContent":["/** Known compatible debuggers that require specific workarounds */\nexport type DebuggerType = 'chrome' | 'vscode' | 'unknown';\n\n// Patterns to test against user agents\nconst CHROME_USER_AGENT = /chrome/i;\nconst VSCODE_USER_AGENT = /vscode/i;\n\n/**\n * Determine the debugger type based on the known user agent.\n */\nexport function getDebuggerType(userAgent?: string | null): DebuggerType {\n  if (userAgent && CHROME_USER_AGENT.test(userAgent)) return 'chrome';\n  if (userAgent && VSCODE_USER_AGENT.test(userAgent)) return 'vscode';\n  return 'unknown';\n}\n"],"names":["getDebuggerType","CHROME_USER_AGENT","VSCODE_USER_AGENT","userAgent","test"],"mappings":"AAAA,iEAAiE;;;;+BAUjDA;;;eAAAA;;;AAPhB,uCAAuC;AACvC,MAAMC,oBAAoB;AAC1B,MAAMC,oBAAoB;AAKnB,SAASF,gBAAgBG,SAAyB;IACvD,IAAIA,aAAaF,kBAAkBG,IAAI,CAACD,YAAY,OAAO;IAC3D,IAAIA,aAAaD,kBAAkBE,IAAI,CAACD,YAAY,OAAO;IAC3D,OAAO;AACT"}

package/build/src/start/server/metro/debugging/messageHandlers/NetworkResponse.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NETWORK_RESPONSE_STORAGE: function() {
+        return NETWORK_RESPONSE_STORAGE;
+    },
+    NetworkResponseHandler: function() {
+        return NetworkResponseHandler;
+    }
+});
+const _MessageHandler = require("../MessageHandler");
+const NETWORK_RESPONSE_STORAGE = new Map();
+class NetworkResponseHandler extends _MessageHandler.MessageHandler {
+    handleDeviceMessage(message) {
+        if (message.method === 'Expo(Network.receivedResponseBody)') {
+            const { requestId, ...requestInfo } = message.params;
+            this.storage.set(requestId, requestInfo);
+            return true;
+        }
+        return false;
+    }
+    handleDebuggerMessage(message) {
+        if (message.method === 'Network.getResponseBody' && this.storage.has(message.params.requestId)) {
+            return this.sendToDebugger({
+                id: message.id,
+                result: this.storage.get(message.params.requestId)
+            });
+        }
+        return false;
+    }
+    constructor(...args){
+        super(...args), /** All known responses, mapped by request id */ this.storage = NETWORK_RESPONSE_STORAGE;
+    }
+}
+
+//# sourceMappingURL=NetworkResponse.js.map

package/build/src/start/server/metro/debugging/messageHandlers/NetworkResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/start/server/metro/debugging/messageHandlers/NetworkResponse.ts"],"sourcesContent":["import type { Protocol } from 'devtools-protocol';\n\nimport { MessageHandler } from '../MessageHandler';\nimport type {\n  CdpMessage,\n  DeviceRequest,\n  DebuggerRequest,\n  DebuggerResponse,\n  DeviceResponse,\n} from '../types';\n\n/**\n * The global network response storage, as a workaround for the network inspector.\n * @see createDebugMiddleware#createNetworkWebsocket\n */\nexport const NETWORK_RESPONSE_STORAGE = new Map<\n  string,\n  DebuggerResponse<NetworkGetResponseBody>['result']\n>();\n\nexport class NetworkResponseHandler extends MessageHandler {\n  /** All known responses, mapped by request id */\n  storage = NETWORK_RESPONSE_STORAGE;\n\n  handleDeviceMessage(message: DeviceRequest<NetworkReceivedResponseBody>) {\n    if (message.method === 'Expo(Network.receivedResponseBody)') {\n      const { requestId, ...requestInfo } = message.params;\n      this.storage.set(requestId, requestInfo);\n      return true;\n    }\n\n    return false;\n  }\n\n  handleDebuggerMessage(message: DebuggerRequest<NetworkGetResponseBody>) {\n    if (\n      message.method === 'Network.getResponseBody' &&\n      this.storage.has(message.params.requestId)\n    ) {\n      return this.sendToDebugger<DeviceResponse<NetworkGetResponseBody>>({\n        id: message.id,\n        result: this.storage.get(message.params.requestId)!,\n      });\n    }\n\n    return false;\n  }\n}\n\n/** Custom message to transfer the response body data to the proxy */\nexport type NetworkReceivedResponseBody = CdpMessage<\n  'Expo(Network.receivedResponseBody)',\n  Protocol.Network.GetResponseBodyRequest & Protocol.Network.GetResponseBodyResponse,\n  never\n>;\n\n/** @see https://chromedevtools.github.io/devtools-protocol/1-2/Network/#method-getResponseBody */\nexport type NetworkGetResponseBody = CdpMessage<\n  'Network.getResponseBody',\n  Protocol.Network.GetResponseBodyRequest,\n  Protocol.Network.GetResponseBodyResponse\n>;\n"],"names":["NETWORK_RESPONSE_STORAGE","NetworkResponseHandler","Map","MessageHandler","handleDeviceMessage","message","method","requestId","requestInfo","params","storage","set","handleDebuggerMessage","has","sendToDebugger","id","result","get"],"mappings":";;;;;;;;;;;IAeaA,wBAAwB;eAAxBA;;IAKAC,sBAAsB;eAAtBA;;;gCAlBkB;AAaxB,MAAMD,2BAA2B,IAAIE;AAKrC,MAAMD,+BAA+BE,8BAAc;IAIxDC,oBAAoBC,OAAmD,EAAE;QACvE,IAAIA,QAAQC,MAAM,KAAK,sCAAsC;YAC3D,MAAM,EAAEC,SAAS,EAAE,GAAGC,aAAa,GAAGH,QAAQI,MAAM;YACpD,IAAI,CAACC,OAAO,CAACC,GAAG,CAACJ,WAAWC;YAC5B,OAAO;QACT;QAEA,OAAO;IACT;IAEAI,sBAAsBP,OAAgD,EAAE;QACtE,IACEA,QAAQC,MAAM,KAAK,6BACnB,IAAI,CAACI,OAAO,CAACG,GAAG,CAACR,QAAQI,MAAM,CAACF,SAAS,GACzC;YACA,OAAO,IAAI,CAACO,cAAc,CAAyC;gBACjEC,IAAIV,QAAQU,EAAE;gBACdC,QAAQ,IAAI,CAACN,OAAO,CAACO,GAAG,CAACZ,QAAQI,MAAM,CAACF,SAAS;YACnD;QACF;QAEA,OAAO;IACT;;QA1BK,gBACL,8CAA8C,QAC9CG,UAAUV;;AAyBZ"}

package/build/src/start/server/metro/debugging/messageHandlers/VscodeDebuggerGetPossibleBreakpoints.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VscodeDebuggerGetPossibleBreakpointsHandler", {
+    enumerable: true,
+    get: function() {
+        return VscodeDebuggerGetPossibleBreakpointsHandler;
+    }
+});
+const _MessageHandler = require("../MessageHandler");
+const _getDebuggerType = require("../getDebuggerType");
+class VscodeDebuggerGetPossibleBreakpointsHandler extends _MessageHandler.MessageHandler {
+    isEnabled() {
+        return (0, _getDebuggerType.getDebuggerType)(this.debugger.userAgent) === 'vscode';
+    }
+    handleDebuggerMessage(message) {
+        if (message.method === 'Debugger.getPossibleBreakpoints') {
+            return this.sendToDebugger({
+                id: message.id,
+                result: {
+                    locations: []
+                }
+            });
+        }
+        return false;
+    }
+}
+
+//# sourceMappingURL=VscodeDebuggerGetPossibleBreakpoints.js.map

package/build/src/start/server/metro/debugging/messageHandlers/VscodeDebuggerGetPossibleBreakpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/start/server/metro/debugging/messageHandlers/VscodeDebuggerGetPossibleBreakpoints.ts"],"sourcesContent":["import type Protocol from 'devtools-protocol';\n\nimport { MessageHandler } from '../MessageHandler';\nimport { getDebuggerType } from '../getDebuggerType';\nimport type { CdpMessage, DebuggerRequest, DeviceResponse } from '../types';\n\n/**\n * Hermes doesn't seem to handle this request, but `locations` have to be returned.\n * Respond with an empty location to make it \"spec compliant\" with Chrome DevTools.\n */\nexport class VscodeDebuggerGetPossibleBreakpointsHandler extends MessageHandler {\n  isEnabled() {\n    return getDebuggerType(this.debugger.userAgent) === 'vscode';\n  }\n\n  handleDebuggerMessage(message: DebuggerRequest<DebuggerGetPossibleBreakpoints>) {\n    if (message.method === 'Debugger.getPossibleBreakpoints') {\n      return this.sendToDebugger<DeviceResponse<DebuggerGetPossibleBreakpoints>>({\n        id: message.id,\n        result: { locations: [] },\n      });\n    }\n\n    return false;\n  }\n}\n\n/** @see https://chromedevtools.github.io/devtools-protocol/v8/Debugger/#method-getPossibleBreakpoints */\nexport type DebuggerGetPossibleBreakpoints = CdpMessage<\n  'Debugger.getPossibleBreakpoints',\n  Protocol.Debugger.GetPossibleBreakpointsRequest,\n  Protocol.Debugger.GetPossibleBreakpointsResponse\n>;\n"],"names":["VscodeDebuggerGetPossibleBreakpointsHandler","MessageHandler","isEnabled","getDebuggerType","debugger","userAgent","handleDebuggerMessage","message","method","sendToDebugger","id","result","locations"],"mappings":";;;;+BAUaA;;;eAAAA;;;gCARkB;iCACC;AAOzB,MAAMA,oDAAoDC,8BAAc;IAC7EC,YAAY;QACV,OAAOC,IAAAA,gCAAe,EAAC,IAAI,CAACC,QAAQ,CAACC,SAAS,MAAM;IACtD;IAEAC,sBAAsBC,OAAwD,EAAE;QAC9E,IAAIA,QAAQC,MAAM,KAAK,mCAAmC;YACxD,OAAO,IAAI,CAACC,cAAc,CAAiD;gBACzEC,IAAIH,QAAQG,EAAE;gBACdC,QAAQ;oBAAEC,WAAW,EAAE;gBAAC;YAC1B;QACF;QAEA,OAAO;IACT;AACF"}

package/build/src/start/server/metro/debugging/messageHandlers/VscodeDebuggerSetBreakpointByUrl.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VscodeDebuggerSetBreakpointByUrlHandler", {
+    enumerable: true,
+    get: function() {
+        return VscodeDebuggerSetBreakpointByUrlHandler;
+    }
+});
+const _MessageHandler = require("../MessageHandler");
+const _getDebuggerType = require("../getDebuggerType");
+class VscodeDebuggerSetBreakpointByUrlHandler extends _MessageHandler.MessageHandler {
+    isEnabled() {
+        return (0, _getDebuggerType.getDebuggerType)(this.debugger.userAgent) === 'vscode';
+    }
+    handleDebuggerMessage(message) {
+        if (message.method === 'Debugger.setBreakpointByUrl' && message.params.urlRegex) {
+            // Explicitly force the breakpoint to be unbounded
+            message.params.url = 'file://__invalid_url__';
+            delete message.params.urlRegex;
+        }
+        return false;
+    }
+}
+
+//# sourceMappingURL=VscodeDebuggerSetBreakpointByUrl.js.map

package/build/src/start/server/metro/debugging/messageHandlers/VscodeDebuggerSetBreakpointByUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/start/server/metro/debugging/messageHandlers/VscodeDebuggerSetBreakpointByUrl.ts"],"sourcesContent":["import type Protocol from 'devtools-protocol';\n\nimport { MessageHandler } from '../MessageHandler';\nimport { getDebuggerType } from '../getDebuggerType';\nimport type { CdpMessage, DebuggerRequest } from '../types';\n\n/**\n * Hermes and vscode have trouble setting breakpoints by `urlRegex` through `Debugger.setBreakpointByUrl`.\n * Vscode adds `file://` to a URL containing `http://`, which confuses Hermes and sets it to the wrong location.\n * Hermes needs to create the breakpoint to get the proper ID, but it must be unbounded.\n * Once the sourcemap is loaded, vscode will rebind the unbounded breakpoint to the correct location (using `Debugger.setBreakpoint`).\n */\nexport class VscodeDebuggerSetBreakpointByUrlHandler extends MessageHandler {\n  isEnabled() {\n    return getDebuggerType(this.debugger.userAgent) === 'vscode';\n  }\n\n  handleDebuggerMessage(message: DebuggerRequest<DebuggerSetBreakpointByUrl>) {\n    if (message.method === 'Debugger.setBreakpointByUrl' && message.params.urlRegex) {\n      // Explicitly force the breakpoint to be unbounded\n      message.params.url = 'file://__invalid_url__';\n      delete message.params.urlRegex;\n    }\n\n    return false;\n  }\n}\n\n/** @see https://chromedevtools.github.io/devtools-protocol/v8/Debugger/#method-setBreakpointByUrl */\nexport type DebuggerSetBreakpointByUrl = CdpMessage<\n  'Debugger.setBreakpointByUrl',\n  Protocol.Debugger.SetBreakpointByUrlRequest,\n  Protocol.Debugger.SetBreakpointByUrlResponse\n>;\n"],"names":["VscodeDebuggerSetBreakpointByUrlHandler","MessageHandler","isEnabled","getDebuggerType","debugger","userAgent","handleDebuggerMessage","message","method","params","urlRegex","url"],"mappings":";;;;+BAYaA;;;eAAAA;;;gCAVkB;iCACC;AASzB,MAAMA,gDAAgDC,8BAAc;IACzEC,YAAY;QACV,OAAOC,IAAAA,gCAAe,EAAC,IAAI,CAACC,QAAQ,CAACC,SAAS,MAAM;IACtD;IAEAC,sBAAsBC,OAAoD,EAAE;QAC1E,IAAIA,QAAQC,MAAM,KAAK,iCAAiCD,QAAQE,MAAM,CAACC,QAAQ,EAAE;YAC/E,kDAAkD;YAClDH,QAAQE,MAAM,CAACE,GAAG,GAAG;YACrB,OAAOJ,QAAQE,MAAM,CAACC,QAAQ;QAChC;QAEA,OAAO;IACT;AACF"}

package/build/src/start/server/metro/debugging/messageHandlers/VscodeRuntimeCallFunctionOn.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VscodeRuntimeCallFunctionOnHandler", {
+    enumerable: true,
+    get: function() {
+        return VscodeRuntimeCallFunctionOnHandler;
+    }
+});
+const _MessageHandler = require("../MessageHandler");
+const _getDebuggerType = require("../getDebuggerType");
+class VscodeRuntimeCallFunctionOnHandler extends _MessageHandler.MessageHandler {
+    isEnabled() {
+        return (0, _getDebuggerType.getDebuggerType)(this.debugger.userAgent) === 'vscode';
+    }
+    handleDebuggerMessage(message) {
+        if (message.method === 'Runtime.callFunctionOn') {
+            return this.sendToDebugger({
+                id: message.id,
+                result: {
+                    // We don't know the `type` and vscode allows `type: undefined`
+                    result: {
+                        objectId: message.params.objectId
+                    }
+                }
+            });
+        }
+        return false;
+    }
+}
+
+//# sourceMappingURL=VscodeRuntimeCallFunctionOn.js.map

package/build/src/start/server/metro/debugging/messageHandlers/VscodeRuntimeCallFunctionOn.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/start/server/metro/debugging/messageHandlers/VscodeRuntimeCallFunctionOn.ts"],"sourcesContent":["import type Protocol from 'devtools-protocol';\n\nimport { MessageHandler } from '../MessageHandler';\nimport { getDebuggerType } from '../getDebuggerType';\nimport type { CdpMessage, DebuggerRequest, DeviceResponse } from '../types';\n\n/**\n * Vscode is trying to inject a script to fetch information about \"Stringy\" variables.\n * Unfortunately, this script causes a Hermes exception and crashes the app.\n *\n * @see https://github.com/expo/vscode-expo/issues/231\n * @see https://github.com/microsoft/vscode-js-debug/blob/dcccaf3972d675cc1e5c776450bb4c3dc8c178c1/src/adapter/stackTrace.ts#L319-L324\n */\nexport class VscodeRuntimeCallFunctionOnHandler extends MessageHandler {\n  isEnabled() {\n    return getDebuggerType(this.debugger.userAgent) === 'vscode';\n  }\n\n  handleDebuggerMessage(message: DebuggerRequest<RuntimeCallFunctionOn>) {\n    if (message.method === 'Runtime.callFunctionOn') {\n      return this.sendToDebugger<DeviceResponse<RuntimeCallFunctionOn>>({\n        id: message.id,\n        result: {\n          // We don't know the `type` and vscode allows `type: undefined`\n          result: { objectId: message.params.objectId } as any,\n        },\n      });\n    }\n\n    return false;\n  }\n}\n\n/** @see https://chromedevtools.github.io/devtools-protocol/v8/Runtime/#method-callFunctionOn */\nexport type RuntimeCallFunctionOn = CdpMessage<\n  'Runtime.callFunctionOn',\n  Protocol.Runtime.CallFunctionOnRequest,\n  Protocol.Runtime.CallFunctionOnResponse\n>;\n"],"names":["VscodeRuntimeCallFunctionOnHandler","MessageHandler","isEnabled","getDebuggerType","debugger","userAgent","handleDebuggerMessage","message","method","sendToDebugger","id","result","objectId","params"],"mappings":";;;;+BAaaA;;;eAAAA;;;gCAXkB;iCACC;AAUzB,MAAMA,2CAA2CC,8BAAc;IACpEC,YAAY;QACV,OAAOC,IAAAA,gCAAe,EAAC,IAAI,CAACC,QAAQ,CAACC,SAAS,MAAM;IACtD;IAEAC,sBAAsBC,OAA+C,EAAE;QACrE,IAAIA,QAAQC,MAAM,KAAK,0BAA0B;YAC/C,OAAO,IAAI,CAACC,cAAc,CAAwC;gBAChEC,IAAIH,QAAQG,EAAE;gBACdC,QAAQ;oBACN,+DAA+D;oBAC/DA,QAAQ;wBAAEC,UAAUL,QAAQM,MAAM,CAACD,QAAQ;oBAAC;gBAC9C;YACF;QACF;QAEA,OAAO;IACT;AACF"}

package/build/src/start/server/metro/debugging/messageHandlers/VscodeRuntimeEvaluate.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VscodeRuntimeEvaluateHandler", {
+    enumerable: true,
+    get: function() {
+        return VscodeRuntimeEvaluateHandler;
+    }
+});
+const _MessageHandler = require("../MessageHandler");
+const _getDebuggerType = require("../getDebuggerType");
+class VscodeRuntimeEvaluateHandler extends _MessageHandler.MessageHandler {
+    isEnabled() {
+        return (0, _getDebuggerType.getDebuggerType)(this.debugger.userAgent) === 'vscode';
+    }
+    handleDebuggerMessage(message) {
+        if (message.method === 'Runtime.evaluate' && isVscodeNodeAttachEnvironmentInjection(message)) {
+            return this.sendToDebugger({
+                id: message.id,
+                result: {
+                    result: {
+                        type: 'string',
+                        value: `Hermes doesn't support environment variables through process.env`
+                    }
+                }
+            });
+        }
+        if (message.method === 'Runtime.evaluate' && isVscodeNodeTelemetry(message)) {
+            return this.sendToDebugger({
+                id: message.id,
+                result: {
+                    result: {
+                        type: 'object',
+                        value: {
+                            processId: this.page.id,
+                            nodeVersion: process.version,
+                            architecture: process.arch
+                        }
+                    }
+                }
+            });
+        }
+        return false;
+    }
+}
+/** @see https://github.com/microsoft/vscode-js-debug/blob/1d104b5184736677ab5cc280c70bbd227403850c/src/targets/node/nodeAttacherBase.ts#L22-L54 */ function isVscodeNodeAttachEnvironmentInjection(message) {
+    var _message_params, _message_params1, _message_params2;
+    return ((_message_params = message.params) == null ? void 0 : _message_params.expression.includes(`typeof process==='undefined'`)) && ((_message_params1 = message.params) == null ? void 0 : _message_params1.expression.includes(`'process not defined'`)) && ((_message_params2 = message.params) == null ? void 0 : _message_params2.expression.includes(`process.env["NODE_OPTIONS"]`));
+}
+/** @see https://github.com/microsoft/vscode-js-debug/blob/1d104b5184736677ab5cc280c70bbd227403850c/src/targets/node/nodeLauncherBase.ts#L523-L531 */ function isVscodeNodeTelemetry(message) {
+    var _message_params, _message_params1, _message_params2, _message_params3, _message_params4;
+    return ((_message_params = message.params) == null ? void 0 : _message_params.expression.includes(`typeof process === 'undefined'`)) && ((_message_params1 = message.params) == null ? void 0 : _message_params1.expression.includes(`'process not defined'`)) && ((_message_params2 = message.params) == null ? void 0 : _message_params2.expression.includes(`process.pid`)) && ((_message_params3 = message.params) == null ? void 0 : _message_params3.expression.includes(`process.version`)) && ((_message_params4 = message.params) == null ? void 0 : _message_params4.expression.includes(`process.arch`));
+}
+
+//# sourceMappingURL=VscodeRuntimeEvaluate.js.map

package/build/src/start/server/metro/debugging/messageHandlers/VscodeRuntimeEvaluate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/start/server/metro/debugging/messageHandlers/VscodeRuntimeEvaluate.ts"],"sourcesContent":["import type Protocol from 'devtools-protocol';\n\nimport { MessageHandler } from '../MessageHandler';\nimport { getDebuggerType } from '../getDebuggerType';\nimport type { CdpMessage, DebuggerRequest, DeviceResponse } from '../types';\n\n/**\n * Vscode is trying to inject a script to configure Node environment variables.\n * This won't work in Hermes, but vscode will retry this 200x.\n * Avoid sending this \"spam\" to the device.\n *\n * @see https://github.com/microsoft/vscode-js-debug/blob/1d104b5184736677ab5cc280c70bbd227403850c/src/targets/node/nodeAttacherBase.ts#L22-L54\n */\nexport class VscodeRuntimeEvaluateHandler extends MessageHandler {\n  isEnabled() {\n    return getDebuggerType(this.debugger.userAgent) === 'vscode';\n  }\n\n  handleDebuggerMessage(message: DebuggerRequest<RuntimeEvaluate>) {\n    if (message.method === 'Runtime.evaluate' && isVscodeNodeAttachEnvironmentInjection(message)) {\n      return this.sendToDebugger<DeviceResponse<RuntimeEvaluate>>({\n        id: message.id,\n        result: {\n          result: {\n            type: 'string',\n            value: `Hermes doesn't support environment variables through process.env`,\n          },\n        },\n      });\n    }\n\n    if (message.method === 'Runtime.evaluate' && isVscodeNodeTelemetry(message)) {\n      return this.sendToDebugger<DeviceResponse<RuntimeEvaluate>>({\n        id: message.id,\n        result: {\n          result: {\n            type: 'object',\n            value: {\n              processId: this.page.id,\n              nodeVersion: process.version,\n              architecture: process.arch,\n            },\n          },\n        },\n      });\n    }\n\n    return false;\n  }\n}\n\n/** @see https://chromedevtools.github.io/devtools-protocol/v8/Runtime/#method-evaluate */\nexport type RuntimeEvaluate = CdpMessage<\n  'Runtime.evaluate',\n  Protocol.Runtime.EvaluateRequest,\n  Protocol.Runtime.EvaluateResponse\n>;\n\n/** @see https://github.com/microsoft/vscode-js-debug/blob/1d104b5184736677ab5cc280c70bbd227403850c/src/targets/node/nodeAttacherBase.ts#L22-L54 */\nfunction isVscodeNodeAttachEnvironmentInjection(message: DebuggerRequest<RuntimeEvaluate>) {\n  return (\n    message.params?.expression.includes(`typeof process==='undefined'`) &&\n    message.params?.expression.includes(`'process not defined'`) &&\n    message.params?.expression.includes(`process.env[\"NODE_OPTIONS\"]`)\n  );\n}\n\n/** @see https://github.com/microsoft/vscode-js-debug/blob/1d104b5184736677ab5cc280c70bbd227403850c/src/targets/node/nodeLauncherBase.ts#L523-L531 */\nfunction isVscodeNodeTelemetry(message: DebuggerRequest<RuntimeEvaluate>) {\n  return (\n    message.params?.expression.includes(`typeof process === 'undefined'`) &&\n    message.params?.expression.includes(`'process not defined'`) &&\n    message.params?.expression.includes(`process.pid`) &&\n    message.params?.expression.includes(`process.version`) &&\n    message.params?.expression.includes(`process.arch`)\n  );\n}\n"],"names":["VscodeRuntimeEvaluateHandler","MessageHandler","isEnabled","getDebuggerType","debugger","userAgent","handleDebuggerMessage","message","method","isVscodeNodeAttachEnvironmentInjection","sendToDebugger","id","result","type","value","isVscodeNodeTelemetry","processId","page","nodeVersion","process","version","architecture","arch","params","expression","includes"],"mappings":";;;;+BAaaA;;;eAAAA;;;gCAXkB;iCACC;AAUzB,MAAMA,qCAAqCC,8BAAc;IAC9DC,YAAY;QACV,OAAOC,IAAAA,gCAAe,EAAC,IAAI,CAACC,QAAQ,CAACC,SAAS,MAAM;IACtD;IAEAC,sBAAsBC,OAAyC,EAAE;QAC/D,IAAIA,QAAQC,MAAM,KAAK,sBAAsBC,uCAAuCF,UAAU;YAC5F,OAAO,IAAI,CAACG,cAAc,CAAkC;gBAC1DC,IAAIJ,QAAQI,EAAE;gBACdC,QAAQ;oBACNA,QAAQ;wBACNC,MAAM;wBACNC,OAAO,CAAC,gEAAgE,CAAC;oBAC3E;gBACF;YACF;QACF;QAEA,IAAIP,QAAQC,MAAM,KAAK,sBAAsBO,sBAAsBR,UAAU;YAC3E,OAAO,IAAI,CAACG,cAAc,CAAkC;gBAC1DC,IAAIJ,QAAQI,EAAE;gBACdC,QAAQ;oBACNA,QAAQ;wBACNC,MAAM;wBACNC,OAAO;4BACLE,WAAW,IAAI,CAACC,IAAI,CAACN,EAAE;4BACvBO,aAAaC,QAAQC,OAAO;4BAC5BC,cAAcF,QAAQG,IAAI;wBAC5B;oBACF;gBACF;YACF;QACF;QAEA,OAAO;IACT;AACF;AASA,iJAAiJ,GACjJ,SAASb,uCAAuCF,OAAyC;QAErFA,iBACAA,kBACAA;IAHF,OACEA,EAAAA,kBAAAA,QAAQgB,MAAM,qBAAdhB,gBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,4BAA4B,CAAC,QAClElB,mBAAAA,QAAQgB,MAAM,qBAAdhB,iBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,qBAAqB,CAAC,QAC3DlB,mBAAAA,QAAQgB,MAAM,qBAAdhB,iBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,2BAA2B,CAAC;AAErE;AAEA,mJAAmJ,GACnJ,SAASV,sBAAsBR,OAAyC;QAEpEA,iBACAA,kBACAA,kBACAA,kBACAA;IALF,OACEA,EAAAA,kBAAAA,QAAQgB,MAAM,qBAAdhB,gBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,8BAA8B,CAAC,QACpElB,mBAAAA,QAAQgB,MAAM,qBAAdhB,iBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,qBAAqB,CAAC,QAC3DlB,mBAAAA,QAAQgB,MAAM,qBAAdhB,iBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,WAAW,CAAC,QACjDlB,mBAAAA,QAAQgB,MAAM,qBAAdhB,iBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,eAAe,CAAC,QACrDlB,mBAAAA,QAAQgB,MAAM,qBAAdhB,iBAAgBiB,UAAU,CAACC,QAAQ,CAAC,CAAC,YAAY,CAAC;AAEtD"}

package/build/src/start/server/metro/debugging/messageHandlers/VscodeRuntimeGetProperties.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VscodeRuntimeGetPropertiesHandler", {
+    enumerable: true,
+    get: function() {
+        return VscodeRuntimeGetPropertiesHandler;
+    }
+});
+const _MessageHandler = require("../MessageHandler");
+const _getDebuggerType = require("../getDebuggerType");
+class VscodeRuntimeGetPropertiesHandler extends _MessageHandler.MessageHandler {
+    isEnabled() {
+        return (0, _getDebuggerType.getDebuggerType)(this.debugger.userAgent) === 'vscode';
+    }
+    handleDebuggerMessage(message) {
+        if (message.method === 'Runtime.getProperties') {
+            this.interceptGetProperties.add(message.id);
+        }
+        // Do not block propagation of this message
+        return false;
+    }
+    handleDeviceMessage(message) {
+        if ('id' in message && this.interceptGetProperties.has(message.id)) {
+            this.interceptGetProperties.delete(message.id);
+            for (const item of message.result.result ?? []){
+                var _item_value;
+                // Force-fully format the properties description to be an empty string
+                if (item.value) {
+                    item.value.description = item.value.description ?? '';
+                }
+                // Avoid passing the `objectId` for symbol types.
+                // When collapsing in vscode, it will fetch information about the symbol using the `objectId`.
+                // The `Runtime.getProperties` request of the symbol hard-crashes Hermes.
+                if (((_item_value = item.value) == null ? void 0 : _item_value.type) === 'symbol' && item.value.objectId) {
+                    delete item.value.objectId;
+                }
+            }
+        }
+        // Do not block propagation of this message
+        return false;
+    }
+    constructor(...args){
+        super(...args), /** Keep track of `Runtime.getProperties` responses to intercept, by request id */ this.interceptGetProperties = new Set();
+    }
+}
+
+//# sourceMappingURL=VscodeRuntimeGetProperties.js.map

package/build/src/start/server/metro/debugging/messageHandlers/VscodeRuntimeGetProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../src/start/server/metro/debugging/messageHandlers/VscodeRuntimeGetProperties.ts"],"sourcesContent":["import type Protocol from 'devtools-protocol';\n\nimport { MessageHandler } from '../MessageHandler';\nimport { getDebuggerType } from '../getDebuggerType';\nimport type { CdpMessage, DebuggerRequest, DeviceResponse } from '../types';\n\n/**\n * Vscode doesn't seem to work nicely with missing `description` fields on `RemoteObject` instances.\n * It also tries to invoke `Runtime.callFunctionOn` on `Symbol` types, which crashes Hermes.\n * This handler tries to compensate for these two separate issues.\n *\n * @see https://github.com/facebook/hermes/issues/114\n * @see https://github.com/microsoft/vscode-js-debug/issues/1583\n */\nexport class VscodeRuntimeGetPropertiesHandler extends MessageHandler {\n  /** Keep track of `Runtime.getProperties` responses to intercept, by request id */\n  interceptGetProperties = new Set<number>();\n\n  isEnabled() {\n    return getDebuggerType(this.debugger.userAgent) === 'vscode';\n  }\n\n  handleDebuggerMessage(message: DebuggerRequest<RuntimeGetProperties>) {\n    if (message.method === 'Runtime.getProperties') {\n      this.interceptGetProperties.add(message.id);\n    }\n\n    // Do not block propagation of this message\n    return false;\n  }\n\n  handleDeviceMessage(message: DeviceResponse<RuntimeGetProperties>) {\n    if ('id' in message && this.interceptGetProperties.has(message.id)) {\n      this.interceptGetProperties.delete(message.id);\n\n      for (const item of message.result.result ?? []) {\n        // Force-fully format the properties description to be an empty string\n        if (item.value) {\n          item.value.description = item.value.description ?? '';\n        }\n\n        // Avoid passing the `objectId` for symbol types.\n        // When collapsing in vscode, it will fetch information about the symbol using the `objectId`.\n        // The `Runtime.getProperties` request of the symbol hard-crashes Hermes.\n        if (item.value?.type === 'symbol' && item.value.objectId) {\n          delete item.value.objectId;\n        }\n      }\n    }\n\n    // Do not block propagation of this message\n    return false;\n  }\n}\n\n/** @see https://chromedevtools.github.io/devtools-protocol/v8/Runtime/#method-getProperties */\nexport type RuntimeGetProperties = CdpMessage<\n  'Runtime.getProperties',\n  Protocol.Runtime.GetPropertiesRequest,\n  Protocol.Runtime.GetPropertiesResponse\n>;\n"],"names":["VscodeRuntimeGetPropertiesHandler","MessageHandler","isEnabled","getDebuggerType","debugger","userAgent","handleDebuggerMessage","message","method","interceptGetProperties","add","id","handleDeviceMessage","has","delete","item","result","value","description","type","objectId","Set"],"mappings":";;;;+BAcaA;;;eAAAA;;;gCAZkB;iCACC;AAWzB,MAAMA,0CAA0CC,8BAAc;IAInEC,YAAY;QACV,OAAOC,IAAAA,gCAAe,EAAC,IAAI,CAACC,QAAQ,CAACC,SAAS,MAAM;IACtD;IAEAC,sBAAsBC,OAA8C,EAAE;QACpE,IAAIA,QAAQC,MAAM,KAAK,yBAAyB;YAC9C,IAAI,CAACC,sBAAsB,CAACC,GAAG,CAACH,QAAQI,EAAE;QAC5C;QAEA,2CAA2C;QAC3C,OAAO;IACT;IAEAC,oBAAoBL,OAA6C,EAAE;QACjE,IAAI,QAAQA,WAAW,IAAI,CAACE,sBAAsB,CAACI,GAAG,CAACN,QAAQI,EAAE,GAAG;YAClE,IAAI,CAACF,sBAAsB,CAACK,MAAM,CAACP,QAAQI,EAAE;YAE7C,KAAK,MAAMI,QAAQR,QAAQS,MAAM,CAACA,MAAM,IAAI,EAAE,CAAE;oBAS1CD;gBARJ,sEAAsE;gBACtE,IAAIA,KAAKE,KAAK,EAAE;oBACdF,KAAKE,KAAK,CAACC,WAAW,GAAGH,KAAKE,KAAK,CAACC,WAAW,IAAI;gBACrD;gBAEA,iDAAiD;gBACjD,8FAA8F;gBAC9F,yEAAyE;gBACzE,IAAIH,EAAAA,cAAAA,KAAKE,KAAK,qBAAVF,YAAYI,IAAI,MAAK,YAAYJ,KAAKE,KAAK,CAACG,QAAQ,EAAE;oBACxD,OAAOL,KAAKE,KAAK,CAACG,QAAQ;gBAC5B;YACF;QACF;QAEA,2CAA2C;QAC3C,OAAO;IACT;;QAtCK,gBACL,gFAAgF,QAChFX,yBAAyB,IAAIY;;AAqC/B"}

package/build/src/start/server/metro/debugging/pageIsSupported.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pageIsSupported", {
+    enumerable: true,
+    get: function() {
+        return pageIsSupported;
+    }
+});
+function pageIsSupported(page) {
+    var _page_reactNative;
+    const capabilities = page.capabilities ?? ((_page_reactNative = page.reactNative) == null ? void 0 : _page_reactNative.capabilities) ?? {};
+    return page.title === 'React Native Experimental (Improved Chrome Reloads)' || capabilities.nativePageReloads === true;
+}
+
+//# sourceMappingURL=pageIsSupported.js.map

package/build/src/start/server/metro/debugging/pageIsSupported.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/debugging/pageIsSupported.ts"],"sourcesContent":["import { Page } from './types';\n\ntype DevicePageInternal = Pick<Page, 'title' | 'capabilities'>;\ntype DevicePageResponse = {\n  title: string;\n  reactNative?: {\n    logicalDeviceId: string;\n    capabilities: Page['capabilities'];\n  };\n};\n\n/**\n * Determine if a page debug target is supported by our debugging extensions.\n * If it's not, the extended CDP handlers will not be enabled.\n */\nexport function pageIsSupported(page: DevicePageInternal | DevicePageResponse): boolean {\n  const capabilities =\n    (page as DevicePageInternal).capabilities ??\n    (page as DevicePageResponse).reactNative?.capabilities ??\n    {};\n\n  return (\n    page.title === 'React Native Experimental (Improved Chrome Reloads)' ||\n    capabilities.nativePageReloads === true\n  );\n}\n"],"names":["pageIsSupported","page","capabilities","reactNative","title","nativePageReloads"],"mappings":";;;;+BAegBA;;;eAAAA;;;AAAT,SAASA,gBAAgBC,IAA6C;QAGzE;IAFF,MAAMC,eACJ,AAACD,KAA4BC,YAAY,MACzC,oBAAA,AAACD,KAA4BE,WAAW,qBAAxC,kBAA0CD,YAAY,KACtD,CAAC;IAEH,OACED,KAAKG,KAAK,KAAK,yDACfF,aAAaG,iBAAiB,KAAK;AAEvC"}

package/build/src/start/server/metro/debugging/types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=types.js.map

package/build/src/start/server/metro/debugging/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/build/src/start/server/metro/dev-server/compression.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "compression", {
+    enumerable: true,
+    get: function() {
+        return compression;
+    }
+});
+const createCompressionMiddleware = require('compression');
+const compressionMiddleware = createCompressionMiddleware();
+const compression = (req, res, next)=>{
+    // We need to make compression decision based on request,
+    // because resposnse is not ready when the middleware is executed.
+    if (!req.url) {
+        return next();
+    }
+    const pathname = getPathname(req.url);
+    // Detection based on Metro Server implementation
+    // All pathnames ending with .bundle or .map are handled as bundles and source maps respectively.
+    // https://github.com/facebook/metro/blob/83fd895c567207efb6568cb8850bf05a238d83d2/packages/metro/src/Server.js#L649
+    if (isBundle(pathname) || isSourceMap(pathname)) {
+        return compressionMiddleware(req, res, next);
+    }
+    // For all other pathnames, we skip compression.
+    return next();
+};
+function getPathname(url) {
+    let pathname;
+    try {
+        pathname = new URL(url, 'https://expo.dev').pathname;
+    } catch  {
+        pathname = '';
+    }
+    return pathname;
+}
+function isBundle(pathname) {
+    return pathname.endsWith('.bundle');
+}
+function isSourceMap(pathname) {
+    return pathname.endsWith('.map');
+}
+
+//# sourceMappingURL=compression.js.map

package/build/src/start/server/metro/dev-server/compression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/dev-server/compression.ts"],"sourcesContent":["import { NextHandleFunction } from 'connect';\n\nconst createCompressionMiddleware = require('compression');\n\nconst compressionMiddleware = createCompressionMiddleware();\n\n/**\n * Compression middleware that allows compression for bundles and source maps only.\n */\nexport const compression: NextHandleFunction = (req, res, next) => {\n  // We need to make compression decision based on request,\n  // because resposnse is not ready when the middleware is executed.\n\n  if (!req.url) {\n    return next();\n  }\n\n  const pathname = getPathname(req.url);\n\n  // Detection based on Metro Server implementation\n  // All pathnames ending with .bundle or .map are handled as bundles and source maps respectively.\n  // https://github.com/facebook/metro/blob/83fd895c567207efb6568cb8850bf05a238d83d2/packages/metro/src/Server.js#L649\n  if (isBundle(pathname) || isSourceMap(pathname)) {\n    return compressionMiddleware(req, res, next);\n  }\n\n  // For all other pathnames, we skip compression.\n  return next();\n};\n\nfunction getPathname(url: string): string {\n  let pathname: string;\n  try {\n    pathname = new URL(url, 'https://expo.dev').pathname;\n  } catch {\n    pathname = '';\n  }\n  return pathname;\n}\n\nfunction isBundle(pathname: string): boolean {\n  return pathname.endsWith('.bundle');\n}\n\nfunction isSourceMap(pathname: string): boolean {\n  return pathname.endsWith('.map');\n}\n"],"names":["compression","createCompressionMiddleware","require","compressionMiddleware","req","res","next","url","pathname","getPathname","isBundle","isSourceMap","URL","endsWith"],"mappings":";;;;+BASaA;;;eAAAA;;;AAPb,MAAMC,8BAA8BC,QAAQ;AAE5C,MAAMC,wBAAwBF;AAKvB,MAAMD,cAAkC,CAACI,KAAKC,KAAKC;IACxD,yDAAyD;IACzD,kEAAkE;IAElE,IAAI,CAACF,IAAIG,GAAG,EAAE;QACZ,OAAOD;IACT;IAEA,MAAME,WAAWC,YAAYL,IAAIG,GAAG;IAEpC,iDAAiD;IACjD,iGAAiG;IACjG,oHAAoH;IACpH,IAAIG,SAASF,aAAaG,YAAYH,WAAW;QAC/C,OAAOL,sBAAsBC,KAAKC,KAAKC;IACzC;IAEA,gDAAgD;IAChD,OAAOA;AACT;AAEA,SAASG,YAAYF,GAAW;IAC9B,IAAIC;IACJ,IAAI;QACFA,WAAW,IAAII,IAAIL,KAAK,oBAAoBC,QAAQ;IACtD,EAAE,OAAM;QACNA,WAAW;IACb;IACA,OAAOA;AACT;AAEA,SAASE,SAASF,QAAgB;IAChC,OAAOA,SAASK,QAAQ,CAAC;AAC3B;AAEA,SAASF,YAAYH,QAAgB;IACnC,OAAOA,SAASK,QAAQ,CAAC;AAC3B"}

package/build/src/start/server/metro/dev-server/createEventSocket.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createEventsSocket", {
+    enumerable: true,
+    get: function() {
+        return createEventsSocket;
+    }
+});
+function _prettyformat() {
+    const data = require("pretty-format");
+    _prettyformat = function() {
+        return data;
+    };
+    return data;
+}
+function _ws() {
+    const data = require("ws");
+    _ws = function() {
+        return data;
+    };
+    return data;
+}
+const _createSocketBroadcaster = require("./utils/createSocketBroadcaster");
+const _createSocketMap = require("./utils/createSocketMap");
+const _socketMessages = require("./utils/socketMessages");
+const debug = require('debug')('expo:metro:devserver:eventsSocket');
+function createEventsSocket(options) {
+    const clients = (0, _createSocketMap.createSocketMap)();
+    const broadcast = (0, _createSocketBroadcaster.createBroadcaster)(clients.map);
+    const server = new (_ws()).WebSocketServer({
+        noServer: true,
+        verifyClient ({ origin }) {
+            // This exposes the full JS logs and enables issuing commands like reload
+            // so let's make sure only locally running stuff can connect to it
+            // origin is only checked if it is set, e.g. when the request is made from a (CORS) browser
+            // any 'back-end' connection isn't CORS at all, and has full control over the origin header,
+            // so there is no point in checking it security wise
+            return !origin || origin.startsWith('http://localhost:') || origin.startsWith('file:');
+        }
+    });
+    server.on('connection', (socket)=>{
+        const client = clients.registerSocket(socket);
+        // Register disconnect handlers
+        socket.on('close', client.terminate);
+        socket.on('error', client.terminate);
+        // Register message handler
+        socket.on('message', (data, isBinary)=>{
+            const message = (0, _socketMessages.parseRawMessage)(data, isBinary);
+            if (!message) return;
+            if (message.type === 'command') {
+                options.broadcast(message.command, message.params);
+            } else {
+                debug(`Received unknown message type: ${message.type}`);
+            }
+        });
+    });
+    return {
+        endpoint: '/events',
+        server: new (_ws()).WebSocketServer({
+            noServer: true
+        }),
+        reportMetroEvent: (event)=>{
+            // Avoid serializing data if there are no clients
+            if (!clients.map.size) {
+                return;
+            }
+            return broadcast(null, serializeMetroEvent(event));
+        }
+    };
+}
+function serializeMetroEvent(message) {
+    // Some types reported by Metro are not serializable
+    if (message && message.error && message.error instanceof Error) {
+        return (0, _socketMessages.serializeMessage)({
+            ...message,
+            error: (0, _prettyformat().format)(message.error, {
+                escapeString: true,
+                highlight: true,
+                maxDepth: 3,
+                min: true
+            })
+        });
+    }
+    if (message && message.type === 'client_log') {
+        return (0, _socketMessages.serializeMessage)({
+            ...message,
+            data: message.data.map((item)=>typeof item === 'string' ? item : (0, _prettyformat().format)(item, {
+                    escapeString: true,
+                    highlight: true,
+                    maxDepth: 3,
+                    min: true,
+                    plugins: [
+                        _prettyformat().plugins.ReactElement
+                    ]
+                }))
+        });
+    }
+    return (0, _socketMessages.serializeMessage)(message);
+}
+
+//# sourceMappingURL=createEventSocket.js.map

package/build/src/start/server/metro/dev-server/createEventSocket.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/start/server/metro/dev-server/createEventSocket.ts"],"sourcesContent":["import { format as prettyFormat, plugins as prettyPlugins } from 'pretty-format';\nimport { WebSocketServer } from 'ws';\n\nimport type { createMessagesSocket } from './createMessageSocket';\nimport { createBroadcaster } from './utils/createSocketBroadcaster';\nimport { createSocketMap } from './utils/createSocketMap';\nimport { parseRawMessage, serializeMessage } from './utils/socketMessages';\n\nconst debug = require('debug')('expo:metro:devserver:eventsSocket') as typeof console.log;\n\ntype EventsSocketOptions = {\n  /** The message endpoint broadcaster, used to relay commands from Metro */\n  broadcast: ReturnType<typeof createMessagesSocket>['broadcast'];\n};\n\n/**\n * Metro events server that dispatches all Metro events to connected clients.\n * This includes logs, errors, bundling progression, etc.\n */\nexport function createEventsSocket(options: EventsSocketOptions) {\n  const clients = createSocketMap();\n  const broadcast = createBroadcaster(clients.map);\n\n  const server = new WebSocketServer({\n    noServer: true,\n    verifyClient({ origin }: { origin: string }) {\n      // This exposes the full JS logs and enables issuing commands like reload\n      // so let's make sure only locally running stuff can connect to it\n      // origin is only checked if it is set, e.g. when the request is made from a (CORS) browser\n      // any 'back-end' connection isn't CORS at all, and has full control over the origin header,\n      // so there is no point in checking it security wise\n      return !origin || origin.startsWith('http://localhost:') || origin.startsWith('file:');\n    },\n  });\n\n  server.on('connection', (socket) => {\n    const client = clients.registerSocket(socket);\n\n    // Register disconnect handlers\n    socket.on('close', client.terminate);\n    socket.on('error', client.terminate);\n    // Register message handler\n    socket.on('message', (data, isBinary) => {\n      const message = parseRawMessage<Command>(data, isBinary);\n      if (!message) return;\n\n      if (message.type === 'command') {\n        options.broadcast(message.command, message.params);\n      } else {\n        debug(`Received unknown message type: ${message.type}`);\n      }\n    });\n  });\n\n  return {\n    endpoint: '/events' as const,\n    server: new WebSocketServer({ noServer: true }),\n    reportMetroEvent: (event: any) => {\n      // Avoid serializing data if there are no clients\n      if (!clients.map.size) {\n        return;\n      }\n\n      return broadcast(null, serializeMetroEvent(event));\n    },\n  };\n}\n\ntype Command = {\n  type: 'command';\n  command: string;\n  params?: any;\n};\n\nfunction serializeMetroEvent(message: any): string {\n  // Some types reported by Metro are not serializable\n  if (message && message.error && message.error instanceof Error) {\n    return serializeMessage({\n      ...message,\n      error: prettyFormat(message.error, {\n        escapeString: true,\n        highlight: true,\n        maxDepth: 3,\n        min: true,\n      }),\n    });\n  }\n\n  if (message && message.type === 'client_log') {\n    return serializeMessage({\n      ...message,\n      data: message.data.map((item: any) =>\n        typeof item === 'string'\n          ? item\n          : prettyFormat(item, {\n              escapeString: true,\n              highlight: true,\n              maxDepth: 3,\n              min: true,\n              plugins: [prettyPlugins.ReactElement],\n            })\n      ),\n    });\n  }\n\n  return serializeMessage(message);\n}\n"],"names":["createEventsSocket","debug","require","options","clients","createSocketMap","broadcast","createBroadcaster","map","server","WebSocketServer","noServer","verifyClient","origin","startsWith","on","socket","client","registerSocket","terminate","data","isBinary","message","parseRawMessage","type","command","params","endpoint","reportMetroEvent","event","size","serializeMetroEvent","error","Error","serializeMessage","prettyFormat","escapeString","highlight","maxDepth","min","item","plugins","prettyPlugins","ReactElement"],"mappings":";;;;+BAmBgBA;;;eAAAA;;;;yBAnBiD;;;;;;;yBACjC;;;;;;yCAGE;iCACF;gCACkB;AAElD,MAAMC,QAAQC,QAAQ,SAAS;AAWxB,SAASF,mBAAmBG,OAA4B;IAC7D,MAAMC,UAAUC,IAAAA,gCAAe;IAC/B,MAAMC,YAAYC,IAAAA,0CAAiB,EAACH,QAAQI,GAAG;IAE/C,MAAMC,SAAS,IAAIC,CAAAA,KAAc,iBAAC,CAAC;QACjCC,UAAU;QACVC,cAAa,EAAEC,MAAM,EAAsB;YACzC,yEAAyE;YACzE,kEAAkE;YAClE,2FAA2F;YAC3F,4FAA4F;YAC5F,oDAAoD;YACpD,OAAO,CAACA,UAAUA,OAAOC,UAAU,CAAC,wBAAwBD,OAAOC,UAAU,CAAC;QAChF;IACF;IAEAL,OAAOM,EAAE,CAAC,cAAc,CAACC;QACvB,MAAMC,SAASb,QAAQc,cAAc,CAACF;QAEtC,+BAA+B;QAC/BA,OAAOD,EAAE,CAAC,SAASE,OAAOE,SAAS;QACnCH,OAAOD,EAAE,CAAC,SAASE,OAAOE,SAAS;QACnC,2BAA2B;QAC3BH,OAAOD,EAAE,CAAC,WAAW,CAACK,MAAMC;YAC1B,MAAMC,UAAUC,IAAAA,+BAAe,EAAUH,MAAMC;YAC/C,IAAI,CAACC,SAAS;YAEd,IAAIA,QAAQE,IAAI,KAAK,WAAW;gBAC9BrB,QAAQG,SAAS,CAACgB,QAAQG,OAAO,EAAEH,QAAQI,MAAM;YACnD,OAAO;gBACLzB,MAAM,CAAC,+BAA+B,EAAEqB,QAAQE,IAAI,EAAE;YACxD;QACF;IACF;IAEA,OAAO;QACLG,UAAU;QACVlB,QAAQ,IAAIC,CAAAA,KAAc,iBAAC,CAAC;YAAEC,UAAU;QAAK;QAC7CiB,kBAAkB,CAACC;YACjB,iDAAiD;YACjD,IAAI,CAACzB,QAAQI,GAAG,CAACsB,IAAI,EAAE;gBACrB;YACF;YAEA,OAAOxB,UAAU,MAAMyB,oBAAoBF;QAC7C;IACF;AACF;AAQA,SAASE,oBAAoBT,OAAY;IACvC,oDAAoD;IACpD,IAAIA,WAAWA,QAAQU,KAAK,IAAIV,QAAQU,KAAK,YAAYC,OAAO;QAC9D,OAAOC,IAAAA,gCAAgB,EAAC;YACtB,GAAGZ,OAAO;YACVU,OAAOG,IAAAA,sBAAY,EAACb,QAAQU,KAAK,EAAE;gBACjCI,cAAc;gBACdC,WAAW;gBACXC,UAAU;gBACVC,KAAK;YACP;QACF;IACF;IAEA,IAAIjB,WAAWA,QAAQE,IAAI,KAAK,cAAc;QAC5C,OAAOU,IAAAA,gCAAgB,EAAC;YACtB,GAAGZ,OAAO;YACVF,MAAME,QAAQF,IAAI,CAACZ,GAAG,CAAC,CAACgC,OACtB,OAAOA,SAAS,WACZA,OACAL,IAAAA,sBAAY,EAACK,MAAM;oBACjBJ,cAAc;oBACdC,WAAW;oBACXC,UAAU;oBACVC,KAAK;oBACLE,SAAS;wBAACC,uBAAa,CAACC,YAAY;qBAAC;gBACvC;QAER;IACF;IAEA,OAAOT,IAAAA,gCAAgB,EAACZ;AAC1B"}