static async runTraceEngine(traceEvents, settings, SourceMaps) {
    const processor = new TraceEngine.TraceProcessor(TraceEngine.TraceHandlers);

    const lanternSettings = {};
    if (settings.throttlingMethod) lanternSettings.throttlingMethod = settings.throttlingMethod;
    if (settings.throttling) lanternSettings.throttling = settings.throttling;
    if (settings.precomputedLanternData) {
      lanternSettings.precomputedLanternData = settings.precomputedLanternData;
    }

    await processor.parse(/** @type {import('@paulirish/trace_engine').Types.Events.Event[]} */ (
      traceEvents
    ), {
      logger: {
        start(id) {
          const logId = `lh:computed:TraceEngineResult:${id}`;
          log.time({msg: `Trace Engine ${id}`, id: logId});
        },
        end(id) {
          const logId = `lh:computed:TraceEngineResult:${id}`;
          log.timeEnd({msg: `Trace Engine ${id}`, id: logId});
        },
      },
      lanternSettings,
      async resolveSourceMap(params) {
        const sourceMap = SourceMaps.find(sm => sm.scriptId === params.scriptId);
        if (!sourceMap || !sourceMap.map) {
          return null;
        }

        const compiledUrl = sourceMap.scriptUrl || 'compiled.js';
        const mapUrl = sourceMap.sourceMapUrl || 'compiled.js.map';
        return new SDK.SourceMap(compiledUrl, mapUrl, sourceMap.map);
      },
    });
    if (!processor.parsedTrace) throw new Error('No data');
    if (!processor.insights) throw new Error('No insights');
    this.localizeInsights(processor.insights);
    return {parsedTrace: processor.parsedTrace, insights: processor.insights};
  }
@param {LH.TraceEvent[]} traceEvents
@param {LH.Audit.Context['settings']} settings
@param {LH.Artifacts['SourceMaps']} SourceMaps
@return {Promise<LH.Artifacts.TraceEngineResult>}