lighthouse 9.6.8 → 10.0.0-dev.20230210

package/core/lib/sentry.js

@@ -0,0 +1,143 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import log from 'lighthouse-logger';
+
+/** @typedef {import('@sentry/node').Breadcrumb} Breadcrumb */
+/** @typedef {import('@sentry/node').NodeClient} NodeClient */
+/** @typedef {import('@sentry/node').NodeOptions} NodeOptions */
+/** @typedef {import('@sentry/node').Severity} Severity */
+
+const SENTRY_URL = 'https://a6bb0da87ee048cc9ae2a345fc09ab2e:63a7029f46f74265981b7e005e0f69f8@sentry.io/174697';
+
+// Per-run chance of capturing errors (if enabled).
+const SAMPLE_RATE = 0.01;
+
+/** @type {Array<{pattern: RegExp, rate: number}>} */
+const SAMPLED_ERRORS = [
+  // Error code based sampling. Delete if still unused after 2019-01-01.
+  // e.g.: {pattern: /No.*node with given id/, rate: 0.01},
+];
+
+const noop = () => { };
+
+/**
+ * A delegate for sentry so that environments without error reporting enabled will use
+ * noop functions and environments with error reporting will call the actual Sentry methods.
+ */
+const sentryDelegate = {
+  init,
+  /** @type {(message: string, level?: Severity) => void} */
+  captureMessage: noop,
+  /** @type {(breadcrumb: Breadcrumb) => void} */
+  captureBreadcrumb: noop,
+  /** @type {() => any} */
+  getContext: noop,
+  /** @type {(error: Error, options: {level?: string, tags?: {[key: string]: any}, extra?: {[key: string]: any}}) => Promise<void>} */
+  captureException: async () => { },
+  _shouldSample() {
+    return SAMPLE_RATE >= Math.random();
+  },
+};
+
+/**
+ * When called, replaces noops with actual Sentry implementation.
+ * @param {{url: string, flags: LH.CliFlags, environmentData: NodeOptions}} opts
+ */
+async function init(opts) {
+  // If error reporting is disabled, leave the functions as a noop
+  if (!opts.flags.enableErrorReporting) {
+    return;
+  }
+
+  // If not selected for samping, leave the functions as a noop.
+  if (!sentryDelegate._shouldSample()) {
+    return;
+  }
+
+  try {
+    const Sentry = await import('@sentry/node');
+    Sentry.init({
+      ...opts.environmentData,
+      dsn: SENTRY_URL,
+    });
+
+    const extras = {
+      ...opts.flags.throttling,
+      channel: opts.flags.channel || 'cli',
+      url: opts.url,
+      formFactor: opts.flags.formFactor,
+      throttlingMethod: opts.flags.throttlingMethod,
+    };
+    Sentry.setExtras(extras);
+
+    // Have each delegate function call the corresponding sentry function by default
+    sentryDelegate.captureMessage = (...args) => Sentry.captureMessage(...args);
+    sentryDelegate.captureBreadcrumb = (...args) => Sentry.addBreadcrumb(...args);
+    sentryDelegate.getContext = () => extras;
+
+    // Keep a record of exceptions per audit/gatherer so we can just report once
+    const sentryExceptionCache = new Map();
+    // Special case captureException to return a Promise so we don't process.exit too early
+    sentryDelegate.captureException = async (err, opts = {}) => {
+      // Ignore if there wasn't an error
+      if (!err) return;
+
+      // Ignore expected errors
+      // @ts-expect-error Non-standard property added to flag error as not needing capturing.
+      if (err.expected) return;
+
+      const tags = opts.tags || {};
+      if (tags.audit) {
+        const key = `audit-${tags.audit}-${err.message}`;
+        if (sentryExceptionCache.has(key)) return;
+        sentryExceptionCache.set(key, true);
+      }
+
+      if (tags.gatherer) {
+        const key = `gatherer-${tags.gatherer}-${err.message}`;
+        if (sentryExceptionCache.has(key)) return;
+        sentryExceptionCache.set(key, true);
+      }
+
+      // Sample known errors that occur at a high frequency.
+      const sampledErrorMatch = SAMPLED_ERRORS.find(sample => sample.pattern.test(err.message));
+      if (sampledErrorMatch && sampledErrorMatch.rate <= Math.random()) return;
+
+      // @ts-expect-error - properties added to protocol method LighthouseErrors.
+      if (err.protocolMethod) {
+        // Protocol errors all share same stack trace, so add more to fingerprint
+        // @ts-expect-error - properties added to protocol method LighthouseErrors.
+        opts.fingerprint = ['{{ default }}', err.protocolMethod, err.protocolError];
+
+        opts.tags = opts.tags || {};
+        // @ts-expect-error - properties added to protocol method LighthouseErrors.
+        opts.tags.protocolMethod = err.protocolMethod;
+      }
+
+      Sentry.withScope(scope => {
+        if (opts.level) {
+          // @ts-expect-error - allow any string.
+          scope.setLevel(opts.level);
+        }
+        if (opts.tags) {
+          scope.setTags(opts.tags);
+        }
+        if (opts.extra) {
+          scope.setExtras(opts.extra);
+        }
+        Sentry.captureException(err);
+      });
+    };
+  } catch (e) {
+    log.warn(
+      'sentry',
+      'Could not load Sentry, errors will not be reported.'
+    );
+  }
+}
+
+export const Sentry = sentryDelegate;

