fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/lighthouse/core/audits/accessibility/accesskeys.d.ts

@@ -0,0 +1,10 @@
+export default Accesskeys;
+declare class Accesskeys extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=accesskeys.d.ts.map

node_modules/lighthouse/core/audits/accessibility/accesskeys.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures accesskey values are unique.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the accesskey HTML attribute values are unique across all elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[accesskey]` values are unique',
+  /** Title of an accesibility audit that evaluates if the ARIA HTML attributes are misaligned with the aria-role HTML attribute specificed on the element, such mismatches are invalid. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[accesskey]` values are not unique',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Access keys let users quickly focus a part of the page. For proper ' +
+      'navigation, each access key must be unique. ' +
+      '[Learn more about access keys](https://dequeuniversity.com/rules/axe/4.7/accesskeys).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class Accesskeys extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'accesskeys',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default Accesskeys;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-allowed-attr.d.ts

@@ -0,0 +1,10 @@
+export default ARIAAllowedAttr;
+declare class ARIAAllowedAttr extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-allowed-attr.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-allowed-attr.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures ARIA attributes are allowed for an element's role.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the ARIA HTML attributes are misaligned with the aria-role HTML attribute specificed on the element, such mismatches are invalid. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[aria-*]` attributes match their roles',
+  /** Title of an accesibility audit that evaluates if the ARIA HTML attributes are misaligned with the aria-role HTML attribute specificed on the element, such mismatches are invalid. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[aria-*]` attributes do not match their roles',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Each ARIA `role` supports a specific subset of `aria-*` attributes. ' +
+      'Mismatching these invalidates the `aria-*` attributes. [Learn ' +
+      'how to match ARIA attributes to their roles](https://dequeuniversity.com/rules/axe/4.7/aria-allowed-attr).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ARIAAllowedAttr extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-allowed-attr',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ARIAAllowedAttr;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-command-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaCommandName;
+declare class AriaCommandName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-command-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-command-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every ARIA button, link and menuitem element has an accessible name
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if important HTML elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`button`, `link`, and `menuitem` elements have accessible names',
+  /** Title of an accessibility audit that evaluates if important HTML elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`button`, `link`, and `menuitem` elements do not have accessible names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for HTML elements. 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: 'When an element doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to make command elements more accessible](https://dequeuniversity.com/rules/axe/4.7/aria-command-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaCommandName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-command-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaCommandName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-dialog-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaDialogName;
+declare class AriaDialogName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-dialog-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-dialog-name.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2023 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 Ensures every ARIA dialog element has a discernable, accessible name.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if ARIA dialog elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Elements with `role="dialog"` or `role="alertdialog"` have accessible names.',
+  /** Title of an accessibility audit that evaluates if ARIA dialog elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Elements with `role="dialog"` or `role="alertdialog"` do not have accessible ' +
+      'names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for ARIA dialog elements. 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: 'ARIA dialog elements without accessible names may prevent screen readers users ' +
+      'from discerning the purpose of these elements. ' +
+      '[Learn how to make ARIA dialog elements more accessible](https://dequeuniversity.com/rules/axe/4.7/aria-dialog-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaDialogName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-dialog-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaDialogName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-hidden-body.d.ts

@@ -0,0 +1,10 @@
+export default AriaHiddenBody;
+declare class AriaHiddenBody extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-hidden-body.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-hidden-body.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures `aria-hidden='true'` is not present on the document body.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if the html <body> element does not have an aria-hidden attribute set on it. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[aria-hidden="true"]` is not present on the document `<body>`',
+  /** Title of an accesibility audit that checks if the html <body> element does not have an aria-hidden attribute set on it. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[aria-hidden="true"]` is present on the document `<body>`',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Assistive technologies, like screen readers, work inconsistently when `aria-hidden="true"` is set on the document `<body>`. [Learn how `aria-hidden` affects the document body](https://dequeuniversity.com/rules/axe/4.7/aria-hidden-body).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaHiddenBody extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-hidden-body',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaHiddenBody;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-hidden-focus.d.ts

@@ -0,0 +1,10 @@
+export default AriaHiddenFocus;
+declare class AriaHiddenFocus extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-hidden-focus.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-hidden-focus.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures `aria-hidden` elements do not contain focusable elements.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if all elements that have an aria-hidden attribute do not contain focusable descendent elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[aria-hidden="true"]` elements do not contain focusable descendents',
+  /** Title of an accesibility audit that checks if all elements that have an aria-hidden attribute do not contain focusable descendent elements. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[aria-hidden="true"]` elements contain focusable descendents',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Focusable descendents within an `[aria-hidden="true"]` element prevent those interactive elements from being available to users of assistive technologies like screen readers. [Learn how `aria-hidden` affects focusable elements](https://dequeuniversity.com/rules/axe/4.7/aria-hidden-focus).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaHiddenFocus extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-hidden-focus',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaHiddenFocus;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-input-field-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaInputFieldName;
+declare class AriaInputFieldName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-input-field-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-input-field-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures all ARIA input fields have an accessible name.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks that all ARIA input fields have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA input fields have accessible names',
+  /** Title of an accesibility audit that checks that all ARIA input fields have an accessible name. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA input fields do not have accessible names',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'When an input field doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about input field labels](https://dequeuniversity.com/rules/axe/4.7/aria-input-field-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaInputFieldName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-input-field-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaInputFieldName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-meter-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaMeterName;
+declare class AriaMeterName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-meter-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-meter-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every ARIA meter element has an accessible name
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if meter HTML elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA `meter` elements have accessible names',
+  /** Title of an accessibility audit that evaluates if meter HTML elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA `meter` elements do not have accessible names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for HTML 'meter' elements. This is displayed after a user expands the section to see more. No character length limits. 'Learn how...' becomes link text to additional documentation. */
+  description: 'When a meter element doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to name `meter` elements](https://dequeuniversity.com/rules/axe/4.7/aria-meter-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaMeterName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-meter-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaMeterName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-progressbar-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaProgressbarName;
+declare class AriaProgressbarName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-progressbar-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-progressbar-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every ARIA progressbar element has an accessible name
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if progressbar HTML elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA `progressbar` elements have accessible names',
+  /** Title of an accessibility audit that evaluates if progressbar HTML elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA `progressbar` elements do not have accessible names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'When a `progressbar` element doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to label `progressbar` elements](https://dequeuniversity.com/rules/axe/4.7/aria-progressbar-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaProgressbarName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-progressbar-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaProgressbarName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-required-attr.d.ts

@@ -0,0 +1,10 @@
+export default ARIARequiredAttr;
+declare class ARIARequiredAttr extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-required-attr.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-required-attr.js

@@ -0,0 +1,43 @@
+/**
+ * @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 Ensures elements with ARIA roles have all required ARIA attributes.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all elements with the aria-role attribute have the other corresponding ARIA attributes set as well. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[role]`s have all required `[aria-*]` attributes',
+  /** Title of an accesibility audit that evaluates if all elements with the aria-role attribute have the other corresponding ARIA attributes set as well. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[role]`s do not have all required `[aria-*]` attributes',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Some ARIA roles have required attributes that describe the state ' +
+      'of the element to screen readers. [Learn more about roles and required attributes](https://dequeuniversity.com/rules/axe/4.7/aria-required-attr).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ARIARequiredAttr extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-required-attr',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ARIARequiredAttr;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-required-children.d.ts

@@ -0,0 +1,10 @@
+export default AriaRequiredChildren;
+declare class AriaRequiredChildren extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-required-children.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-required-children.js

@@ -0,0 +1,47 @@
+/**
+ * @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 Ensures elements with an ARIA role contain any required children.
+ * e.g. A parent node with role="list" should contain children with role="listitem".
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the elements with an aria-role that require child elements have the required children. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Elements with an ARIA `[role]` that require children to contain a specific ' +
+  '`[role]` have all required children.',
+  /** Title of an accesibility audit that evaluates if the elements with an aria-role that require child elements have the required children. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Elements with an ARIA `[role]` that require children to contain a specific ' +
+  '`[role]` are missing some or all of those required children.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Some ARIA parent roles must contain specific child roles to perform ' +
+      'their intended accessibility functions. ' +
+      '[Learn more about roles and required children elements](https://dequeuniversity.com/rules/axe/4.7/aria-required-children).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaRequiredChildren extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-required-children',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaRequiredChildren;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-required-parent.d.ts

@@ -0,0 +1,10 @@
+export default AriaRequiredParent;
+declare class AriaRequiredParent extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-required-parent.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-required-parent.js

@@ -0,0 +1,45 @@
+/**
+ * @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 Ensures elements with an ARIA role are contained by their required parents.
+ * e.g. A child node with role="listitem" should be contained by a parent with role="list".
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates valid aria-role usage. Some ARIA roles require that elements must be a child of specific parent element. This audit checks that when those roles are used, the element with the role is in fact a child of the required parent. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[role]`s are contained by their required parent element',
+  /** Title of an accesibility audit that evaluates valid aria-role usage. Some ARIA roles require that elements must be a child of specific parent element. This audit checks that when those roles are used, the element with the role is in fact a child of the required parent. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[role]`s are not contained by their required parent element',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Some ARIA child roles must be contained by specific parent roles to ' +
+      'properly perform their intended accessibility functions. ' +
+      '[Learn more about ARIA roles and required parent element](https://dequeuniversity.com/rules/axe/4.7/aria-required-parent).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaRequiredParent extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-required-parent',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaRequiredParent;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-roles.d.ts

@@ -0,0 +1,10 @@
+export default AriaRoles;
+declare class AriaRoles extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-roles.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-roles.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures all elements with a role attribute use a valid value.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all elements have valid aria-role HTML attributes. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[role]` values are valid',
+  /** Title of an accesibility audit that evaluates if all elements have valid aria-role HTML attributes. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[role]` values are not valid',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'ARIA roles must have valid values in order to perform their ' +
+      'intended accessibility functions. ' +
+      '[Learn more about valid ARIA roles](https://dequeuniversity.com/rules/axe/4.7/aria-roles).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaRoles extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-roles',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaRoles;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-text.d.ts

@@ -0,0 +1,10 @@
+export default AriaText;
+declare class AriaText extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-text.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-text.js

@@ -0,0 +1,44 @@
+/**
+ * @license Copyright 2023 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 Ensures all elements with `role=text` have no focusable descendents.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if elements with `role=text` have no focusable descendents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Elements with the `role=text` attribute do not have focusable descendents.',
+  /** Title of an accesibility audit that evaluates if elements with `role=text` have focusable descendents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  failureTitle: 'Elements with the `role=text` attribute do have focusable descendents.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Adding `role=text` around a text node split by markup enables VoiceOver to treat ' +
+      'it as one phrase, but the element\'s focusable descendents will not be announced. ' +
+      '[Learn more about the `role=text` attribute](https://dequeuniversity.com/rules/axe/4.7/aria-text).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaText extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-text',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaText;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-toggle-field-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaToggleFieldName;
+declare class AriaToggleFieldName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-toggle-field-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-toggle-field-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures all ARIA toggle fields have an accessible name.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks that all ARIA toggle fields have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA toggle fields have accessible names',
+  /** Title of an accesibility audit that checks that all ARIA toggle fields have an accessible name. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA toggle fields do not have accessible names',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'When a toggle field doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about toggle fields](https://dequeuniversity.com/rules/axe/4.7/aria-toggle-field-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaToggleFieldName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-toggle-field-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaToggleFieldName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-tooltip-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaTooltipName;
+declare class AriaTooltipName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-tooltip-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-tooltip-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every ARIA tooltip has an accessible name
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if tooltip HTML elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA `tooltip` elements have accessible names',
+  /** Title of an accessibility audit that evaluates if tooltip HTML elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA `tooltip` elements do not have accessible names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for HTML 'tooltip' elements. This is displayed after a user expands the section to see more. No character length limits. 'Learn how...' becomes link text to additional documentation. */
+  description: 'When a tooltip element doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn how to name `tooltip` elements](https://dequeuniversity.com/rules/axe/4.7/aria-tooltip-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaTooltipName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-tooltip-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaTooltipName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-treeitem-name.d.ts

