@marko/language-server 1.0.20 → 1.1.0

package/dist/index.mjs

@@ -3,7 +3,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 }) : x)(function(x) {
   if (typeof require !== "undefined")
     return require.apply(this, arguments);
-  throw new Error('Dynamic require of "' + x + '" is not supported');
+  throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
 // src/index.ts
@@ -76,7 +76,9 @@ function processDoc(doc, process2) {
 // src/utils/text-documents.ts
 import fs from "fs";
 import { URI as URI2 } from "vscode-uri";
-import { FileChangeType } from "vscode-languageserver";
+import {
+  FileChangeType
+} from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
 var docs = /* @__PURE__ */ new Map();
 var openDocs = /* @__PURE__ */ new Set();
@@ -132,67 +134,65 @@ function exists(uri) {
 function isOpen(doc) {
   return openDocs.has(doc);
 }
-function setup(connection4) {
-  connection4.onDidOpenTextDocument((params) => {
-    const ref = params.textDocument;
-    const existingDoc = docs.get(ref.uri);
+function doOpen(params) {
+  const ref = params.textDocument;
+  const existingDoc = docs.get(ref.uri);
+  projectVersion++;
+  if (existingDoc) {
+    if (existingDoc.version === ref.version) {
+      openDocs.add(existingDoc);
+      return;
+    }
+    openDocs.delete(existingDoc);
+    docs.delete(ref.uri);
+  }
+  const newDoc = TextDocument.create(
+    ref.uri,
+    ref.languageId,
+    ref.version,
+    ref.text
+  );
+  openDocs.add(newDoc);
+  fileExists.set(ref.uri, true);
+  docs.set(ref.uri, newDoc);
+}
+function doChange(params) {
+  const ref = params.textDocument;
+  const changes = params.contentChanges;
+  const doc = docs.get(ref.uri);
+  if (changes.length > 0 && ref.version != null && doc) {
+    TextDocument.update(doc, changes, ref.version);
+    emitFileChange(doc);
+  }
+}
+function doClose(params) {
+  const ref = params.textDocument;
+  const doc = docs.get(ref.uri);
+  if (doc) {
     projectVersion++;
-    if (existingDoc) {
-      if (existingDoc.version === ref.version) {
-        openDocs.add(existingDoc);
-        return;
-      }
-      openDocs.delete(existingDoc);
+    openDocs.delete(doc);
+    if (URI2.parse(ref.uri).scheme !== "file") {
       docs.delete(ref.uri);
     }
-    const newDoc = TextDocument.create(
-      ref.uri,
-      ref.languageId,
-      ref.version,
-      ref.text
-    );
-    openDocs.add(newDoc);
-    fileExists.set(ref.uri, true);
-    docs.set(ref.uri, newDoc);
-  });
-  connection4.onDidChangeTextDocument((params) => {
-    const ref = params.textDocument;
-    const changes = params.contentChanges;
-    const doc = docs.get(ref.uri);
-    if (changes.length > 0 && ref.version != null && doc) {
-      TextDocument.update(doc, changes, ref.version);
-      emitFileChange(doc);
-    }
-  });
-  connection4.onDidCloseTextDocument((params) => {
-    const ref = params.textDocument;
-    const doc = docs.get(ref.uri);
-    if (doc) {
-      projectVersion++;
-      openDocs.delete(doc);
-      if (URI2.parse(ref.uri).scheme !== "file") {
-        docs.delete(ref.uri);
-      }
-    }
-  });
-  connection4.onDidChangeWatchedFiles(async (params) => {
-    for (const change of params.changes) {
-      switch (change.type) {
-        case FileChangeType.Created:
-          fileExists.set(change.uri, true);
-          break;
-        case FileChangeType.Deleted:
-        case FileChangeType.Changed: {
-          fileExists.set(change.uri, change.type === FileChangeType.Changed);
-          const doc = docs.get(change.uri);
-          if (doc && !openDocs.has(doc)) {
-            docs.delete(change.uri);
-          }
+  }
+}
+function doChangeWatchedFiles(params) {
+  for (const change of params.changes) {
+    switch (change.type) {
+      case FileChangeType.Created:
+        fileExists.set(change.uri, true);
+        break;
+      case FileChangeType.Deleted:
+      case FileChangeType.Changed: {
+        fileExists.set(change.uri, change.type === FileChangeType.Changed);
+        const doc = docs.get(change.uri);
+        if (doc && !openDocs.has(doc)) {
+          docs.delete(change.uri);
         }
       }
     }
-    emitFileChange(void 0);
-  });
+  }
+  emitFileChange(void 0);
 }
 function getLanguageId(uri) {
   const ext = uri.slice(uri.lastIndexOf(".") + 1);
@@ -217,6 +217,7 @@ function emitFileChange(doc) {
 }
 
 // src/utils/workspace.ts
+var isInitialized = false;
 var connection;
 var configChangeHandlers = /* @__PURE__ */ new Set();
 var settingsCache = /* @__PURE__ */ new Map();
@@ -234,11 +235,15 @@ async function getConfig(section) {
 function onConfigChange(handler) {
   configChangeHandlers.add(handler);
 }
-function setup2(_) {
+function setup(_) {
   connection = _;
   connection.onDidChangeConfiguration(() => {
-    settingsCache.clear();
-    emitConfigChange();
+    if (isInitialized) {
+      settingsCache.clear();
+      emitConfigChange();
+    } else {
+      isInitialized = true;
+    }
   });
 }
 function emitConfigChange() {
@@ -251,7 +256,7 @@ function emitConfigChange() {
 import { inspect } from "util";
 var connection2;
 var previousMessagesByType = /* @__PURE__ */ new Map();
-function setup3(_) {
+function setup2(_) {
   connection2 = _;
 }
 function displayError(data) {
@@ -276,6 +281,750 @@ function display(type, data) {
 // src/service/index.ts
 import { MarkupContent, MarkupKind as MarkupKind3 } from "vscode-languageserver";
 
+// src/service/html/index.ts
+import axe from "axe-core";
+import { extractHTML } from "@marko/language-tools";
+import { JSDOM } from "jsdom";
+
+// src/service/html/axe-rules/axe-rules.ts
+var keyboard = {
+  /**
+   * - Ensures every accesskey attribute value is unique
+   * - accesskey attribute value should be unique ([url](https://dequeuniversity.com/rules/axe/4.4/accesskeys?application=axeAPI))
+   */
+  accesskeys: "accesskeys",
+  /**
+   * - Ensures each page has at least one mechanism for a user to bypass navigation and jump straight to the content
+   * - Page must have means to bypass repeated blocks ([url](https://dequeuniversity.com/rules/axe/4.4/bypass?application=axeAPI))
+   */
+  bypass: "bypass",
+  /**
+   * - Ensures elements in the focus order have a role appropriate for interactive content
+   * - Elements in the focus order should have an appropriate role ([url](https://dequeuniversity.com/rules/axe/4.4/focus-order-semantics?application=axeAPI))
+   */
+  focusOrderSemantics: "focus-order-semantics",
+  /**
+   * - Ensures `<frame>` and `<iframe>` elements with focusable content do not have tabindex=-1
+   * - Frames with focusable content must not have tabindex=-1 ([url](https://dequeuniversity.com/rules/axe/4.4/frame-focusable-content?application=axeAPI))
+   */
+  frameFocusableContent: "frame-focusable-content",
+  /**
+   * - Ensures interactive controls are not nested as they are not always announced by screen readers or can cause focus problems for assistive technologies
+   * - Interactive controls must not be nested ([url](https://dequeuniversity.com/rules/axe/4.4/nested-interactive?application=axeAPI))
+   */
+  nestedInteractive: "nested-interactive",
+  /**
+   * - Ensures all page content is contained by landmarks
+   * - All page content should be contained by landmarks ([url](https://dequeuniversity.com/rules/axe/4.4/region?application=axeAPI))
+   */
+  region: "region",
+  /**
+   * - Ensure elements that have scrollable content are accessible by keyboard
+   * - Scrollable region must have keyboard access ([url](https://dequeuniversity.com/rules/axe/4.4/scrollable-region-focusable?application=axeAPI))
+   */
+  scrollableRegionFocusable: "scrollable-region-focusable",
+  /**
+   * - Ensure all skip links have a focusable target
+   * - The skip-link target should exist and be focusable ([url](https://dequeuniversity.com/rules/axe/4.4/skip-link?application=axeAPI))
+   */
+  skipLink: "skip-link",
+  /**
+   * - Ensures tabindex attribute values are not greater than 0
+   * - Elements should not have tabindex greater than zero ([url](https://dequeuniversity.com/rules/axe/4.4/tabindex?application=axeAPI))
+   */
+  tabindex: "tabindex"
+};
+var textAlternatives = {
+  /**
+   * - Ensures `<area>` elements of image maps have alternate text
+   * - Active `<area>` elements must have alternate text ([url](https://dequeuniversity.com/rules/axe/4.4/area-alt?application=axeAPI))
+   */
+  areaAlt: "area-alt",
+  /**
+   * - Ensures each HTML document contains a non-empty `<title>` element
+   * - Documents must have `<title>` element to aid in navigation ([url](https://dequeuniversity.com/rules/axe/4.4/document-title?application=axeAPI))
+   */
+  documentTitle: "document-title",
+  /**
+   * - Ensures `<iframe>` and `<frame>` elements contain a unique title attribute
+   * - Frames should have a unique title attribute ([url](https://dequeuniversity.com/rules/axe/4.4/frame-title-unique?application=axeAPI))
+   */
+  frameTitleUnique: "frame-title-unique",
+  /**
+   * - Ensures `<iframe>` and `<frame>` elements have an accessible name
+   * - Frames must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/frame-title?application=axeAPI))
+   */
+  frameTitle: "frame-title",
+  /**
+   * - Ensures `<img>` elements have alternate text or a role of none or presentation
+   * - Images must have alternate text ([url](https://dequeuniversity.com/rules/axe/4.4/image-alt?application=axeAPI))
+   */
+  imageAlt: "image-alt",
+  /**
+   * - Ensure image alternative is not repeated as text
+   * - Alternative text of images should not be repeated as text ([url](https://dequeuniversity.com/rules/axe/4.4/image-redundant-alt?application=axeAPI))
+   */
+  imageRedundantAlt: "image-redundant-alt",
+  /**
+   * - Ensures `<input type="image">` elements have alternate text
+   * - Image buttons must have alternate text ([url](https://dequeuniversity.com/rules/axe/4.4/input-image-alt?application=axeAPI))
+   */
+  inputImageAlt: "input-image-alt",
+  /**
+   * - Ensures `<object>` elements have alternate text
+   * - `<object>` elements must have alternate text ([url](https://dequeuniversity.com/rules/axe/4.4/object-alt?application=axeAPI))
+   */
+  objectAlt: "object-alt",
+  /**
+   * - Ensures [role='img'] elements have alternate text
+   * - [role='img'] elements must have an alternative text ([url](https://dequeuniversity.com/rules/axe/4.4/role-img-alt?application=axeAPI))
+   */
+  roleImgAlt: "role-img-alt",
+  /**
+   * - Ensures that server-side image maps are not used
+   * - Server-side image maps must not be used ([url](https://dequeuniversity.com/rules/axe/4.4/server-side-image-map?application=axeAPI))
+   */
+  serverSideImageMap: "server-side-image-map",
+  /**
+   * - Ensures `<svg>` elements with an img, graphics-document or graphics-symbol role have an accessible text
+   * - `<svg>` elements with an img role must have an alternative text ([url](https://dequeuniversity.com/rules/axe/4.4/svg-img-alt?application=axeAPI))
+   */
+  svgImgAlt: "svg-img-alt",
+  /**
+   * - Ensures `<video>` elements have captions
+   * - `<video>` elements must have captions ([url](https://dequeuniversity.com/rules/axe/4.4/video-caption?application=axeAPI))
+   */
+  videoCaption: "video-caption"
+};
+var aria = {
+  /**
+   * - Ensures ARIA attributes are allowed for an element's role
+   * - Elements must only use allowed ARIA attributes ([url](https://dequeuniversity.com/rules/axe/4.4/aria-allowed-attr?application=axeAPI))
+   */
+  ariaAllowedAttr: "aria-allowed-attr",
+  /**
+   * - Ensures role attribute has an appropriate value for the element
+   * - ARIA role should be appropriate for the element ([url](https://dequeuniversity.com/rules/axe/4.4/aria-allowed-role?application=axeAPI))
+   */
+  ariaAllowedRole: "aria-allowed-role",
+  /**
+   * - Ensures every ARIA button, link and menuitem has an accessible name
+   * - ARIA commands must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-command-name?application=axeAPI))
+   */
+  ariaCommandName: "aria-command-name",
+  /**
+   * - Ensures every ARIA dialog and alertdialog node has an accessible name
+   * - ARIA dialog and alertdialog nodes should have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-dialog-name?application=axeAPI))
+   */
+  ariaDialogName: "aria-dialog-name",
+  /**
+   * - Ensures aria-hidden='true' is not present on the document body.
+   * - aria-hidden='true' must not be present on the document body ([url](https://dequeuniversity.com/rules/axe/4.4/aria-hidden-body?application=axeAPI))
+   */
+  ariaHiddenBody: "aria-hidden-body",
+  /**
+   * - Ensures every ARIA input field has an accessible name
+   * - ARIA input fields must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-input-field-name?application=axeAPI))
+   */
+  ariaInputFieldName: "aria-input-field-name",
+  /**
+   * - Ensures every ARIA meter node has an accessible name
+   * - ARIA meter nodes must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-meter-name?application=axeAPI))
+   */
+  ariaMeterName: "aria-meter-name",
+  /**
+   * - Ensures every ARIA progressbar node has an accessible name
+   * - ARIA progressbar nodes must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-progressbar-name?application=axeAPI))
+   */
+  ariaProgressbarName: "aria-progressbar-name",
+  /**
+   * - Ensures elements with ARIA roles have all required ARIA attributes
+   * - Required ARIA attributes must be provided ([url](https://dequeuniversity.com/rules/axe/4.4/aria-required-attr?application=axeAPI))
+   */
+  ariaRequiredAttr: "aria-required-attr",
+  /**
+   * - Ensures elements with an ARIA role that require child roles contain them
+   * - Certain ARIA roles must contain particular children ([url](https://dequeuniversity.com/rules/axe/4.4/aria-required-children?application=axeAPI))
+   */
+  ariaRequiredChildren: "aria-required-children",
+  /**
+   * - Ensures elements with an ARIA role that require parent roles are contained by them
+   * - Certain ARIA roles must be contained by particular parents ([url](https://dequeuniversity.com/rules/axe/4.4/aria-required-parent?application=axeAPI))
+   */
+  ariaRequiredParent: "aria-required-parent",
+  /**
+   * - Ensure aria-roledescription is only used on elements with an implicit or explicit role
+   * - aria-roledescription must be on elements with a semantic role ([url](https://dequeuniversity.com/rules/axe/4.4/aria-roledescription?application=axeAPI))
+   */
+  ariaRoledescription: "aria-roledescription",
+  /**
+   * - Ensures all elements with a role attribute use a valid value
+   * - ARIA roles used must conform to valid values ([url](https://dequeuniversity.com/rules/axe/4.4/aria-roles?application=axeAPI))
+   */
+  ariaRoles: "aria-roles",
+  /**
+   * - Ensures "role=text" is used on elements with no focusable descendants
+   * - "role=text" should have no focusable descendants ([url](https://dequeuniversity.com/rules/axe/4.4/aria-text?application=axeAPI))
+   */
+  ariaText: "aria-text",
+  /**
+   * - Ensures every ARIA toggle field has an accessible name
+   * - ARIA toggle fields must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-toggle-field-name?application=axeAPI))
+   */
+  ariaToggleFieldName: "aria-toggle-field-name",
+  /**
+   * - Ensures every ARIA tooltip node has an accessible name
+   * - ARIA tooltip nodes must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-tooltip-name?application=axeAPI))
+   */
+  ariaTooltipName: "aria-tooltip-name",
+  /**
+   * - Ensures every ARIA treeitem node has an accessible name
+   * - ARIA treeitem nodes should have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/aria-treeitem-name?application=axeAPI))
+   */
+  ariaTreeitemName: "aria-treeitem-name",
+  /**
+   * - Ensures all ARIA attributes have valid values
+   * - ARIA attributes must conform to valid values ([url](https://dequeuniversity.com/rules/axe/4.4/aria-valid-attr-value?application=axeAPI))
+   */
+  ariaValidAttrValue: "aria-valid-attr-value",
+  /**
+   * - Ensures attributes that begin with aria- are valid ARIA attributes
+   * - ARIA attributes must conform to valid names ([url](https://dequeuniversity.com/rules/axe/4.4/aria-valid-attr?application=axeAPI))
+   */
+  ariaValidAttr: "aria-valid-attr",
+  /**
+   * - Ensures table headers have discernible text
+   * - Table header text must not be empty ([url](https://dequeuniversity.com/rules/axe/4.4/empty-table-header?application=axeAPI))
+   */
+  emptyTableHeader: "empty-table-header",
+  /**
+   * - Flags elements whose role is none or presentation and which cause the role conflict resolution to trigger.
+   * - Elements of role none or presentation should be flagged ([url](https://dequeuniversity.com/rules/axe/4.4/presentation-role-conflict?application=axeAPI))
+   */
+  presentationRoleConflict: "presentation-role-conflict"
+};
+var nameRoleValue = {
+  /**
+   * - Ensures aria-hidden elements are not focusable nor contain focusable elements
+   * - ARIA hidden element must not be focusable or contain focusable elements ([url](https://dequeuniversity.com/rules/axe/4.4/aria-hidden-focus?application=axeAPI))
+   */
+  ariaHiddenFocus: "aria-hidden-focus",
+  /**
+   * - Ensures buttons have discernible text
+   * - Buttons must have discernible text ([url](https://dequeuniversity.com/rules/axe/4.4/button-name?application=axeAPI))
+   */
+  buttonName: "button-name",
+  /**
+   * - Ensures headings have discernible text
+   * - Headings should not be empty ([url](https://dequeuniversity.com/rules/axe/4.4/empty-heading?application=axeAPI))
+   */
+  emptyHeading: "empty-heading",
+  /**
+   * - Ensures input buttons have discernible text
+   * - Input buttons must have discernible text ([url](https://dequeuniversity.com/rules/axe/4.4/input-button-name?application=axeAPI))
+   */
+  inputButtonName: "input-button-name",
+  /**
+   * - Ensures links have discernible text
+   * - Links must have discernible text ([url](https://dequeuniversity.com/rules/axe/4.4/link-name?application=axeAPI))
+   */
+  linkName: "link-name"
+};
+var timeAndMedia = {
+  /**
+   * - Ensures `<audio>` elements have captions
+   * - `<audio>` elements must have a captions track ([url](https://dequeuniversity.com/rules/axe/4.4/audio-caption?application=axeAPI))
+   */
+  audioCaption: "audio-caption",
+  /**
+   * - Ensures `<blink>` elements are not used
+   * - `<blink>` elements are deprecated and must not be used ([url](https://dequeuniversity.com/rules/axe/4.4/blink?application=axeAPI))
+   */
+  blink: "blink",
+  /**
+   * - Ensures `<meta http-equiv="refresh">` is not used
+   * - Timed refresh must not exist ([url](https://dequeuniversity.com/rules/axe/4.4/meta-refresh?application=axeAPI))
+   */
+  metaRefresh: "meta-refresh",
+  /**
+   * - Ensures `<video>` or `<audio>` elements do not autoplay audio for more than 3 seconds without a control mechanism to stop or mute the audio
+   * - `<video>` or `<audio>` elements must not play automatically ([url](https://dequeuniversity.com/rules/axe/4.4/no-autoplay-audio?application=axeAPI))
+   */
+  noAutoplayAudio: "no-autoplay-audio"
+};
+var forms = {
+  /**
+   * - Ensure the autocomplete attribute is correct and suitable for the form field
+   * - autocomplete attribute must be used correctly ([url](https://dequeuniversity.com/rules/axe/4.4/autocomplete-valid?application=axeAPI))
+   */
+  autocompleteValid: "autocomplete-valid",
+  /**
+   * - Ensures form field does not have multiple label elements
+   * - Form field must not have multiple label elements ([url](https://dequeuniversity.com/rules/axe/4.4/form-field-multiple-labels?application=axeAPI))
+   */
+  formFieldMultipleLabels: "form-field-multiple-labels",
+  /**
+   * - Ensures that every form element has a visible label and is not solely labeled using hidden labels, or the title or aria-describedby attributes
+   * - Form elements should have a visible label ([url](https://dequeuniversity.com/rules/axe/4.4/label-title-only?application=axeAPI))
+   */
+  labelTitleOnly: "label-title-only",
+  /**
+   * - Ensures every form element has a label
+   * - Form elements must have labels ([url](https://dequeuniversity.com/rules/axe/4.4/label?application=axeAPI))
+   */
+  label: "label",
+  /**
+   * - Ensures select element has an accessible name
+   * - Select element must have an accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/select-name?application=axeAPI))
+   */
+  selectName: "select-name"
+};
+var structure = {
+  /**
+   * - Ensure that text spacing set through style attributes can be adjusted with custom stylesheets
+   * - Inline text spacing must be adjustable with custom stylesheets ([url](https://dequeuniversity.com/rules/axe/4.4/avoid-inline-spacing?application=axeAPI))
+   */
+  avoidInlineSpacing: "avoid-inline-spacing",
+  /**
+   * - Ensures content is not locked to any specific display orientation, and the content is operable in all display orientations
+   * - CSS Media queries must not lock display orientation ([url](https://dequeuniversity.com/rules/axe/4.4/css-orientation-lock?application=axeAPI))
+   */
+  cssOrientationLock: "css-orientation-lock",
+  /**
+   * - Ensures `<dl>` elements are structured correctly
+   * - `<dl>` elements must only directly contain properly-ordered `<dt>` and `<dd>` groups, `<script>`, `<template>` or `<div>` elements ([url](https://dequeuniversity.com/rules/axe/4.4/definition-list?application=axeAPI))
+   */
+  definitionList: "definition-list",
+  /**
+   * - Ensures `<dt>` and `<dd>` elements are contained by a `<dl>`
+   * - `<dt>` and `<dd>` elements must be contained by a `<dl>` ([url](https://dequeuniversity.com/rules/axe/4.4/dlitem?application=axeAPI))
+   */
+  dlitem: "dlitem",
+  /**
+   * - Ensures `<iframe>` and `<frame>` elements contain the axe-core script
+   * - Frames should be tested with axe-core ([url](https://dequeuniversity.com/rules/axe/4.4/frame-tested?application=axeAPI))
+   */
+  frameTested: "frame-tested",
+  /**
+   * - Informs users about hidden content.
+   * - Hidden content on the page should be analyzed ([url](https://dequeuniversity.com/rules/axe/4.4/hidden-content?application=axeAPI))
+   */
+  hiddenContent: "hidden-content",
+  /**
+   * - Ensures that lists are structured correctly
+   * - `<ul>` and `<ol>` must only directly contain `<li>`, `<script>` or `<template>` elements ([url](https://dequeuniversity.com/rules/axe/4.4/list?application=axeAPI))
+   */
+  list: "list",
+  /**
+   * - Ensures `<li>` elements are used semantically
+   * - `<li>` elements must be contained in a `<ul>` or `<ol>` ([url](https://dequeuniversity.com/rules/axe/4.4/listitem?application=axeAPI))
+   */
+  listitem: "listitem"
+};
+var parsing = {
+  /**
+   * - Ensures every id attribute value of active elements is unique
+   * - IDs of active elements must be unique ([url](https://dequeuniversity.com/rules/axe/4.4/duplicate-id-active?application=axeAPI))
+   */
+  duplicateIdActive: "duplicate-id-active",
+  /**
+   * - Ensures every id attribute value used in ARIA and in labels is unique
+   * - IDs used in ARIA and labels must be unique ([url](https://dequeuniversity.com/rules/axe/4.4/duplicate-id-aria?application=axeAPI))
+   */
+  duplicateIdAria: "duplicate-id-aria",
+  /**
+   * - Ensures every id attribute value is unique
+   * - id attribute value must be unique ([url](https://dequeuniversity.com/rules/axe/4.4/duplicate-id?application=axeAPI))
+   */
+  duplicateId: "duplicate-id",
+  /**
+   * - Ensures `<marquee>` elements are not used
+   * - `<marquee>` elements are deprecated and must not be used ([url](https://dequeuniversity.com/rules/axe/4.4/marquee?application=axeAPI))
+   */
+  marquee: "marquee"
+};
+var semantics = {
+  /**
+   * - Ensures the order of headings is semantically correct
+   * - Heading levels should only increase by one ([url](https://dequeuniversity.com/rules/axe/4.4/heading-order?application=axeAPI))
+   */
+  headingOrder: "heading-order",
+  /**
+   * - Ensure that links with the same accessible name serve a similar purpose
+   * - Links with the same name must have a similar purpose ([url](https://dequeuniversity.com/rules/axe/4.4/identical-links-same-purpose?application=axeAPI))
+   */
+  identicalLinksSamePurpose: "identical-links-same-purpose",
+  /**
+   * - Ensures that elements labelled through their content must have their visible text as part of their accessible name
+   * - Elements must have their visible text as part of their accessible name ([url](https://dequeuniversity.com/rules/axe/4.4/label-content-name-mismatch?application=axeAPI))
+   */
+  labelContentNameMismatch: "label-content-name-mismatch",
+  /**
+   * - Ensures the banner landmark is at top level
+   * - Banner landmark should not be contained in another landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-banner-is-top-level?application=axeAPI))
+   */
+  landmarkBannerIsTopLevel: "landmark-banner-is-top-level",
+  /**
+   * - Ensures the complementary landmark or aside is at top level
+   * - Aside should not be contained in another landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-complementary-is-top-level?application=axeAPI))
+   */
+  landmarkComplementaryIsTopLevel: "landmark-complementary-is-top-level",
+  /**
+   * - Ensures the contentinfo landmark is at top level
+   * - Contentinfo landmark should not be contained in another landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-contentinfo-is-top-level?application=axeAPI))
+   */
+  landmarkContentinfoIsTopLevel: "landmark-contentinfo-is-top-level",
+  /**
+   * - Ensures the main landmark is at top level
+   * - Main landmark should not be contained in another landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-main-is-top-level?application=axeAPI))
+   */
+  landmarkMainIsTopLevel: "landmark-main-is-top-level",
+  /**
+   * - Ensures the document has at most one banner landmark
+   * - Document should not have more than one banner landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-no-duplicate-banner?application=axeAPI))
+   */
+  landmarkNoDuplicateBanner: "landmark-no-duplicate-banner",
+  /**
+   * - Ensures the document has at most one contentinfo landmark
+   * - Document should not have more than one contentinfo landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-no-duplicate-contentinfo?application=axeAPI))
+   */
+  landmarkNoDuplicateContentinfo: "landmark-no-duplicate-contentinfo",
+  /**
+   * - Ensures the document has at most one main landmark
+   * - Document should not have more than one main landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-no-duplicate-main?application=axeAPI))
+   */
+  landmarkNoDuplicateMain: "landmark-no-duplicate-main",
+  /**
+   * - Ensures the document has a main landmark
+   * - Document should have one main landmark ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-one-main?application=axeAPI))
+   */
+  landmarkOneMain: "landmark-one-main",
+  /**
+   * - Landmarks should have a unique role or role/label/title (i.e. accessible name) combination
+   * - Ensures landmarks are unique ([url](https://dequeuniversity.com/rules/axe/4.4/landmark-unique?application=axeAPI))
+   */
+  landmarkUnique: "landmark-unique",
+  /**
+   * - Ensure bold, italic text and font-size is not used to style `<p>` elements as a heading
+   * - Styled `<p>` elements must not be used as headings ([url](https://dequeuniversity.com/rules/axe/4.4/p-as-heading?application=axeAPI))
+   */
+  pAsHeading: "p-as-heading",
+  /**
+   * - Ensure that the page, or at least one of its frames contains a level-one heading
+   * - Page should contain a level-one heading ([url](https://dequeuniversity.com/rules/axe/4.4/page-has-heading-one?application=axeAPI))
+   */
+  pageHasHeadingOne: "page-has-heading-one"
+};
+var language = {
+  /**
+   * - Ensures every HTML document has a lang attribute
+   * - `<html>` element must have a lang attribute ([url](https://dequeuniversity.com/rules/axe/4.4/html-has-lang?application=axeAPI))
+   */
+  htmlHasLang: "html-has-lang",
+  /**
+   * - Ensures the lang attribute of the `<html>` element has a valid value
+   * - `<html>` element must have a valid value for the lang attribute ([url](https://dequeuniversity.com/rules/axe/4.4/html-lang-valid?application=axeAPI))
+   */
+  htmlLangValid: "html-lang-valid",
+  /**
+   * - Ensure that HTML elements with both valid lang and xml:lang attributes agree on the base language of the page
+   * - HTML elements with lang and xml:lang must have the same base language ([url](https://dequeuniversity.com/rules/axe/4.4/html-xml-lang-mismatch?application=axeAPI))
+   */
+  htmlXmlLangMismatch: "html-xml-lang-mismatch",
+  /**
+   * - Ensures lang attributes have valid values
+   * - lang attribute must have a valid value ([url](https://dequeuniversity.com/rules/axe/4.4/valid-lang?application=axeAPI))
+   */
+  validLang: "valid-lang"
+};
+var sensoryAndVisualCues = {
+  /**
+   * - Ensures `<meta name="viewport">` can scale a significant amount
+   * - Users should be able to zoom and scale the text up to 500% ([url](https://dequeuniversity.com/rules/axe/4.4/meta-viewport-large?application=axeAPI))
+   */
+  metaViewportLarge: "meta-viewport-large",
+  /**
+   * - Ensures `<meta name="viewport">` does not disable text scaling and zooming
+   * - Zooming and scaling should not be disabled ([url](https://dequeuniversity.com/rules/axe/4.4/meta-viewport?application=axeAPI))
+   */
+  metaViewport: "meta-viewport"
+};
+var tables = {
+  /**
+   * - Ensures the scope attribute is used correctly on tables
+   * - scope attribute should be used correctly ([url](https://dequeuniversity.com/rules/axe/4.4/scope-attr-valid?application=axeAPI))
+   */
+  scopeAttrValid: "scope-attr-valid",
+  /**
+   * - Ensure the `<caption>` element does not contain the same text as the summary attribute
+   * - tables should not have the same summary and caption ([url](https://dequeuniversity.com/rules/axe/4.4/table-duplicate-name?application=axeAPI))
+   */
+  tableDuplicateName: "table-duplicate-name",
+  /**
+   * - Ensure that tables with a caption use the `<caption>` element.
+   * - Data or header cells must not be used to give caption to a data table. ([url](https://dequeuniversity.com/rules/axe/4.4/table-fake-caption?application=axeAPI))
+   */
+  tableFakeCaption: "table-fake-caption",
+  /**
+   * - Ensure that each non-empty data cell in a `<table>` larger than 3 by 3  has one or more table headers
+   * - Non-empty `<td>` elements in larger `<table>` must have an associated table header ([url](https://dequeuniversity.com/rules/axe/4.4/td-has-header?application=axeAPI))
+   */
+  tdHasHeader: "td-has-header",
+  /**
+   * - Ensure that each cell in a table that uses the headers attribute refers only to other cells in that table
+   * - Table cells that use the headers attribute must only refer to cells in the same table ([url](https://dequeuniversity.com/rules/axe/4.4/td-headers-attr?application=axeAPI))
+   */
+  tdHeadersAttr: "td-headers-attr",
+  /**
+   * - Ensure that `<th>` elements and elements with role=columnheader/rowheader have data cells they describe
+   * - Table headers in a data table must refer to data cells ([url](https://dequeuniversity.com/rules/axe/4.4/th-has-data-cells?application=axeAPI))
+   */
+  thHasDataCells: "th-has-data-cells"
+};
+
+// src/service/html/axe-rules/separated-rules.ts
+var rules = {
+  /**
+   * These rules can be evaluated against any component.
+   */
+  alwaysAllowed: [
+    aria.ariaAllowedAttr,
+    aria.ariaAllowedRole,
+    aria.ariaHiddenBody,
+    aria.ariaRoledescription,
+    aria.ariaRoles,
+    aria.presentationRoleConflict,
+    forms.autocompleteValid,
+    forms.formFieldMultipleLabels,
+    // Could not find error state
+    keyboard.accesskeys,
+    keyboard.focusOrderSemantics,
+    keyboard.tabindex,
+    language.htmlLangValid,
+    language.htmlXmlLangMismatch,
+    language.validLang,
+    nameRoleValue.ariaHiddenFocus,
+    // Could not find error state
+    nameRoleValue.emptyHeading,
+    parsing.duplicateIdActive,
+    parsing.duplicateIdAria,
+    parsing.marquee,
+    semantics.identicalLinksSamePurpose,
+    // Could not find error state
+    semantics.landmarkNoDuplicateBanner,
+    semantics.landmarkNoDuplicateContentinfo,
+    semantics.landmarkNoDuplicateMain,
+    semantics.landmarkUnique,
+    sensoryAndVisualCues.metaViewportLarge,
+    // Could not find error state
+    sensoryAndVisualCues.metaViewport,
+    // Could not find error state
+    tables.scopeAttrValid,
+    // Could not find error state
+    textAlternatives.serverSideImageMap,
+    // Could not find error state
+    timeAndMedia.blink,
+    timeAndMedia.metaRefresh,
+    // Could not find error state
+    timeAndMedia.noAutoplayAudio
+    // Could not find error state
+  ],
+  /**
+   * These rules can't be resolved with a spread operator
+   * in the node's attributes
+   */
+  requiresAttrs: [
+    aria.ariaRequiredAttr,
+    language.htmlHasLang,
+    textAlternatives.areaAlt,
+    textAlternatives.imageAlt,
+    textAlternatives.imageRedundantAlt,
+    textAlternatives.inputImageAlt,
+    textAlternatives.objectAlt,
+    textAlternatives.roleImgAlt,
+    textAlternatives.svgImgAlt
+  ],
+  /**
+   * These rules can't be resolved with dynamic content
+   * in the body of the node
+   */
+  requiresChildren: [
+    aria.ariaRequiredChildren,
+    aria.ariaText,
+    aria.ariaValidAttrValue,
+    aria.emptyTableHeader,
+    keyboard.frameFocusableContent,
+    keyboard.skipLink,
+    nameRoleValue.ariaHiddenFocus,
+    semantics.labelContentNameMismatch,
+    structure.definitionList,
+    structure.list,
+    tables.tableDuplicateName,
+    tables.tableFakeCaption,
+    tables.thHasDataCells,
+    textAlternatives.documentTitle,
+    textAlternatives.frameTitleUnique,
+    textAlternatives.frameTitle,
+    textAlternatives.videoCaption,
+    timeAndMedia.audioCaption
+  ],
+  /**
+   * These rules can be resolved by changing content in
+   * either the node body or its attributes
+   */
+  requiresAttrsOrChildren: [
+    aria.ariaCommandName,
+    aria.ariaDialogName,
+    aria.ariaInputFieldName,
+    aria.ariaMeterName,
+    aria.ariaProgressbarName,
+    aria.ariaToggleFieldName,
+    aria.ariaTooltipName,
+    aria.ariaTreeitemName,
+    nameRoleValue.inputButtonName,
+    nameRoleValue.linkName
+  ],
+  /**
+   * These rules cannot be supported until multiple files
+   * are analyzed at once. For now they are ignored.
+   */
+  requiresParent: [
+    aria.ariaRequiredParent,
+    forms.label,
+    forms.labelTitleOnly,
+    forms.selectName,
+    keyboard.bypass,
+    keyboard.nestedInteractive,
+    keyboard.region,
+    semantics.headingOrder,
+    semantics.landmarkBannerIsTopLevel,
+    semantics.landmarkComplementaryIsTopLevel,
+    semantics.landmarkContentinfoIsTopLevel,
+    semantics.landmarkMainIsTopLevel,
+    semantics.landmarkOneMain,
+    semantics.pageHasHeadingOne,
+    structure.dlitem,
+    structure.listitem,
+    tables.tdHasHeader,
+    tables.tdHeadersAttr
+  ],
+  /**
+   * These rules should not be enforced to all users of
+   * the official Marko language server.
+   */
+  blacklist: [structure.frameTested, parsing.duplicateId],
+  /**
+   * These are rules that cannot currently be validated, either
+   * because of limitations with JSDom + axe-core or with the
+   * current implementation of the language server.
+   */
+  cannotValidate: [
+    keyboard.scrollableRegionFocusable,
+    semantics.pAsHeading,
+    structure.avoidInlineSpacing,
+    structure.cssOrientationLock,
+    structure.hiddenContent
+  ]
+};
+var separated_rules_default = rules;
+
+// src/service/html/index.ts
+var extractCache = /* @__PURE__ */ new WeakMap();
+var HTMLService = {
+  commands: {
+    "$/showHtmlOutput": async (uri) => {
+      const doc = get(uri);
+      if (!doc)
+        return;
+      const { extracted } = extract(doc);
+      return {
+        language: "html",
+        content: extracted.toString()
+      };
+    }
+  },
+  async doValidate(doc) {
+    const { extracted, nodeDetails } = extract(doc);
+    const jsdom = new JSDOM(extracted.toString(), {
+      includeNodeLocations: true
+    });
+    const { documentElement } = jsdom.window.document;
+    const getViolationNodes = async (runOnly) => (await axe.run(documentElement, {
+      runOnly,
+      rules: {
+        "color-contrast": { enabled: false }
+      },
+      resultTypes: ["violations"],
+      elementRef: true
+    })).violations.flatMap(
+      ({ nodes, id }) => nodes.map((node) => ({ ...node, ruleId: id }))
+    );
+    const release = await acquireMutexLock();
+    const violations = await getViolationNodes(separated_rules_default.alwaysAllowed);
+    const requiresAttrs = await getViolationNodes(separated_rules_default.requiresAttrs);
+    const requiresChildren = await getViolationNodes(separated_rules_default.requiresChildren);
+    const requiresAttrsOrChildren = await getViolationNodes(
+      separated_rules_default.requiresAttrsOrChildren
+    );
+    release();
+    violations.push(
+      ...requiresAttrs.filter(
+        ({ element }) => (element == null ? void 0 : element.dataset.markoNodeId) && !nodeDetails[element.dataset.markoNodeId].hasDynamicAttrs
+      )
+    );
+    violations.push(
+      ...requiresChildren.filter(
+        ({ element }) => (element == null ? void 0 : element.dataset.markoNodeId) && !nodeDetails[element.dataset.markoNodeId].hasDynamicBody
+      )
+    );
+    violations.push(
+      ...requiresAttrsOrChildren.filter(
+        ({ element }) => (element == null ? void 0 : element.dataset.markoNodeId) && !nodeDetails[element.dataset.markoNodeId].hasDynamicAttrs && !nodeDetails[element.dataset.markoNodeId].hasDynamicBody
+      )
+    );
+    return violations.flatMap((result) => {
+      const { element } = result;
+      if (!element)
+        return [];
+      const generatedLoc = jsdom.nodeLocation(element);
+      if (!generatedLoc)
+        return [];
+      const sourceRange = extracted.sourceLocationAt(
+        generatedLoc.startOffset + 1,
+        generatedLoc.startOffset + 1 + element.tagName.length
+      );
+      if (!sourceRange)
+        return [];
+      return [
+        {
+          range: sourceRange,
+          severity: 3,
+          source: `axe-core(${result.ruleId})`,
+          message: result.failureSummary ?? "unknown accessibility issue"
+        }
+      ];
+    });
+  }
+};
+function extract(doc) {
+  const { parsed } = getMarkoFile(doc);
+  let cached = extractCache.get(parsed);
+  if (!cached) {
+    cached = extractHTML(parsed);
+    extractCache.set(parsed, cached);
+  }
+  return cached;
+}
+var lock;
+async function acquireMutexLock() {
+  const currLock = lock;
+  let resolve;
+  lock = new Promise((_) => resolve = _);
+  await currLock;
+  return resolve;
+}
+var html_default = HTMLService;
+
 // src/service/marko/complete/index.ts
 import { NodeType as NodeType3 } from "@marko/language-tools";
 
@@ -1289,7 +2038,7 @@ Project3.setDefaultTypePaths({
   internalTypesFile: path6.join(__dirname, "marko.internal.d.ts"),
   markoTypesFile: path6.join(__dirname, "marko.runtime.d.ts")
 });
-function patch(ts2, configFile, extractCache2, resolutionCache, host, ps) {
+function patch(ts2, configFile, extractCache3, resolutionCache, host, ps) {
   var _a, _b, _c;
   const processors = Processors.create({
     ts: ts2,
@@ -1328,7 +2077,7 @@ function patch(ts2, configFile, extractCache2, resolutionCache, host, ps) {
   host.getScriptSnapshot = (fileName) => {
     const processor = getProcessor(fileName);
     if (processor) {
-      let cached = extractCache2.get(fileName);
+      let cached = extractCache3.get(fileName);
       if (!cached) {
         const code = host.readFile(fileName, "utf-8") || "";
         try {
@@ -1338,7 +2087,7 @@ function patch(ts2, configFile, extractCache2, resolutionCache, host, ps) {
           cached = { snapshot: ts2.ScriptSnapshot.fromString("") };
         }
         trackFile(fileName);
-        extractCache2.set(fileName, cached);
+        extractCache3.set(fileName, cached);
       }
       return cached.snapshot;
     }
@@ -1615,7 +2364,7 @@ function escapeBackTicks(text) {
 
 // src/service/script/index.ts
 var IGNORE_DIAG_REG = /^(?:(?:Expression|Identifier|['"][^\w]['"]) expected|Invalid character)\b/i;
-var extractCache = /* @__PURE__ */ new Map();
+var extractCache2 = /* @__PURE__ */ new Map();
 var snapshotCache = /* @__PURE__ */ new Map();
 var insertModuleStatementLocCache = /* @__PURE__ */ new WeakMap();
 var markoFileReg = /\.marko$/;
@@ -1693,10 +2442,10 @@ var ScriptService = {
     onFileChange((doc) => {
       if (doc) {
         const filename = getFSPath(doc);
-        extractCache.delete(filename);
+        extractCache2.delete(filename);
         snapshotCache.delete(filename);
       } else {
-        extractCache.clear();
+        extractCache2.clear();
         snapshotCache.clear();
       }
     });
@@ -2158,7 +2907,7 @@ function getTSProject(docFsPath) {
   const host = patch(
     ts,
     configFile,
-    extractCache,
+    extractCache2,
     resolutionCache,
     {
       getNewLine() {
@@ -2814,7 +3563,7 @@ function isTextEdit(edit) {
 
 // src/service/index.ts
 var REG_MARKDOWN_CHARS = /[\\`*_{}[\]<>()#+.!|-]/g;
-var plugins = [marko_default, ScriptService, StyleSheetService];
+var plugins = [marko_default, ScriptService, StyleSheetService, html_default];
 var service = {
   commands: Object.assign({}, ...plugins.map(({ commands }) => commands)),
   async initialize(params) {
@@ -3157,7 +3906,7 @@ console.error = (...args) => {
 process.on("uncaughtException", console.error);
 process.on("unhandledRejection", console.error);
 connection3.onInitialize(async (params) => {
-  setup3(connection3);
+  setup2(connection3);
   await service.initialize(params);
   return {
     capabilities: {
@@ -3199,9 +3948,23 @@ connection3.onInitialize(async (params) => {
     }
   };
 });
-setup2(connection3);
-onConfigChange(validateDocs);
 setup(connection3);
+onConfigChange(validateDocs);
+connection3.onDidOpenTextDocument(async (params) => {
+  doOpen(params);
+  const doc = get(params.textDocument.uri);
+  if (doc) {
+    const diagnostics = await service.doValidate(doc) || [];
+    prevDiags.set(doc, diagnostics);
+    connection3.sendDiagnostics({
+      uri: doc.uri,
+      diagnostics
+    });
+  }
+});
+connection3.onDidChangeTextDocument(doChange);
+connection3.onDidCloseTextDocument(doClose);
+connection3.onDidChangeWatchedFiles(doChangeWatchedFiles);
 onFileChange((changeDoc) => {
   if (changeDoc) {
     queueDiagnostic();