package/core/lib/stack-packs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns all packs that match the stacks found in the page.
+ * @param {LH.Artifacts['Stacks']|undefined} pageStacks
+ * @return {LH.RawIcu<Array<LH.Result.StackPack>>}
+ */
+export function getStackPacks(pageStacks: LH.Artifacts['Stacks'] | undefined): LH.RawIcu<Array<LH.Result.StackPack>>;
+/**
+ * Pairs consisting of a stack pack's ID and the set of stacks needed to be
+ * detected in a page to display that pack's advice.
+ * @type {Array<{packId: string, requiredStacks: Array<string>}>}
+ */
+export const stackPacksToInclude: Array<{
+    packId: string;
+    requiredStacks: Array<string>;
+}>;
+//# sourceMappingURL=stack-packs.d.ts.map

package/core/lib/stack-packs.js

@@ -0,0 +1,126 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import log from 'lighthouse-logger';
+import stackPacks from 'lighthouse-stack-packs';
+
+import * as i18n from './i18n/i18n.js';
+
+/**
+ * Pairs consisting of a stack pack's ID and the set of stacks needed to be
+ * detected in a page to display that pack's advice.
+ * @type {Array<{packId: string, requiredStacks: Array<string>}>}
+ */
+const stackPacksToInclude = [
+  {
+    packId: 'wordpress',
+    requiredStacks: ['js:wordpress'],
+  },
+  {
+    packId: 'wp-rocket',
+    requiredStacks: ['js:wp-rocket'],
+  },
+  {
+    packId: 'ezoic',
+    requiredStacks: ['js:ezoic'],
+  },
+  {
+    packId: 'drupal',
+    requiredStacks: ['js:drupal'],
+  },
+  {
+    packId: 'amp',
+    requiredStacks: ['js:amp'],
+  },
+  {
+    packId: 'magento',
+    requiredStacks: ['js:magento'],
+  },
+  {
+    packId: 'octobercms',
+    requiredStacks: ['js:octobercms'],
+  },
+  {
+    packId: 'joomla',
+    requiredStacks: ['js:joomla'],
+  },
+  {
+    packId: 'next.js',
+    requiredStacks: ['js:next'],
+  },
+  {
+    packId: 'nuxt',
+    requiredStacks: ['js:nuxt'],
+  },
+  {
+    packId: 'angular',
+    requiredStacks: ['js:@angular/core'],
+  },
+  {
+    packId: 'react',
+    requiredStacks: ['js:react'],
+  },
+];
+
+/**
+ * Returns all packs that match the stacks found in the page.
+ * @param {LH.Artifacts['Stacks']|undefined} pageStacks
+ * @return {LH.RawIcu<Array<LH.Result.StackPack>>}
+ */
+function getStackPacks(pageStacks) {
+  if (!pageStacks) return [];
+
+  /** @type {LH.RawIcu<Array<LH.Result.StackPack>>} */
+  const packs = [];
+
+  for (const pageStack of pageStacks) {
+    const stackPackToIncl = stackPacksToInclude.find(stackPackToIncl =>
+      stackPackToIncl.requiredStacks.includes(`${pageStack.detector}:${pageStack.id}`));
+    if (!stackPackToIncl) {
+      continue;
+    }
+
+    // Grab the full pack definition.
+    const matchedPack = stackPacks.find(pack => pack.id === stackPackToIncl.packId);
+    if (!matchedPack) {
+      log.warn('StackPacks',
+        `'${stackPackToIncl.packId}' stack pack was matched but is not found in stack-packs lib`);
+      continue;
+    }
+
+    // Create i18n handler to get translated strings.
+    const str_ = i18n.createIcuMessageFn(
+      `node_modules/lighthouse-stack-packs/packs/${matchedPack.id}.js`,
+      matchedPack.UIStrings
+    );
+
+    /** @type {Record<string, LH.IcuMessage>} */
+    const descriptions = {};
+    /** @type {Record<string, string>} */
+    const UIStrings = matchedPack.UIStrings;
+
+    // Convert all strings into the correct translation.
+    for (const key in UIStrings) {
+      if (UIStrings[key]) {
+        descriptions[key] = str_(UIStrings[key]);
+      }
+    }
+
+    packs.push({
+      id: matchedPack.id,
+      title: matchedPack.title,
+      iconDataURL: matchedPack.icon,
+      descriptions,
+    });
+  }
+
+  return packs;
+}
+
+export {
+  getStackPacks,
+  stackPacksToInclude,
+};