@@ -0,0 +1,10 @@
+export default AriaTreeitemName;
+declare class AriaTreeitemName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-treeitem-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-treeitem-name.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every ARIA treeitem element has an accessible name.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accessibility audit that evaluates if treeitem HTML elements have an accessible name. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA `treeitem` elements have accessible names',
+  /** Title of an accessibility audit that evaluates if treeitem HTML elements do not have accessible names. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA `treeitem` elements do not have accessible names.',
+  /** Description of a Lighthouse audit that tells the user *why* they should have accessible names for HTML elements. 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: 'When a `treeitem` element doesn\'t have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about labeling `treeitem` elements](https://dequeuniversity.com/rules/axe/4.7/aria-treeitem-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AriaTreeitemName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-treeitem-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default AriaTreeitemName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-valid-attr-value.d.ts

@@ -0,0 +1,10 @@
+export default ARIAValidAttr;
+declare class ARIAValidAttr extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-valid-attr-value.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-valid-attr-value.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures all ARIA attributes have valid values.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all elements that have an ARIA HTML attribute have a valid value for that attribute. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[aria-*]` attributes have valid values',
+  /** Title of an accesibility audit that evaluates if all elements that have an ARIA HTML attribute have a valid value for that attribute. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[aria-*]` attributes do not have valid values',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Assistive technologies, like screen readers, can\'t interpret ARIA ' +
+      'attributes with invalid values. [Learn ' +
+      'more about valid values for ARIA attributes](https://dequeuniversity.com/rules/axe/4.7/aria-valid-attr-value).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ARIAValidAttr extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-valid-attr-value',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ARIAValidAttr;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/aria-valid-attr.d.ts

@@ -0,0 +1,10 @@
+export default ARIAValidAttr;
+declare class ARIAValidAttr extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=aria-valid-attr.d.ts.map

node_modules/lighthouse/core/audits/accessibility/aria-valid-attr.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures aria-* attributes are valid and not misspelled or non-existent.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all elements with ARIA HTML attributes have spelled the name of attribute correctly. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[aria-*]` attributes are valid and not misspelled',
+  /** Title of an accesibility audit that evaluates if all elements with ARIA HTML attributes have spelled the name of attribute correctly. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[aria-*]` attributes are not valid or misspelled',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Assistive technologies, like screen readers, can\'t interpret ARIA ' +
+      'attributes with invalid names. [Learn ' +
+      'more about valid ARIA attributes](https://dequeuniversity.com/rules/axe/4.7/aria-valid-attr).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ARIAValidAttr extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'aria-valid-attr',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ARIAValidAttr;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/axe-audit.d.ts

@@ -0,0 +1,17 @@
+export default AxeAudit;
+declare class AxeAudit extends Audit {
+    /**
+     * Base class for audit rules which reflect assessment performed by the aXe accessibility library
+     * See https://github.com/dequelabs/axe-core/blob/6b444546cff492a62a70a74a8fc3c62bd4729400/doc/API.md#results-object for result type and format details
+     *
+     * @param {LH.Artifacts} artifacts Accessibility gatherer artifacts. Note that AxeAudit
+     * expects the meta name for the class to match the rule id from aXe.
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const failingElementsHeader: string;
+}
+import { Audit } from '../audit.js';
+//# sourceMappingURL=axe-audit.d.ts.map

node_modules/lighthouse/core/audits/accessibility/axe-audit.js

@@ -0,0 +1,113 @@
+/**
+ * @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 all aXe audits. Provides a consistent way to
+ * generate audit results using aXe rule names.
+ */
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Label of a table column that identifies HTML elements that have failed an audit. */
+  failingElementsHeader: 'Failing Elements',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class AxeAudit extends Audit {
+  /**
+   * Base class for audit rules which reflect assessment performed by the aXe accessibility library
+   * See https://github.com/dequelabs/axe-core/blob/6b444546cff492a62a70a74a8fc3c62bd4729400/doc/API.md#results-object for result type and format details
+   *
+   * @param {LH.Artifacts} artifacts Accessibility gatherer artifacts. Note that AxeAudit
+   * expects the meta name for the class to match the rule id from aXe.
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    // Indicate if a test is not applicable.
+    // This means aXe did not find any nodes which matched these checks.
+    // Note in Lighthouse we use the phrasing "Not Applicable" (aXe uses "inapplicable", which sounds weird).
+    const notApplicables = artifacts.Accessibility.notApplicable || [];
+    const isNotApplicable = notApplicables.find(result => result.id === this.meta.id);
+    if (isNotApplicable) {
+      return {
+        score: null,
+        notApplicable: true,
+      };
+    }
+
+    // Detect errors reported within aXe 'incomplete' results
+    // aXe uses this result type to indicate errors, or rules which require manual investigation
+    // If aXe reports an error, then bubble it up to the caller
+    const incomplete = artifacts.Accessibility.incomplete || [];
+    const incompleteResult = incomplete.find(result => result.id === this.meta.id);
+    if (incompleteResult?.error) {
+      return {
+        score: null,
+        errorMessage: `axe-core Error: ${incompleteResult.error.message || 'Unknown error'}`,
+      };
+    }
+
+    const isInformative = this.meta.scoreDisplayMode === Audit.SCORING_MODES.INFORMATIVE;
+    const violations = artifacts.Accessibility.violations || [];
+    const failureCases = isInformative ? violations.concat(incomplete) : violations;
+    const rule = failureCases.find(result => result.id === this.meta.id);
+    const impact = rule?.impact;
+    const tags = rule?.tags;
+
+    // Handle absence of aXe failure results for informative rules as 'not applicable'
+    // This scenario indicates that no action is required by the web property owner
+    // Since there is no score impact from informative rules, display the rule as not applicable
+    if (isInformative && !rule) {
+      return {
+        score: null,
+        notApplicable: true,
+      };
+    }
+
+    /** @type {LH.Audit.Details.Table['items']}>} */
+    let items = [];
+    if (rule?.nodes) {
+      items = rule.nodes.map(axeNode => ({
+        node: {
+          ...Audit.makeNodeItem(axeNode.node),
+          explanation: axeNode.failureSummary,
+        },
+        subItems: axeNode.relatedNodes.length ? {
+          type: 'subitems',
+          items: axeNode.relatedNodes.map(node => ({relatedNode: Audit.makeNodeItem(node)})),
+        } : undefined,
+      }));
+    }
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'node', valueType: 'node', subItemsHeading: {key: 'relatedNode', valueType: 'node'}, label: str_(UIStrings.failingElementsHeader)},
+      /* eslint-enable max-len */
+    ];
+
+    /** @type {LH.Audit.Details.DebugData|undefined} */
+    let debugData;
+    if (impact || tags) {
+      debugData = {
+        type: 'debugdata',
+        impact,
+        tags,
+      };
+    }
+
+    return {
+      score: Number(rule === undefined),
+      details: {...Audit.makeTableDetails(headings, items), debugData},
+    };
+  }
+}
+
+export default AxeAudit;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/button-name.d.ts

