lighthouse 9.6.7 → 10.0.0-dev.20230209

package/core/audits/multi-check-audit.d.ts

@@ -0,0 +1,28 @@
+export default MultiCheckAudit;
+declare class MultiCheckAudit extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+    /**
+     * @param {{failures: Array<string>, manifestValues?: LH.Artifacts.ManifestValues}} result
+     * @return {LH.Audit.Product}
+     */
+    static createAuditProduct(result: {
+        failures: Array<string>;
+        manifestValues?: LH.Artifacts.ManifestValues;
+    }): LH.Audit.Product;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<{failures: Array<string>, manifestValues?: LH.Artifacts.ManifestValues}>}
+     */
+    static audit_(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
+        failures: Array<string>;
+        manifestValues?: LH.Artifacts.ManifestValues;
+    }>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=multi-check-audit.d.ts.map

package/core/audits/multi-check-audit.js

@@ -0,0 +1,82 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Base class for boolean audits that can have multiple reasons for failure
+ */
+
+import {Audit} from './audit.js';
+
+class MultiCheckAudit extends Audit {
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const multiProduct = await this.audit_(artifacts, context);
+    return this.createAuditProduct(multiProduct);
+  }
+
+  /**
+   * @param {{failures: Array<string>, manifestValues?: LH.Artifacts.ManifestValues}} result
+   * @return {LH.Audit.Product}
+   */
+  static createAuditProduct(result) {
+    /** @type {LH.Audit.MultiCheckAuditDetails} */
+    const detailsItem = {
+      ...result,
+      ...result.manifestValues,
+      manifestValues: undefined,
+      allChecks: undefined,
+    };
+
+    if (result.manifestValues?.allChecks) {
+      result.manifestValues.allChecks.forEach(check => {
+        detailsItem[check.id] = check.passing;
+      });
+    }
+
+    // Include the detailed pass/fail checklist as a diagnostic.
+    /** @type {LH.Audit.Details.DebugData} */
+    const details = {
+      type: 'debugdata',
+      // TODO: Consider not nesting detailsItem under `items`.
+      items: [detailsItem],
+    };
+
+    // If we fail, share the failures
+    if (result.failures.length > 0) {
+      return {
+        score: 0,
+        // TODO(#11495): make this i18n-able.
+        explanation: `Failures: ${result.failures.join(',\n')}.`,
+        details,
+      };
+    }
+
+    // Otherwise, we pass
+    return {
+      score: 1,
+      details,
+    };
+  }
+
+  /* eslint-disable no-unused-vars */
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<{failures: Array<string>, manifestValues?: LH.Artifacts.ManifestValues}>}
+   */
+  static audit_(artifacts, context) {
+    throw new Error('audit_ unimplemented');
+  }
+
+  /* eslint-enable no-unused-vars */
+}
+
+export default MultiCheckAudit;

package/core/audits/network-requests.d.ts

@@ -0,0 +1,11 @@
+export default NetworkRequests;
+declare class NetworkRequests extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=network-requests.d.ts.map

package/core/audits/network-requests.js