package/core/lib/statistics.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Interpolates the y value at a point x on the line defined by (x0, y0) and (x1, y1)
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x
+ * @return {number}
+ */
+export function linearInterpolation(x0: number, y0: number, x1: number, y1: number, x: number): number;
+/**
+ * Returns the score (1 - percentile) of `value` in a log-normal distribution
+ * specified by the `median` value, at which the score will be 0.5, and a 10th
+ * percentile value, at which the score will be 0.9. The score represents the
+ * amount of the distribution greater than `value`. All values should be in the
+ * same units (e.g. milliseconds). See
+ *   https://www.desmos.com/calculator/o98tbeyt1t
+ * for an interactive view of the relationship between these parameters and the
+ * typical parameterization (location and shape) of the log-normal distribution.
+ * @param {{median: number, p10: number}} parameters
+ * @param {number} value
+ * @return {number}
+ */
+export function getLogNormalScore({ median, p10 }: {
+    median: number;
+    p10: number;
+}, value: number): number;
+//# sourceMappingURL=statistics.d.ts.map

package/core/lib/statistics.js

@@ -0,0 +1,103 @@
+/**
+ * @license Copyright 2017 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+// The exact double values for the max and min scores possible in each range.
+const MIN_PASSING_SCORE = 0.90000000000000002220446049250313080847263336181640625;
+const MAX_AVERAGE_SCORE = 0.899999999999999911182158029987476766109466552734375;
+const MIN_AVERAGE_SCORE = 0.5;
+const MAX_FAILING_SCORE = 0.499999999999999944488848768742172978818416595458984375;
+
+/**
+ * Approximates the Gauss error function, the probability that a random variable
+ * from the standard normal distribution lies within [-x, x]. Moved from
+ * traceviewer.b.math.erf, based on Abramowitz and Stegun, formula 7.1.26.
+ * @param {number} x
+ * @return {number}
+ */
+function erf(x) {
+  // erf(-x) = -erf(x);
+  const sign = Math.sign(x);
+  x = Math.abs(x);
+
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const t = 1 / (1 + p * x);
+  const y = t * (a1 + t * (a2 + t * (a3 + t * (a4 + t * a5))));
+  return sign * (1 - y * Math.exp(-x * x));
+}
+
+/**
+ * Returns the score (1 - percentile) of `value` in a log-normal distribution
+ * specified by the `median` value, at which the score will be 0.5, and a 10th
+ * percentile value, at which the score will be 0.9. The score represents the
+ * amount of the distribution greater than `value`. All values should be in the
+ * same units (e.g. milliseconds). See
+ *   https://www.desmos.com/calculator/o98tbeyt1t
+ * for an interactive view of the relationship between these parameters and the
+ * typical parameterization (location and shape) of the log-normal distribution.
+ * @param {{median: number, p10: number}} parameters
+ * @param {number} value
+ * @return {number}
+ */
+function getLogNormalScore({median, p10}, value) {
+  // Required for the log-normal distribution.
+  if (median <= 0) throw new Error('median must be greater than zero');
+  if (p10 <= 0) throw new Error('p10 must be greater than zero');
+  // Not strictly required, but if p10 > median, it flips around and becomes the p90 point.
+  if (p10 >= median) throw new Error('p10 must be less than the median');
+
+  // Non-positive values aren't in the distribution, so always 1.
+  if (value <= 0) return 1;
+
+  // Closest double to `erfc-1(1/5)`.
+  const INVERSE_ERFC_ONE_FIFTH = 0.9061938024368232;
+
+  // Shape (σ) is `|log(p10/median) / (sqrt(2)*erfc^-1(1/5))|` and
+  // standardizedX is `1/2 erfc(log(value/median) / (sqrt(2)*σ))`, so simplify a bit.
+  const xRatio = Math.max(Number.MIN_VALUE, value / median); // value and median are > 0, so is ratio.
+  const xLogRatio = Math.log(xRatio);
+  const p10Ratio = Math.max(Number.MIN_VALUE, p10 / median); // p10 and median are > 0, so is ratio.
+  const p10LogRatio = -Math.log(p10Ratio); // negate to keep σ positive.
+  const standardizedX = xLogRatio * INVERSE_ERFC_ONE_FIFTH / p10LogRatio;
+  const complementaryPercentile = (1 - erf(standardizedX)) / 2;
+
+  // Clamp to avoid floating-point out-of-bounds issues and keep score in expected range.
+  let score;
+  if (value <= p10) {
+    // Passing. Clamp to [0.9, 1].
+    score = Math.max(MIN_PASSING_SCORE, Math.min(1, complementaryPercentile));
+  } else if (value <= median) {
+    // Average. Clamp to [0.5, 0.9).
+    score = Math.max(MIN_AVERAGE_SCORE, Math.min(MAX_AVERAGE_SCORE, complementaryPercentile));
+  } else {
+    // Failing. Clamp to [0, 0.5).
+    score = Math.max(0, Math.min(MAX_FAILING_SCORE, complementaryPercentile));
+  }
+  return score;
+}
+
+/**
+ * Interpolates the y value at a point x on the line defined by (x0, y0) and (x1, y1)
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x
+ * @return {number}
+ */
+function linearInterpolation(x0, y0, x1, y1, x) {
+  const slope = (y1 - y0) / (x1 - x0);
+  return y0 + (x - x0) * slope;
+}
+
+export {
+  linearInterpolation,
+  getLogNormalScore,
+};