@@ -0,0 +1,10 @@
+export default ButtonName;
+declare class ButtonName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=button-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/button-name.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures buttons have discernible text.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all button elements have names accessible to screen readers. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Buttons have an accessible name',
+  /** Title of an accesibility audit that evaluates if all button elements have names accessible to screen readers. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Buttons do not have an accessible name',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'When a button doesn\'t have an accessible name, screen readers announce it ' +
+      'as "button", making it unusable for users who rely on screen readers. ' +
+      '[Learn how to make buttons more accessible](https://dequeuniversity.com/rules/axe/4.7/button-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ButtonName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'button-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ButtonName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/bypass.d.ts

@@ -0,0 +1,10 @@
+export default Bypass;
+declare class Bypass extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=bypass.d.ts.map

node_modules/lighthouse/core/audits/accessibility/bypass.js

@@ -0,0 +1,46 @@
+/**
+ * @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 Ensures each page has at least one mechanism for a user to bypass navigation
+ * and jump straight to the content.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the page has elements that let screen reader users skip over repetitive content. `heading`, `skip link`, and `landmark region` are technical terms for the elements that enable quick page navigation. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'The page contains a heading, skip link, or landmark region',
+  /** Title of an accesibility audit that evaluates if the page has elements that let screen reader users skip over repetitive content. `heading`, `skip link`, and `landmark region` are technical terms for the elements that enable quick page navigation. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'The page does not contain a heading, skip link, or landmark region',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Adding ways to bypass repetitive content lets keyboard users navigate the ' +
+      'page more efficiently. ' +
+      '[Learn more about bypass blocks](https://dequeuniversity.com/rules/axe/4.7/bypass).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class Bypass extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'bypass',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default Bypass;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/color-contrast.d.ts

@@ -0,0 +1,10 @@
+export default ColorContrast;
+declare class ColorContrast extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=color-contrast.d.ts.map

node_modules/lighthouse/core/audits/accessibility/color-contrast.js

@@ -0,0 +1,45 @@
+/**
+ * @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 Ensures the contrast between foreground and background colors meets
+ * WCAG 2 AA contrast ratio thresholds.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all foreground colors are distinct enough from their background colors to be legible for users. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Background and foreground colors have a sufficient contrast ratio',
+  /** Title of an accesibility audit that evaluates if all foreground colors are distinct enough from their background colors to be legible for users. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Background and foreground colors do not have a ' +
+      'sufficient contrast ratio.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Low-contrast text is difficult or impossible for many users to read. ' +
+      '[Learn how to provide sufficient color contrast](https://dequeuniversity.com/rules/axe/4.7/color-contrast).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ColorContrast extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'color-contrast',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ColorContrast;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/definition-list.d.ts

@@ -0,0 +1,10 @@
+export default DefinitionList;
+declare class DefinitionList extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=definition-list.d.ts.map

node_modules/lighthouse/core/audits/accessibility/definition-list.js

@@ -0,0 +1,46 @@
+/**
+ * @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 Ensures `<dl>` elements are structured correctly.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all the definition list elements have valid markup for screen readers. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`<dl>`\'s contain only properly-ordered `<dt>` and `<dd>` groups, `<script>`, ' +
+      '`<template>` or `<div>` elements.',
+  /** Title of an accesibility audit that evaluates if all the definition list elements have valid markup for screen readers. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`<dl>`\'s do not contain only properly-ordered `<dt>` and `<dd>` ' +
+      'groups, `<script>`, `<template>` or `<div>` elements.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'When definition lists are not properly marked up, screen readers may produce ' +
+      'confusing or inaccurate output. ' +
+      '[Learn how to structure definition lists correctly](https://dequeuniversity.com/rules/axe/4.7/definition-list).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DefinitionList extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'definition-list',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default DefinitionList;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/dlitem.d.ts

@@ -0,0 +1,10 @@
+export default DLItem;
+declare class DLItem extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=dlitem.d.ts.map

node_modules/lighthouse/core/audits/accessibility/dlitem.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures that all child <dd> and <dt> elements have a <dl> as a parent.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all definition list item elements (`<dt>`/`<dd>`) have a definition list parent element (`<dl>`). This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Definition list items are wrapped in `<dl>` elements',
+  /** Title of an accesibility audit that evaluates if all definition list item elements (`<dt>`/`<dd>`) have a definition list parent element (`<dl>`). This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Definition list items are not wrapped in `<dl>` elements',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Definition list items (`<dt>` and `<dd>`) must be wrapped in a ' +
+      'parent `<dl>` element to ensure that screen readers can properly announce them. ' +
+      '[Learn how to structure definition lists correctly](https://dequeuniversity.com/rules/axe/4.7/dlitem).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DLItem extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'dlitem',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default DLItem;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/document-title.d.ts

@@ -0,0 +1,10 @@
+export default DocumentTitle;
+declare class DocumentTitle extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=document-title.d.ts.map

node_modules/lighthouse/core/audits/accessibility/document-title.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures that each HTML document contains a `<title>`.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the page has a <title> element that describes the page. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Document has a `<title>` element',
+  /** Title of an accesibility audit that evaluates if the page has a <title> element that describes the page. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Document doesn\'t have a `<title>` element',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'The title gives screen reader users an overview of the page, and search ' +
+      'engine users rely on it heavily to determine if a page is relevant to their search. ' +
+      '[Learn more about document titles](https://dequeuniversity.com/rules/axe/4.7/document-title).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DocumentTitle extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'document-title',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default DocumentTitle;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/duplicate-id-active.d.ts

@@ -0,0 +1,10 @@
+export default DuplicateIdActive;
+declare class DuplicateIdActive extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=duplicate-id-active.d.ts.map

node_modules/lighthouse/core/audits/accessibility/duplicate-id-active.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every `id` attribute value of active, focusable elements is unique.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if there are any duplicate id HTML attributes on active, focusable elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`[id]` attributes on active, focusable elements are unique',
+  /** Title of an accesibility audit that checks if there are any duplicate id HTML attributes on active, focusable elements. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`[id]` attributes on active, focusable elements are not unique',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'All focusable elements must have a unique `id` to ensure that they\'re visible to assistive technologies. [Learn how to fix duplicate `id`s](https://dequeuniversity.com/rules/axe/4.7/duplicate-id-active).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DuplicateIdActive extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'duplicate-id-active',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default DuplicateIdActive;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/duplicate-id-aria.d.ts

@@ -0,0 +1,10 @@
+export default DuplicateIdAria;
+declare class DuplicateIdAria extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=duplicate-id-aria.d.ts.map

node_modules/lighthouse/core/audits/accessibility/duplicate-id-aria.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures every `id` attribute value used in ARIA and in labels is unique.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if there are any duplicate ARIA IDs on the page. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'ARIA IDs are unique',
+  /** Title of an accesibility audit that checks if there are any duplicate ARIA IDs on the page. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'ARIA IDs are not unique',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'The value of an ARIA ID must be unique to prevent other instances from being overlooked by assistive technologies. [Learn how to fix duplicate ARIA IDs](https://dequeuniversity.com/rules/axe/4.7/duplicate-id-aria).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DuplicateIdAria extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'duplicate-id-aria',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default DuplicateIdAria;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/empty-heading.d.ts

@@ -0,0 +1,10 @@
+export default EmptyHeading;
+declare class EmptyHeading extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=empty-heading.d.ts.map

node_modules/lighthouse/core/audits/accessibility/empty-heading.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2023 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 Ensures that headings are not empty.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if all heading elements have content. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'All heading elements contain content.',
+  /** Title of an accesibility audit that checks if all heading elements have content. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Heading elements do not contain content.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'A heading with no content or inaccessible text prevent screen reader users from ' +
+      'accessing information on the page\'s structure. ' +
+      '[Learn more about headings](https://dequeuniversity.com/rules/axe/4.7/empty-heading).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class EmptyHeading extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'empty-heading',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default EmptyHeading;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/form-field-multiple-labels.d.ts

@@ -0,0 +1,10 @@
+export default FormFieldMultipleLabels;
+declare class FormFieldMultipleLabels extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=form-field-multiple-labels.d.ts.map

node_modules/lighthouse/core/audits/accessibility/form-field-multiple-labels.js

@@ -0,0 +1,43 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures no form field has multiple label elements.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if any form fields have multiple label elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'No form fields have multiple labels',
+  /** Title of an accesibility audit that checks if any form fields have multiple label elements. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Form fields have multiple labels',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Form fields with multiple labels can be confusingly announced by assistive technologies like screen readers which use either the first, the last, or all of the labels. [Learn how to use form labels](https://dequeuniversity.com/rules/axe/4.7/form-field-multiple-labels).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class FormFieldMultipleLabels extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'form-field-multiple-labels',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default FormFieldMultipleLabels;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/frame-title.d.ts

@@ -0,0 +1,10 @@
+export default FrameTitle;
+declare class FrameTitle extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=frame-title.d.ts.map

node_modules/lighthouse/core/audits/accessibility/frame-title.js

@@ -0,0 +1,43 @@
+/**
+ * @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 Ensures `<iframe>` and `<frame>` elements contain a non-empty title attribute.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all `<frame>` and `<iframe>` elements on the page have a title HTML attribute to describe their contents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`<frame>` or `<iframe>` elements have a title',
+  /** Title of an accesibility audit that evaluates if all `<frame>` and `<iframe>` elements on the page have a title HTML attribute to describe their contents. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`<frame>` or `<iframe>` elements do not have a title',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Screen reader users rely on frame titles to describe the contents of frames. ' +
+      '[Learn more about frame titles](https://dequeuniversity.com/rules/axe/4.7/frame-title).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class FrameTitle extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'frame-title',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default FrameTitle;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/heading-order.d.ts

@@ -0,0 +1,10 @@
+export default HeadingOrder;
+declare class HeadingOrder extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=heading-order.d.ts.map

node_modules/lighthouse/core/audits/accessibility/heading-order.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Ensures heading levels should only ever increase by one.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if heading elements (<h1>, <h2>, etc) appear in numeric order and only ever increase in steps of 1. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Heading elements appear in a sequentially-descending order',
+  /** Title of an accesibility audit that checks if heading elements (<h1>, <h2>, etc) appear in numeric order and only ever increase in steps of 1. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Heading elements are not in a sequentially-descending order',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Properly ordered headings that do not skip levels convey the semantic structure of the page, making it easier to navigate and understand when using assistive technologies. [Learn more about heading order](https://dequeuniversity.com/rules/axe/4.7/heading-order).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class HeadingOrder extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'heading-order',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default HeadingOrder;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/html-has-lang.d.ts

@@ -0,0 +1,10 @@
+export default HTMLHasLang;
+declare class HTMLHasLang extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=html-has-lang.d.ts.map

node_modules/lighthouse/core/audits/accessibility/html-has-lang.js

@@ -0,0 +1,46 @@
+/**
+ * @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 Ensures every HTML document has a `lang` attribute.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the root HTML tag has a lang attribute identifying the page's language. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`<html>` element has a `[lang]` attribute',
+  /** Title of an accesibility audit that evaluates if the root HTML tag has a lang attribute identifying the page's language. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`<html>` element does not have a `[lang]` attribute',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'If a page doesn\'t specify a `lang` attribute, a screen reader assumes ' +
+      'that the page is in the default language that the user chose when setting up the ' +
+      'screen reader. If the page isn\'t actually in the default language, then the screen ' +
+      'reader might not announce the page\'s text correctly. ' +
+      '[Learn more about the `lang` attribute](https://dequeuniversity.com/rules/axe/4.7/html-has-lang).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class HTMLHasLang extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'html-has-lang',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default HTMLHasLang;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/html-lang-valid.d.ts

@@ -0,0 +1,10 @@
+export default HTMLLangValid;
+declare class HTMLLangValid extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=html-lang-valid.d.ts.map

node_modules/lighthouse/core/audits/accessibility/html-lang-valid.js

@@ -0,0 +1,45 @@
+/**
+ * @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 Ensures the lang attribute of the <html> element has a valid value.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the value for root HTML tag's lang attribute is a valid BCP 47 language. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`<html>` element has a valid value for its `[lang]` attribute',
+  /** Title of an accesibility audit that evaluates if the value for root HTML tag's lang attribute is a valid BCP 47 language. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`<html>` element does not have a valid value for ' +
+      'its `[lang]` attribute.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Specifying a valid [BCP 47 language](https://www.w3.org/International/questions/qa-choosing-language-tags#question) ' +
+      'helps screen readers announce text properly. ' +
+      '[Learn how to use the `lang` attribute](https://dequeuniversity.com/rules/axe/4.7/html-lang-valid).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class HTMLLangValid extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'html-lang-valid',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default HTMLLangValid;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/html-xml-lang-mismatch.d.ts

@@ -0,0 +1,10 @@
+export default HTMLXMLLangMismatch;
+declare class HTMLXMLLangMismatch extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=html-xml-lang-mismatch.d.ts.map

node_modules/lighthouse/core/audits/accessibility/html-xml-lang-mismatch.js

@@ -0,0 +1,47 @@
+/**
+ * @license Copyright 2023 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 Ensures that, if present, the `[xml:lang]` attribute value in an HTML document has
+ * the same base language as the `[lang]` attribute.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if the xml:lang attribute, if present, has the same base language as the `lang` attribute. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`<html>` element has an `[xml:lang]` attribute with the same base language as the ' +
+      '`[lang]` attribute.',
+  /** Title of an accesibility audit that evaluates if the xml:lang attribute, if present, has the same base language as the `lang` attribute. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`<html>` element does not have an `[xml:lang]` attribute with the same base ' +
+      'language as the `[lang]` attribute.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'If the webpage does not specify a consistent language, then the screen ' +
+      'reader might not announce the page\'s text correctly. ' +
+      '[Learn more about the `lang` attribute](https://dequeuniversity.com/rules/axe/4.7/html-xml-lang-mismatch).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class HTMLXMLLangMismatch extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'html-xml-lang-mismatch',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default HTMLXMLLangMismatch;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/identical-links-same-purpose.d.ts

@@ -0,0 +1,10 @@
+export default IdenticalLinksSamePurpose;
+declare class IdenticalLinksSamePurpose extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=identical-links-same-purpose.d.ts.map

node_modules/lighthouse/core/audits/accessibility/identical-links-same-purpose.js

@@ -0,0 +1,45 @@
+/**
+ * @license Copyright 2023 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 Ensures that identical links have the same purpose.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if identical links have the same purpose. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Identical links have the same purpose.',
+  /** Title of an accesibility audit that checks if identical links have the same purpose. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Identical links do not have the same purpose.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Links with the same destination should have the same description, to help users ' +
+      'understand the link\'s purpose and decide whether to follow it. ' +
+      '[Learn more about identical links](https://dequeuniversity.com/rules/axe/4.7/identical-links-same-purpose).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class IdenticalLinksSamePurpose extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'identical-links-same-purpose',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default IdenticalLinksSamePurpose;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/image-alt.d.ts

@@ -0,0 +1,10 @@
+export default ImageAlt;
+declare class ImageAlt extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=image-alt.d.ts.map

node_modules/lighthouse/core/audits/accessibility/image-alt.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures <img> elements have alternate text or a role of none or presentation.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all image elements have the alt HTML attribute to describe their contents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Image elements have `[alt]` attributes',
+  /** Title of an accesibility audit that evaluates if all image elements have the alt HTML attribute to describe their contents. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Image elements do not have `[alt]` attributes',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Informative elements should aim for short, descriptive alternate text. ' +
+      'Decorative elements can be ignored with an empty alt attribute. ' +
+      '[Learn more about the `alt` attribute](https://dequeuniversity.com/rules/axe/4.7/image-alt).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ImageAlt extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'image-alt',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ImageAlt;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/input-button-name.d.ts

@@ -0,0 +1,10 @@
+export default InputButtonName;
+declare class InputButtonName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=input-button-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/input-button-name.js

@@ -0,0 +1,44 @@
+/**
+ * @license Copyright 2023 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 Ensures input buttons have discernible text.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all input buttons have discernible text. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Input buttons have discernible text.',
+  /** Title of an accesibility audit that evaluates if all input buttons have discernible text. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Input buttons do not have discernible text.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Adding discernable and accessible text to input buttons may help screen reader ' +
+      'users understand the purpose of the input button. ' +
+      '[Learn more about input buttons](https://dequeuniversity.com/rules/axe/4.7/input-button-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class InputButtonName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'input-button-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default InputButtonName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/input-image-alt.d.ts

@@ -0,0 +1,10 @@
+export default InputImageAlt;
+declare class InputImageAlt extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=input-image-alt.d.ts.map

node_modules/lighthouse/core/audits/accessibility/input-image-alt.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures `<input type="image">` elements have alternate text.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all input elements of type image have an alt HTML attribute to describe their contents. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: '`<input type="image">` elements have `[alt]` text',
+  /** Title of an accesibility audit that evaluates if all input elements of type image have an alt HTML attribute to describe their contents. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: '`<input type="image">` elements do not have `[alt]` text',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'When an image is being used as an `<input>` button, providing alternative ' +
+      'text can help screen reader users understand the purpose of the button. ' +
+      '[Learn about input image alt text](https://dequeuniversity.com/rules/axe/4.7/input-image-alt).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class InputImageAlt extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'input-image-alt',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default InputImageAlt;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/label.d.ts

@@ -0,0 +1,10 @@
+export default Label;
+declare class Label extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=label.d.ts.map

node_modules/lighthouse/core/audits/accessibility/label.js

@@ -0,0 +1,44 @@
+/**
+ * @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 Ensures every form element has a label.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all form elements have corresponding label elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Form elements have associated labels',
+  /** Title of an accesibility audit that evaluates if all form elements have corresponding label elements. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Form elements do not have associated labels',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Labels ensure that form controls are announced properly by assistive ' +
+      'technologies, like screen readers. [Learn ' +
+      'more about form element labels](https://dequeuniversity.com/rules/axe/4.7/label).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class Label extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'label',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default Label;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/landmark-one-main.d.ts

@@ -0,0 +1,10 @@
+export default LandmarkOneMain;
+declare class LandmarkOneMain extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=landmark-one-main.d.ts.map

node_modules/lighthouse/core/audits/accessibility/landmark-one-main.js

@@ -0,0 +1,44 @@
+/**
+ * @license Copyright 2023 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 Ensures that the document has a main landmark.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that checks if the document has a main landmark. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Document has a main landmark.',
+  /** Title of an accesibility audit that checks if the document has a main landmark. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Document does not have a main landmark.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'One main landmark helps screen reader users navigate a web page. ' +
+      '[Learn more about landmarks](https://dequeuniversity.com/rules/axe/4.7/landmark-one-main).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LandmarkOneMain extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'landmark-one-main',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: AxeAudit.SCORING_MODES.INFORMATIVE,
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default LandmarkOneMain;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/link-in-text-block.d.ts

@@ -0,0 +1,10 @@
+export default LinkInTextBlock;
+declare class LinkInTextBlock extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=link-in-text-block.d.ts.map

node_modules/lighthouse/core/audits/accessibility/link-in-text-block.js

@@ -0,0 +1,44 @@
+/**
+ * @license Copyright 2023 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 Ensures that links can be distinguished without relying on color.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all link elements can be distinguished without relying on color. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Links are distinguishable without relying on color.',
+  /** Title of an accesibility audit that evaluates if all link elements can be distinguished without relying on color. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Links rely on color to be distinguishable.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Low-contrast text is difficult or impossible for many users to read. Link text ' +
+      'that is discernible improves the experience for users with low vision. ' +
+      '[Learn how to make links distinguishable](https://dequeuniversity.com/rules/axe/4.7/link-in-text-block).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LinkInTextBlock extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'link-in-text-block',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default LinkInTextBlock;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/link-name.d.ts

@@ -0,0 +1,10 @@
+export default LinkName;
+declare class LinkName extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=link-name.d.ts.map

node_modules/lighthouse/core/audits/accessibility/link-name.js

@@ -0,0 +1,45 @@
+/**
+ * @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 Ensures links have discernible text.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all link elements have a non-generic name to screen readers. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Links have a discernible name',
+  /** Title of an accesibility audit that evaluates if all link elements have a non-generic name to screen readers. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Links do not have a discernible name',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Link text (and alternate text for images, when used as links) that is ' +
+      'discernible, unique, and focusable improves the navigation experience for ' +
+      'screen reader users. ' +
+      '[Learn how to make links accessible](https://dequeuniversity.com/rules/axe/4.7/link-name).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class LinkName extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'link-name',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default LinkName;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/list.d.ts

@@ -0,0 +1,10 @@
+export default List;
+declare class List extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=list.d.ts.map

node_modules/lighthouse/core/audits/accessibility/list.js

@@ -0,0 +1,46 @@
+/**
+ * @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 Ensures that lists are structured correctly.
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if all list elements have a valid structure containing only list items. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'Lists contain only `<li>` elements and script supporting elements ' +
+      '(`<script>` and `<template>`).',
+  /** Title of an accesibility audit that evaluates if all list elements have a valid structure containing only list items. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'Lists do not contain only `<li>` elements and script ' +
+      'supporting elements (`<script>` and `<template>`).',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Screen readers have a specific way of announcing lists. Ensuring proper list ' +
+      'structure aids screen reader output. ' +
+      '[Learn more about proper list structure](https://dequeuniversity.com/rules/axe/4.7/list).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class List extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'list',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default List;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/listitem.d.ts

@@ -0,0 +1,10 @@
+export default ListItem;
+declare class ListItem extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from './axe-audit.js';
+//# sourceMappingURL=listitem.d.ts.map

node_modules/lighthouse/core/audits/accessibility/listitem.js

@@ -0,0 +1,45 @@
+/**
+ * @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 Ensures every list item is contained within a parent list
+ * See base class in axe-audit.js for audit() implementation.
+ */
+
+import AxeAudit from './axe-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of an accesibility audit that evaluates if any list item elements do not have list parent elements. This title is descriptive of the successful state and is shown to users when no user action is required. */
+  title: 'List items (`<li>`) are contained within `<ul>`, `<ol>` or `<menu>` parent elements',
+  /** Title of an accesibility audit that evaluates if any list item elements do not have list parent elements. This title is descriptive of the failing state and is shown to users when there is a failure that needs to be addressed. */
+  failureTitle: 'List items (`<li>`) are not contained within `<ul>`, ' +
+      '`<ol>` or `<menu>` parent elements.',
+  /** Description of a Lighthouse audit that tells the user *why* they should try to pass. 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: 'Screen readers require list items (`<li>`) to be contained within a ' +
+      'parent `<ul>`, `<ol>` or `<menu>` to be announced properly. ' +
+      '[Learn more about proper list structure](https://dequeuniversity.com/rules/axe/4.7/listitem).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class ListItem extends AxeAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'listitem',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Accessibility'],
+    };
+  }
+}
+
+export default ListItem;
+export {UIStrings};

node_modules/lighthouse/core/audits/accessibility/manual/custom-controls-labels.d.ts

@@ -0,0 +1,8 @@
+export default CustomControlsLabels;
+/**
+ * @fileoverview Manual A11y audit to assert custom controls have associated labels.
+ */
+declare class CustomControlsLabels extends ManualAudit {
+}
+import ManualAudit from '../../manual/manual-audit.js';
+//# sourceMappingURL=custom-controls-labels.d.ts.map