@@ -0,0 +1,129 @@
+/**
+ * @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 {Audit} from './audit.js';
+import UrlUtils from '../lib/url-utils.js';
+import {NetworkRecords} from '../computed/network-records.js';
+import {MainResource} from '../computed/main-resource.js';
+
+class NetworkRequests extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'network-requests',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: 'Network Requests',
+      description: 'Lists the network requests that were made during page load.',
+      requiredArtifacts: ['devtoolsLogs', 'URL', 'GatherContext'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const records = await NetworkRecords.request(devtoolsLog, context);
+    const earliestRendererStartTime = records.reduce(
+      (min, record) => Math.min(min, record.rendererStartTime),
+      Infinity
+    );
+
+    // Optional mainFrameId check because the main resource is only available for
+    // navigations. TODO: https://github.com/GoogleChrome/lighthouse/issues/14157
+    // for the general solution to this.
+    /** @type {string|undefined} */
+    let mainFrameId;
+    if (artifacts.GatherContext.gatherMode === 'navigation') {
+      const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+      mainFrameId = mainResource.frameId;
+    }
+
+    /** @param {number} time */
+    const normalizeTime = time => time < earliestRendererStartTime || !Number.isFinite(time) ?
+      undefined : (time - earliestRendererStartTime);
+
+    const results = records.map(record => {
+      const endTimeDeltaMs = record.lrStatistics?.endTimeDeltaMs;
+      const TCPMs = record.lrStatistics?.TCPMs;
+      const requestMs = record.lrStatistics?.requestMs;
+      const responseMs = record.lrStatistics?.responseMs;
+      // Default these to undefined so omitted from JSON in the negative case.
+      const isLinkPreload = record.isLinkPreload || undefined;
+      const experimentalFromMainFrame = mainFrameId ?
+        ((record.frameId === mainFrameId) || undefined) :
+        undefined;
+
+      return {
+        url: UrlUtils.elideDataURI(record.url),
+        protocol: record.protocol,
+        rendererStartTime: normalizeTime(record.rendererStartTime),
+        networkRequestTime: normalizeTime(record.networkRequestTime),
+        networkEndTime: normalizeTime(record.networkEndTime),
+        finished: record.finished,
+        transferSize: record.transferSize,
+        resourceSize: record.resourceSize,
+        statusCode: record.statusCode,
+        mimeType: record.mimeType,
+        resourceType: record.resourceType,
+        priority: record.priority,
+        isLinkPreload,
+        experimentalFromMainFrame,
+        lrEndTimeDeltaMs: endTimeDeltaMs, // Only exists on Lightrider runs
+        lrTCPMs: TCPMs, // Only exists on Lightrider runs
+        lrRequestMs: requestMs, // Only exists on Lightrider runs
+        lrResponseMs: responseMs, // Only exists on Lightrider runs
+      };
+    });
+
+    // NOTE(i18n): this audit is only for debug info in the LHR and does not appear in the report.
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'url', valueType: 'url', label: 'URL'},
+      {key: 'protocol', valueType: 'text', label: 'Protocol'},
+      {key: 'networkRequestTime', valueType: 'ms', granularity: 1, label: 'Network Request Time'},
+      {key: 'networkEndTime', valueType: 'ms', granularity: 1, label: 'Network End Time'},
+      {
+        key: 'transferSize',
+        valueType: 'bytes',
+        displayUnit: 'kb',
+        granularity: 1,
+        label: 'Transfer Size',
+      },
+      {
+        key: 'resourceSize',
+        valueType: 'bytes',
+        displayUnit: 'kb',
+        granularity: 1,
+        label: 'Resource Size',
+      },
+      {key: 'statusCode', valueType: 'text', label: 'Status Code'},
+      {key: 'mimeType', valueType: 'text', label: 'MIME Type'},
+      {key: 'resourceType', valueType: 'text', label: 'Resource Type'},
+    ];
+
+    const tableDetails = Audit.makeTableDetails(headings, results);
+
+    // Include starting timestamp to allow syncing requests with navStart/metric timestamps.
+    const networkStartTimeTs = Number.isFinite(earliestRendererStartTime) ?
+        earliestRendererStartTime * 1000 : undefined;
+    tableDetails.debugData = {
+      type: 'debugdata',
+      networkStartTimeTs,
+    };
+
+    return {
+      score: 1,
+      details: tableDetails,
+    };
+  }
+}
+
+export default NetworkRequests;

package/core/audits/network-rtt.d.ts

@@ -0,0 +1,15 @@
+export default NetworkRTT;
+declare class NetworkRTT extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=network-rtt.d.ts.map

package/core/audits/network-rtt.js