package/core/lib/tappable-rects.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Merge client rects together and remove small ones. This may result in a larger overall
+ * size than that of the individual client rects.
+ * We use this to simulate a finger tap on those targets later on.
+ * @param {LH.Artifacts.Rect[]} clientRects
+ */
+export function getTappableRectsFromClientRects(clientRects: LH.Artifacts.Rect[]): import("../../types/lhr/audit-details.js").default.Rect[];
+//# sourceMappingURL=tappable-rects.d.ts.map

package/core/lib/tappable-rects.js

@@ -0,0 +1,98 @@
+/**
+ * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import * as RectHelpers from './rect-helpers.js';
+
+/**
+ * Merge client rects together and remove small ones. This may result in a larger overall
+ * size than that of the individual client rects.
+ * We use this to simulate a finger tap on those targets later on.
+ * @param {LH.Artifacts.Rect[]} clientRects
+ */
+function getTappableRectsFromClientRects(clientRects) {
+  // 1x1px rect shouldn't be reason to treat the rect as something the user should tap on.
+  // Often they're made invisble in some obscure way anyway, and only exist for e.g. accessibiliity.
+  clientRects = RectHelpers.filterOutTinyRects(clientRects);
+  clientRects = RectHelpers.filterOutRectsContainedByOthers(clientRects);
+  clientRects = mergeTouchingClientRects(clientRects);
+  return clientRects;
+}
+
+/**
+ * Sometimes a child will reach out of the parent by a few px, but still
+ * clearly belong to the same tap area in the users's eyes.
+ * We can be quite generous here, since merging too much tends to cause false
+ * passes instead of false failures (because there are more fingers)
+ * @param {number} a
+ * @param {number} b
+ */
+function almostEqual(a, b) {
+  return Math.abs(a - b) <= 10;
+}
+
+/**
+ * Merge touching rects based on what appears as one tappable area to the user.
+ * @param {LH.Artifacts.Rect[]} clientRects
+ * @return {LH.Artifacts.Rect[]}
+ */
+function mergeTouchingClientRects(clientRects) {
+  for (let i = 0; i < clientRects.length; i++) {
+    for (let j = i + 1; j < clientRects.length; j++) {
+      const crA = clientRects[i];
+      const crB = clientRects[j];
+
+      /**
+       * We try to determine whether the rects appear as a single tappable
+       * area to the user, so that they'd tap in the middle of the merged rect.
+       * Examples of what we want to merge:
+       *
+       * AAABBB
+       *
+       * AAA
+       * AAA
+       * BBBBB
+       */
+      const rectsLineUpHorizontally =
+        almostEqual(crA.top, crB.top) || almostEqual(crA.bottom, crB.bottom);
+      const rectsLineUpVertically =
+        almostEqual(crA.left, crB.left) || almostEqual(crA.right, crB.right);
+      const canMerge =
+        RectHelpers.rectsTouchOrOverlap(crA, crB) &&
+        (rectsLineUpHorizontally || rectsLineUpVertically);
+
+      if (canMerge) {
+        const replacementClientRect = RectHelpers.getBoundingRect([crA, crB]);
+        const mergedRectCenter = RectHelpers.getRectCenterPoint(replacementClientRect);
+
+        if (
+          !(
+            RectHelpers.rectContainsPoint(crA, mergedRectCenter) ||
+            RectHelpers.rectContainsPoint(crB, mergedRectCenter)
+          )
+        ) {
+          // Don't merge because the new shape is too different from the
+          // merged rects, and tapping in the middle wouldn't actually hit
+          // either rect
+          continue;
+        }
+
+        // Replace client rects with merged version
+        clientRects = clientRects.filter(cr => cr !== crA && cr !== crB);
+        clientRects.push(replacementClientRect);
+
+        // Start over so we don't have to handle complexity introduced by array mutation.
+        // Client rect ararys rarely contain more than 5 rects, so starting again doesn't cause perf issues.
+        return mergeTouchingClientRects(clientRects);
+      }
+    }
+  }
+
+  return clientRects;
+}
+
+export {
+  getTappableRectsFromClientRects,
+};