node_modules/lighthouse/core/audits/accessibility/manual/custom-controls-labels.js

@@ -0,0 +1,27 @@
+
+/**
+ * @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 ManualAudit from '../../manual/manual-audit.js';
+
+/**
+ * @fileoverview Manual A11y audit to assert custom controls have associated labels.
+ */
+
+class CustomControlsLabels extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'custom-controls-labels',
+      description: 'Custom interactive controls have associated labels, provided by aria-label or aria-labelledby. [Learn more about custom controls and labels](https://developer.chrome.com/docs/lighthouse/accessibility/custom-controls-labels/).',
+      title: 'Custom controls have associated labels',
+    }, super.partialMeta);
+  }
+}
+
+export default CustomControlsLabels;

node_modules/lighthouse/core/audits/accessibility/manual/custom-controls-roles.d.ts

@@ -0,0 +1,8 @@
+export default CustomControlsRoles;
+/**
+ * @fileoverview Manual A11y audit to assert custom controls have associated roles.
+ */
+declare class CustomControlsRoles extends ManualAudit {
+}
+import ManualAudit from '../../manual/manual-audit.js';
+//# sourceMappingURL=custom-controls-roles.d.ts.map

node_modules/lighthouse/core/audits/accessibility/manual/custom-controls-roles.js