@@ -0,0 +1,89 @@
+/**
+ * @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 {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {NetworkRecords} from '../computed/network-records.js';
+import {NetworkAnalysis} from '../computed/network-analysis.js';
+
+const UIStrings = {
+  /** Descriptive title of a Lighthouse audit that tells the user the round trip times to each origin the page connected to. This is displayed in a list of audit titles that Lighthouse generates. */
+  title: 'Network Round Trip Times',
+  /** Description of a Lighthouse audit that tells the user that a high network round trip time (RTT) can effect their website's performance because the server is physically far away from them thus making the RTT high. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Network round trip times (RTT) have a large impact on performance. ' +
+    'If the RTT to an origin is high, it\'s an indication that servers closer to the user could ' +
+    'improve performance. [Learn more about the Round Trip Time](https://hpbn.co/primer-on-latency-and-bandwidth/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class NetworkRTT extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'network-rtt',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['devtoolsLogs'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const records = await NetworkRecords.request(devtoolsLog, context);
+    if (!records.length) {
+      return {
+        score: 1,
+        notApplicable: true,
+      };
+    }
+
+    const analysis = await NetworkAnalysis.request(devtoolsLog, context);
+
+    /** @type {number} */
+    let maxRtt = 0;
+    const baseRtt = analysis.rtt;
+    /** @type {Array<{origin: string, rtt: number}>} */
+    const results = [];
+    for (const [origin, additionalRtt] of analysis.additionalRttByOrigin.entries()) {
+      // Ignore entries that don't look like real origins, like the __SUMMARY__ entry.
+      if (!origin.startsWith('http')) continue;
+
+      const rtt = additionalRtt + baseRtt;
+      results.push({origin, rtt});
+      maxRtt = Number.isFinite(rtt) ? Math.max(rtt, maxRtt) : maxRtt;
+    }
+
+    results.sort((a, b) => b.rtt - a.rtt);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'origin', valueType: 'text', label: str_(i18n.UIStrings.columnURL)},
+      {key: 'rtt', valueType: 'ms', granularity: 1, label: str_(i18n.UIStrings.columnTimeSpent)},
+    ];
+
+    const tableDetails = Audit.makeTableDetails(headings, results);
+
+    return {
+      score: 1,
+      numericValue: maxRtt,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: maxRtt}),
+      details: tableDetails,
+    };
+  }
+}
+
+export default NetworkRTT;
+export {UIStrings};

package/core/audits/network-server-latency.d.ts

@@ -0,0 +1,15 @@
+export default NetworkServerLatency;
+declare class NetworkServerLatency extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=network-server-latency.d.ts.map

package/core/audits/network-server-latency.js

@@ -0,0 +1,88 @@
+/**
+ * @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 {Audit} from './audit.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {NetworkRecords} from '../computed/network-records.js';
+import {NetworkAnalysis} from '../computed/network-analysis.js';
+
+const UIStrings = {
+  /** Descriptive title of a Lighthouse audit that tells the user the server latencies observed from each origin the page connected to. This is displayed in a list of audit titles that Lighthouse generates. */
+  title: 'Server Backend Latencies',
+  /** Description of a Lighthouse audit that tells the user that server latency can effect their website's performance negatively. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Server latencies can impact web performance. ' +
+    'If the server latency of an origin is high, it\'s an indication the server is overloaded ' +
+    'or has poor backend performance. [Learn more about server response time](https://hpbn.co/primer-on-web-performance/#analyzing-the-resource-waterfall).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class NetworkServerLatency extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'network-server-latency',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['devtoolsLogs'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const records = await NetworkRecords.request(devtoolsLog, context);
+    if (!records.length) {
+      return {
+        score: 1,
+        notApplicable: true,
+      };
+    }
+
+    const analysis = await NetworkAnalysis.request(devtoolsLog, context);
+
+    /** @type {number} */
+    let maxLatency = 0;
+    /** @type {Array<{origin: string, serverResponseTime: number}>} */
+    const results = [];
+    for (const [origin, serverResponseTime] of analysis.serverResponseTimeByOrigin.entries()) {
+      // Ignore entries that don't look like real origins, like the __SUMMARY__ entry.
+      if (!origin.startsWith('http')) continue;
+
+      maxLatency = Math.max(serverResponseTime, maxLatency);
+      results.push({origin, serverResponseTime});
+    }
+
+    results.sort((a, b) => b.serverResponseTime - a.serverResponseTime);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'origin', valueType: 'text', label: str_(i18n.UIStrings.columnURL)},
+      {key: 'serverResponseTime', valueType: 'ms', granularity: 1,
+        label: str_(i18n.UIStrings.columnTimeSpent)},
+    ];
+
+    const tableDetails = Audit.makeTableDetails(headings, results);
+
+    return {
+      score: Math.max(1 - (maxLatency / 500), 0),
+      numericValue: maxLatency,
+      numericUnit: 'millisecond',
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: maxLatency}),
+      details: tableDetails,
+    };
+  }
+}
+
+export default NetworkServerLatency;
+export {UIStrings};