package/core/lib/third-party-web.d.ts

@@ -0,0 +1,32 @@
+declare namespace _default {
+    export { getEntity };
+    export { getProduct };
+    export { isThirdParty };
+    export { isFirstParty };
+}
+export default _default;
+export type ThirdPartyEntity = import("third-party-web").IEntity;
+export type ThirdPartyProduct = import("third-party-web").IProduct;
+/** @typedef {import("third-party-web").IEntity} ThirdPartyEntity */
+/** @typedef {import("third-party-web").IProduct} ThirdPartyProduct */
+/**
+ * @param {string} url
+ * @return {ThirdPartyEntity|undefined}
+ */
+declare function getEntity(url: string): ThirdPartyEntity | undefined;
+/**
+ * @param {string} url
+ * @return {ThirdPartyProduct|undefined}
+ */
+declare function getProduct(url: string): ThirdPartyProduct | undefined;
+/**
+ * @param {string} url
+ * @param {ThirdPartyEntity | undefined} mainDocumentEntity
+ */
+declare function isThirdParty(url: string, mainDocumentEntity: ThirdPartyEntity | undefined): boolean;
+/**
+ * @param {string} url
+ * @param {ThirdPartyEntity | undefined} mainDocumentEntity
+ */
+declare function isFirstParty(url: string, mainDocumentEntity: ThirdPartyEntity | undefined): boolean;
+//# sourceMappingURL=third-party-web.d.ts.map