@@ -0,0 +1,27 @@
+
+/**
+ * @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 ManualAudit from '../../manual/manual-audit.js';
+
+/**
+ * @fileoverview Manual A11y audit to assert custom controls have associated roles.
+ */
+
+class CustomControlsRoles extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'custom-controls-roles',
+      description: 'Custom interactive controls have appropriate ARIA roles. [Learn how to add roles to custom controls](https://developer.chrome.com/docs/lighthouse/accessibility/custom-control-roles/).',
+      title: 'Custom controls have ARIA roles',
+    }, super.partialMeta);
+  }
+}
+
+export default CustomControlsRoles;

node_modules/lighthouse/core/audits/accessibility/manual/focus-traps.d.ts

@@ -0,0 +1,8 @@
+export default FocusTraps;
+/**
+ * @fileoverview Manual A11y audit to avoid trapping keyboard focus in a region.
+ */
+declare class FocusTraps extends ManualAudit {
+}
+import ManualAudit from '../../manual/manual-audit.js';
+//# sourceMappingURL=focus-traps.d.ts.map

node_modules/lighthouse/core/audits/accessibility/manual/focus-traps.js

@@ -0,0 +1,27 @@
+
+/**
+ * @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 ManualAudit from '../../manual/manual-audit.js';
+
+/**
+ * @fileoverview Manual A11y audit to avoid trapping keyboard focus in a region.
+ */
+
+class FocusTraps extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'focus-traps',
+      description: 'A user can tab into and out of any control or region without accidentally trapping their focus. [Learn how to avoid focus traps](https://developer.chrome.com/docs/lighthouse/accessibility/focus-traps/).',
+      title: 'User focus is not accidentally trapped in a region',
+    }, super.partialMeta);
+  }
+}
+
+export default FocusTraps;