package/core/audits/no-unload-listeners.d.ts

@@ -0,0 +1,16 @@
+export default NoUnloadListeners;
+declare class NoUnloadListeners extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=no-unload-listeners.d.ts.map

package/core/audits/no-unload-listeners.js

@@ -0,0 +1,86 @@
+/**
+ * @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 {Audit} from './audit.js';
+import {JSBundles} from '../computed/js-bundles.js';
+import * as i18n from './../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Descriptive title of a Lighthouse audit that checks if a web page has 'unload' event listeners and finds none. */
+  title: 'Avoids `unload` event listeners',
+  /** Descriptive title of a Lighthouse audit that checks if a web page has 'unload' event listeners and finds that it is using them. */
+  failureTitle: 'Registers an `unload` listener',
+  /** Description of a Lighthouse audit that tells the user why pages should not use the 'unload' event. This is displayed after a user expands the section to see more. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'The `unload` event does not fire reliably and listening for it can prevent browser optimizations like the Back-Forward Cache. Use `pagehide` or `visibilitychange` events instead. [Learn more about unload event listeners](https://web.dev/bfcache/#never-use-the-unload-event)',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class NoUnloadListeners extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'no-unload-listeners',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['GlobalListeners', 'SourceMaps', 'Scripts'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const unloadListeners = artifacts.GlobalListeners.filter(l => l.type === 'unload');
+    if (!unloadListeners.length) {
+      return {
+        score: 1,
+      };
+    }
+
+    const bundles = await JSBundles.request(artifacts, context);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'source', valueType: 'source-location', label: str_(i18n.UIStrings.columnSource)},
+    ];
+
+    /** @type {Array<{source: LH.Audit.Details.ItemValue}>} */
+    const tableItems = unloadListeners.map(listener => {
+      const {lineNumber, columnNumber} = listener;
+      const script = artifacts.Scripts.find(s => s.scriptId === listener.scriptId);
+
+      // If we can't find a url, still show something so the user can manually
+      // look for where an `unload` handler is being created.
+      if (!script) {
+        return {
+          source: {
+            type: 'url',
+            value: `(unknown):${lineNumber}:${columnNumber}`,
+          },
+        };
+      }
+
+      const bundle = bundles.find(bundle => bundle.script.scriptId === script.scriptId);
+      return {
+        source: Audit.makeSourceLocation(script.url, lineNumber, columnNumber, bundle),
+      };
+    });
+
+    return {
+      score: 0,
+      details: Audit.makeTableDetails(headings, tableItems),
+    };
+  }
+}
+
+export default NoUnloadListeners;
+export {UIStrings};

package/core/audits/non-composited-animations.d.ts

@@ -0,0 +1,21 @@
+export default NonCompositedAnimations;
+declare class NonCompositedAnimations extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+    const displayValue: string;
+    const unsupportedCSSProperty: string;
+    const transformDependsBoxSize: string;
+    const filterMayMovePixels: string;
+    const nonReplaceCompositeMode: string;
+    const incompatibleAnimations: string;
+    const unsupportedTimingParameters: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=non-composited-animations.d.ts.map