package/core/lib/third-party-web.js

@@ -0,0 +1,52 @@
+/**
+ * @license Copyright 2020 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+import thirdPartyWeb from 'third-party-web/nostats-subset.js';
+
+/** @typedef {import("third-party-web").IEntity} ThirdPartyEntity */
+/** @typedef {import("third-party-web").IProduct} ThirdPartyProduct */
+
+/**
+ * @param {string} url
+ * @return {ThirdPartyEntity|undefined}
+ */
+function getEntity(url) {
+  return thirdPartyWeb.getEntity(url);
+}
+
+/**
+ * @param {string} url
+ * @return {ThirdPartyProduct|undefined}
+ */
+function getProduct(url) {
+  return thirdPartyWeb.getProduct(url);
+}
+
+/**
+ * @param {string} url
+ * @param {ThirdPartyEntity | undefined} mainDocumentEntity
+ */
+function isThirdParty(url, mainDocumentEntity) {
+  const entity = getEntity(url);
+  if (!entity) return false;
+  if (entity === mainDocumentEntity) return false;
+  return true;
+}
+
+/**
+ * @param {string} url
+ * @param {ThirdPartyEntity | undefined} mainDocumentEntity
+ */
+function isFirstParty(url, mainDocumentEntity) {
+  return !isThirdParty(url, mainDocumentEntity);
+}
+
+export default {
+  getEntity,
+  getProduct,
+  isThirdParty,
+  isFirstParty,
+};

package/core/lib/timing-trace-saver.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license Copyright 2018 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/**
+ * Generates a chromium trace file from user timing measures
+ * `threadId` can be provided to separate a series of trace events into another thread, useful
+ * if timings do not share the same timeOrigin, but should both be "left-aligned".
+ * Adapted from https://github.com/tdresser/performance-observer-tracing
+ * @param {LH.Artifacts.MeasureEntry[]} entries user timing entries
+ * @param {number=} threadId
+ */
+export function generateTraceEvents(entries: LH.Artifacts.MeasureEntry[], threadId?: number | undefined): import("..").TraceEvent[];
+/**
+ * Writes a trace file to disk
+ * @param {LH.Result} lhr
+ * @return {string}
+ */
+export function createTraceString(lhr: LH.Result): string;
+//# sourceMappingURL=timing-trace-saver.d.ts.map