node_modules/lighthouse/core/audits/accessibility/manual/focusable-controls.d.ts

@@ -0,0 +1,8 @@
+export default FocusableControls;
+/**
+ * @fileoverview Manual A11y audit for focusable controls.
+ */
+declare class FocusableControls extends ManualAudit {
+}
+import ManualAudit from '../../manual/manual-audit.js';
+//# sourceMappingURL=focusable-controls.d.ts.map

node_modules/lighthouse/core/audits/accessibility/manual/focusable-controls.js

@@ -0,0 +1,27 @@
+
+/**
+ * @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 ManualAudit from '../../manual/manual-audit.js';
+
+/**
+ * @fileoverview Manual A11y audit for focusable controls.
+ */
+
+class FocusableControls extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'focusable-controls',
+      description: 'Custom interactive controls are keyboard focusable and display a focus indicator. [Learn how to make custom controls focusable](https://developer.chrome.com/docs/lighthouse/accessibility/focusable-controls/).',
+      title: 'Interactive controls are keyboard focusable',
+    }, super.partialMeta);
+  }
+}
+
+export default FocusableControls;

node_modules/lighthouse/core/audits/accessibility/manual/interactive-element-affordance.d.ts

@@ -0,0 +1,8 @@
+export default InteractiveElementAffordance;
+/**
+ * @fileoverview Manual A11y audit for interactive element affordance.
+ */
+declare class InteractiveElementAffordance extends ManualAudit {
+}
+import ManualAudit from '../../manual/manual-audit.js';
+//# sourceMappingURL=interactive-element-affordance.d.ts.map

node_modules/lighthouse/core/audits/accessibility/manual/interactive-element-affordance.js

@@ -0,0 +1,27 @@
+
+/**
+ * @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 ManualAudit from '../../manual/manual-audit.js';
+
+/**
+ * @fileoverview Manual A11y audit for interactive element affordance.
+ */
+
+class InteractiveElementAffordance extends ManualAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return Object.assign({
+      id: 'interactive-element-affordance',
+      description: 'Interactive elements, such as links and buttons, should indicate their state and be distinguishable from non-interactive elements. [Learn how to decorate interactive elements with affordance hints](https://developer.chrome.com/docs/lighthouse/accessibility/interactive-element-affordance/).',
+      title: 'Interactive elements indicate their purpose and state',
+    }, super.partialMeta);
+  }
+}
+
+export default InteractiveElementAffordance;