/g, "")
+ .replace(/<\/code>[ \r\n]*<\/pre>/g, " ");
+ }, 0)
+ }
+ // childrenAvailableCallback() {
+ // let converted = marked.parse(this.innerHTML);
+ // this.innerHTML = converted
+ // .replace(/<(\/?)ul>/g, "<$1bx-unordered-list>")
+ // .replace(/<(\/?)li>/g, "<$1bx-list-item>")
+ // .replace(/[ \r\n]*/g, "")
+ // .replace(/<\/code>[ \r\n]*<\/pre>/g, " ");
+ // }
+ }
+);
+
+customElements.define(
+ "code-snippet",
+ class extends HTMLBaseElement {
+ childrenAvailableCallback() {
+ let oldCode = this.innerHTML;
+ this.innerHTML = "";
+ // const shadowRoot = this.attachShadow({mode: 'open'});
+ const shadowRoot = this;
+ let snip = document.createElement("bx-code-snippet");
+ snip.setAttribute("type", "multi");
+ snip.setAttribute("color-scheme", "light");
+ snip.innerHTML = oldCode.replace(/ {
+ let groupMsg = typeof RULE_MESSAGES !== "undefined" && (RULE_MESSAGES["en-US"].group || RULE_MESSAGES["en-US"][0]) || "";
+ groupMsg = groupMsg.replace(/&/g, "&").replace(//g, ">");
+ document.querySelector("#groupLabel").innerHTML = groupMsg;
+ let ruleInfo;
+ if (window.location.search && window.location.search.length > 0) {
+ const searchParams = new URLSearchParams(window.location.search);
+ ruleInfo = JSON.parse(decodeURIComponent(searchParams.get("issue")));
+ } else if (window.location.hash && window.location.hash.length > 0) {
+ ruleInfo = JSON.parse(decodeURIComponent(window.location.hash.substring(1)));
+ }
+ if (ruleInfo) {
+ if (ruleInfo.message) {
+ let ruleMessage = ruleInfo.message.replace(/\{(\d+)\}/g, (matchedStr, matchedNum, matchedIndex) => msgArgs[matchedNum]);
+ document.querySelector("#ruleMessage").innerHTML = ruleMessage.replace(/&/g, "&").replace(//g, ">")
+ }
+ setTimeout(() => {
+ if (ruleInfo.snippet) {
+ let snip = ruleInfo.snippet;
+ snip = snip.replace(/( [a-zA-Z-]+="[^"]*")/g, "\n $1");
+ let snipElem = document.createElement("code-snippet");
+ for (let line of snip.split("\n")) {
+ snipElem.appendChild(document.createTextNode(line+"\n"));
+ }
+ let locSnippet = document.querySelector("#locSnippet");
+ locSnippet.innerHTML = `Element location
`;
+ locSnippet.appendChild(snipElem);
+ }
+ }, 0);
+ if (ruleInfo.value) {
+ let value = ruleInfo.value;
+ const val = valueMap[value[0]][value[1]];
+ let icon = "";
+ if (val === "Violation") icon = `
`;
+ if (val === "Needs review") icon = `
`;
+ if (val === "Recommendation") icon = `
`;
+ document.querySelector("#locLevel").innerHTML = `${icon} ${val}`;
+ }
+ if (RULE_ID) {
+ document.querySelector("#ruleInfo").innerHTML = `Rule ID: ${RULE_ID}${ruleInfo.reasonId ? `
Reason ID: ${ruleInfo.reasonId}
` : ""}`;
+ }
+ }
+})
+
diff --git a/rule-server/src/static/archives/2022.03.12/doc/en-US/HAAC_Accesskey_NeedLabel.html b/rule-server/src/static/archives/2022.03.12/doc/en-US/HAAC_Accesskey_NeedLabel.html
new file mode 100644
index 000000000..8f5cce0f0
--- /dev/null
+++ b/rule-server/src/static/archives/2022.03.12/doc/en-US/HAAC_Accesskey_NeedLabel.html
@@ -0,0 +1,90 @@
+
+
+ HAAC_Accesskey_NeedLabel - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_ActiveDescendantCheck - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Application_Role_Text - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Aria_ErrorMessage - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Aria_ImgAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Aria_Or_HTML5_Attr - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Aria_SvgAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Audio_Video_Trigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_BackgroundImg_HasTextOrTitle - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Canvas - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Figure_label - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Img_UsemapAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Input_Placeholder - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_List_Group_ListItem - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Media_DocumentTrigger2 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+HAAC_Video_HasNoTrack - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+IBMA_Color_Contrast_WCAG2AA - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+IBMA_Color_Contrast_WCAG2AA_PV - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+IBMA_Focus_MultiTab - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+IBMA_Focus_Tabbable - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Blink_CSSTrigger1 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Block_ShouldBeHeading - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Blockquote_HasCite - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Blockquote_WrapsTextQuote - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Elem_EventMouseAndKey - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Elem_UniqueId - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Embed_AutoStart - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Embed_HasAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Font_ColorInForm - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Form_ChangeEmpty - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Header_HasContent - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Headers_FewWords - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Html_SkipNav - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Img_AltCommonMisuse - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Img_LongDescription2 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Img_UsemapValid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Label_UniqueFor - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_List_Misuse - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_List_UseMarkup - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Marquee_Trigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Media_AltBrief - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Media_AudioTrigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Media_AudioVideoAltFilename - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Media_VideoObjectTrigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Media_VideoReferenceTrigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Meta_Refresh - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Pre_ASCIIArt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Script_OnclickHTML1 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Script_OnclickHTML2 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Style_BackgroundImage - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Style_ColorSemantics1 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Style_HinderFocus1 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Style_Trigger2 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Table_DataHeadingsAria - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Table_LayoutTrigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Text_SensoryReference - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+RPT_Title_Valid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ApplicationLandmarkLabel - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ComplementaryLandmarkLabel_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ComplementaryRequiredLabel_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ContentinfoWithNoMain_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_EmptyPropertyValue - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_EventHandlerMissingRole_Native_Host_Sematics - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_InvalidTabindexForActivedescendant - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MissingFocusableChild - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MissingKeyboardHandler - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleApplicationLandmarks - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleArticleRoles_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleBannerLandmarks_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleComplementaryLandmarks_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleContentinfoInSiblingSet_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleContentinfoLandmarks_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleDocumentRoles - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleFormLandmarks_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleMainsRequireLabel_Implicit_2 - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleMainsVisibleLabel_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleNavigationLandmarks_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleRegionsUniqueLabel_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleSearchLandmarks - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_MultipleToolbarUniqueLabel - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_OneBannerInSiblingSet_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_OrphanedContent_Native_Host_Sematics - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_RegionLabel_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_RequiredChildren_Native_Host_Sematics - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_RequiredParent_Native_Host_Sematics - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_RequiredProperties - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ValidIdRef - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ValidProperty - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ValidPropertyValue - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_ValidRole - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Rpt_Aria_WidgetLabels_Implicit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Caption_HasContent - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Caption_InTable - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Elem_DirValid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Frame_SrcHtml - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Label_HasContent - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Noembed_HasContent - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Valerie_Table_DataCellRelationships - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_A_HasText - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_A_TargetAndText - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Applet_HasAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Area_HasAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Blink_AlwaysTrigger - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Body_FirstAContainsSkipText_Native_Host_Sematics - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Body_FirstASkips_Native_Host_Sematics - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Doc_HasTitle - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Elem_Lang_Valid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Elem_UniqueAccessKey - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Embed_HasNoEmbed - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Fieldset_HasLegend - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Form_HasSubmit - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Form_TargetAndText - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Frame_HasTitle - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Html_HasLang - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Img_HasAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Img_LinkTextNotRedundant - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Img_PresentationImgHasNonNullAlt - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Img_TitleEmptyWhenAltNull - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_ExplicitLabel - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_ExplicitLabelImage - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_HasOnchange - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_InFieldSet - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_LabelAfter - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_LabelBefore - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_RadioChkInFieldSet - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Input_VisibleLabel - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Label_RefValid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Meta_RedirectZero - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Object_HasText - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Script_FocusBlurs - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Select_HasOptGroup - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Select_NoChangeAction - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Style_BeforeAfter - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Table_CapSummRedundant - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Table_Scope_Valid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Table_Structure - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Text_Emoticons - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG20_Text_LetterSpacing - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG21_Input_Autocomplete - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG21_Label_Accessible - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+WCAG21_Style_Viewport - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+aria_hidden_focus_misuse - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+aria_semantics_attribute - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+aria_semantics_role - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+combobox_active_descendant - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+combobox_autocomplete - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+combobox_focusable_elements - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+combobox_haspopup - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+combobox_popup_reference - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+combobox_version - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+element_attribute_deprecated - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+group_withInputs_hasName - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+input_haspopup_invalid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+landmark_name_unique - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+meta_viewport_zoom - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+style_hover_persistent - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+table_aria_descendants - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+table_headers_ref_valid - Accessibility Checker Help
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+![]()
with alt="" allows only aria-hidden
+ if (tagName === "img" &&
+ ruleContext.hasAttribute("alt") &&
+ ruleContext.getAttribute("alt").trim() === "") {
+ RPTUtil.concatUniqueArrayItemList(["aria-hidden"], allowedAttributes);
+ }
+ }
+ }
+ // adding the specified role properties to the allowed attribute list
+ for (var i = 0; permittedRoles !== null && i < permittedRoles.length; i++) {
+ var roleProperties = ARIADefinitions_1.ARIADefinitions.designPatterns[permittedRoles[i]];
+ if (roleProperties !== null && roleProperties !== undefined) {
+ var properties_3 = roleProperties.props; // allowed properties
+ RPTUtil.concatUniqueArrayItemList(properties_3, allowedAttributes);
+ properties_3 = RPTUtil.getRoleRequiredProperties(permittedRoles[i], ruleContext); // required properties
+ RPTUtil.concatUniqueArrayItemList(properties_3, allowedAttributes);
+ // special case for separator
+ if (permittedRoles[i] === "separator" && RPTUtil.isFocusable(ruleContext)) {
+ RPTUtil.concatUniqueArrayItemList(["aria-disabled", "aria-valuemax", "aria-valuemin", "aria-valuetext"], allowedAttributes);
+ }
+ }
+ }
+ // ignore aria-level, aria-setsize or aria-posinset if "row" is not in treegrid
+ if (permittedRoles.includes("row") && RPTUtil.getAncestorWithRole(ruleContext, "treegrid", true) == null) {
+ var index = -1;
+ if ((index = allowedAttributes.indexOf("aria-level")) > -1)
+ allowedAttributes.splice(index, 1);
+ if ((index = allowedAttributes.indexOf("aria-setsize")) > -1)
+ allowedAttributes.splice(index, 1);
+ if ((index = allowedAttributes.indexOf("aria-posinset")) > -1)
+ allowedAttributes.splice(index, 1);
+ }
+ return allowedAttributes;
+ };
+ RPTUtil.CSS = function (element) {
+ var styleText = "";
+ if (element === null)
+ return [];
+ if (element.IBM_CSS_THB)
+ return element.IBM_CSS_THB;
+ var nodeName = element.nodeName.toLowerCase();
+ if (nodeName === "style") {
+ styleText = RPTUtil.getInnerText(element);
+ }
+ else if (element.hasAttribute("style")) {
+ styleText = element.getAttribute("style");
+ }
+ else
+ return [];
+ if (styleText === null || styleText.trim().length === 0)
+ return [];
+ //remove comment blocks
+ var re = /(\/\*+(?:(?:(?:[^\*])+)|(?:[\*]+(?!\/)))[*]+\/)|\/\/.*/g;
+ var subst = ' ';
+ styleText = styleText.replace(re, subst);
+ // Find all "key : val;" pairs with various whitespace inbetween
+ var rKeyVals = /\s*([^:\s]+)\s*:\s*([^;$}]+)\s*(;|$)/g;
+ // Find all "selector { csskeyvals } with various whitespace inbetween
+ var rSelectors = /\s*([^{]*){([^}]*)}/g;
+ if (styleText.indexOf("{") === -1) {
+ var keyVals = {};
+ var m = void 0;
+ while ((m = rKeyVals.exec(styleText)) != null) {
+ keyVals[m[1]] = m[2].trim().toLowerCase();
+ }
+ var retVal = [{
+ selector: null,
+ values: keyVals
+ }];
+ element.IBM_CSS_THB = retVal;
+ return retVal;
+ }
+ else {
+ var retVal = [];
+ var m = void 0;
+ var m2 = void 0;
+ while ((m = rSelectors.exec(styleText)) != null) {
+ var keyVals = {};
+ var selKey = m[1];
+ var selVal = m[2];
+ while ((m2 = rKeyVals.exec(selVal)) != null) {
+ keyVals[m2[1]] = m2[2].trim().toLowerCase();
+ }
+ retVal.push({
+ selector: selKey,
+ values: keyVals
+ });
+ }
+ element.IBM_CSS_THB = retVal;
+ return retVal;
+ }
+ };
+ /**
+ * This function is responsible for checking if the node that is provied is
+ * visible or not. Following is how the check is performed:
+ * 1. Check if the current node is hidden with the following options:
+ * CSS --> dislay: none
+ * CSS --> visibility: hidden
+ * attribute --> hidden
+ * 2. Check if the any of the current nodes parents are hidden with the same
+ * options listed in 1.
+ *
+ * Note: If either current node or any of the parent nodes are hidden then this
+ * function will return false (node is not visible).
+ *
+ * @parm {element} node The node which should be checked if it is visible or not.
+ * @return {bool} false if the node is NOT visible, true otherwise
+ *
+ * @memberOf RPTUtil
+ */
+ RPTUtil.isNodeVisible = function (node) {
+ // Set PT_NODE_HIDDEN to false for all the nodes, before the check and this will be changed to
+ // true when we detect that the node is hidden. We have to set it to false so that we know
+ // the rules has already been checked.
+ RPTUtil.setCache(node, "PT_NODE_HIDDEN", RPTUtil.getCache(node, "PT_NODE_HIDDEN", false));
+ // Check the nodeType if this node, if this node is a text node then
+ // we get the parentnode and set that as the node as a text nodes,
+ // visibility is directly related to the parent node.
+ if (node.nodeType === 3) {
+ node = DOMUtil_1.DOMUtil.parentNode(node);
+ }
+ // We should only allow nodeType element, and TextNode all other nodesTypes
+ // we can return the visibility as visible.
+ // Following nodes will be returned as visable by default, since we can not
+ // actually change their visibility.
+ // Node.PROCESSING_INSTRUCTION_NODE --> 7
+ // Node.COMMENT_NODE --> 8
+ // 9 /* Node.DOCUMENT_NODE */ --> 9
+ // Node.DOCUMENT_TYPE_NODE --> 10
+ // Node.DOCUMENT_FRAGMENT_NODE --> 11
+ if (node.nodeType !== 1) {
+ return true;
+ }
+ // Make sure that the ownerDocument is present before moving forward
+ // in detecting if the node is visible or not. In the case that ownerDocument
+ // does not exist then we simply return node is visible by default.
+ if (!node.ownerDocument) {
+ return true;
+ }
+ // Variable Declaration
+ var compStyle;
+ var nodeName = node.nodeName.toLowerCase();
+ // In the case this node is a script, link or style node, right away return node is visible
+ // because scripts, links and style nodes can not be hidden by HTML attribute or CSS or are hidden by default. But we want to scan
+ // the elements everytime as they render content still which is still visible to users.
+ // script --> script elements have display: none by default
+ // link --> link elements have display: none by default, but the actually CSS script is still executed so we have to
+ // mark this element as visible at all times.
+ // style --> style elements have display: none by default, but the actually CSS script is still executed so we have to
+ // mark this element as visible at all times.
+ if (RPTUtil.hiddenByDefaultElements != null && RPTUtil.hiddenByDefaultElements != undefined && RPTUtil.hiddenByDefaultElements.indexOf(nodeName) > -1) {
+ return true;
+ }
+ // Check if this node is visible, we check couple of CSS properties and hidden attribute.
+ // area, param and audio elements we do not check if they are hidden as it does not apply to them.
+ // Check the unhideableElements array which is part of the rules, to check if this element is allowed to be hidden or not
+ // in the case that the element is part of the unhideableElements array then we do not run the hidden check on this element,
+ // and go stright to the parent node.
+ // Array check elements like:
+ // area --> area element is part of a map element and it can not be hidden because it is used to
+ // make an certian parts of an map interactive.
+ // param --> element can only be part of object elment and it cannot be hidden directly, it
+ // can only be hidden if the parent is hidden.
+ // audio --> If this element is hidden it will still play the music, so we should still trigger
+ // violations for this element.
+ // In the case that unhideableElements array is not defined then we just scan all elements and do no filtering at all.
+ if (RPTUtil.unhideableElements === null || RPTUtil.unhideableElements === undefined || RPTUtil.unhideableElements.indexOf(nodeName) === -1) {
+ // Check if defaultView exists for this node, if it does then use this to run the getComputedStyle
+ // function to get the CSS style for the node.
+ if (node.ownerDocument.defaultView) {
+ // Run the getComputedStyle on this node to fetch the CSS compuation of the node
+ compStyle = node.ownerDocument.defaultView.getComputedStyle(node, null);
+ }
+ // In the case that defaultView does not exists return true to identify that this
+ // node is visible, because were not able to detect if it was not.
+ else {
+ return true;
+ }
+ // Get the hidden element property and hidden attribute
+ var hiddenAttribute = node.getAttribute("hidden");
+ var hiddenPropertyCustom = RPTUtil.getCache(node, "PT_NODE_HIDDEN", undefined);
+ // To get the hidden property we need to perform a special check as in some cases the hidden property will not be
+ // a boolean, for theses cases we set it to false as we are not able to determine the true hidden condition.
+ // The reason for this is because form elements are able to perform an override, so when we have id="hidden" for an element
+ // which is under the form element then, node.hidden gives the element/list of elements which have id="hidden". Refer to
+ // mozilla bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1267356
+ var hiddenProperty = typeof node.hidden === "boolean" ? node.hidden : false;
+ // If compStyle object is empty, node does't have hidden property, node does't have hidden attribute and does't have custom PT
+ // hidden property then we can just return true (node visible) at this point.
+ if (!compStyle &&
+ !hiddenProperty && // this covers false, null, or undefined
+ (hiddenAttribute === null || hiddenAttribute === undefined) &&
+ !hiddenPropertyCustom // This covers false, null or undefined
+ ) {
+ return true;
+ }
+ // In the case that the compStyle is defined we check the following:
+ // CSS style display set to none
+ // CSS style visibility set to hidden
+ // Note: For this property since it is inherited, need to skip the check on parents as
+ // the parent can have hidden but the child can be visible. So we only check this property
+ // on child elements/elements that are passed to this function the first time.
+ // node hidden property set (node.hidden)
+ // node attribute hidden set (to any value)
+ // node custom hidden property ser (node.PT_NODE_HIDDEN)
+ // If any of the above conditions are true then we return false as this element is not visible
+ if ((compStyle !== null && ((compStyle.getPropertyValue('display') === 'none' ||
+ (!RPTUtil.getCache(node, "Visibility_Check_Parent", null) && compStyle.getPropertyValue('visibility') === 'hidden'))) ||
+ (compStyle.getPropertyValue('display') !== 'block' && (hiddenProperty || hiddenAttribute != null || hiddenPropertyCustom)))) {
+ // Set a custom expandos property on the the node to identify that it is hidden, so that we can uses
+ // use this in the rules to determine if the node is hidden or not, if we need to.
+ // Use expandos property instead of a hash map which stores the elements, adding/checking expandos
+ // properties is a lot faster performance whise. For Hash map we need to store based on xpath, and to calculate
+ // xpath it is more performance impact.
+ RPTUtil.setCache(node, "PT_NODE_HIDDEN", true);
+ return false;
+ }
+ }
+ // Get the parentNode for this node, becuase we have to check all parents to make sure they do not have
+ // the hidden CSS, property or attribute. Only keep checking until we are all the way back to the parentNode
+ // element.
+ var parentElement = DOMUtil_1.DOMUtil.parentNode(node);
+ // If the parent node exists and the nodetype is element (1), then run recursive call to perform the check
+ // all the way up to the very parent node. Use recursive call here instead of a while loop so that we do not
+ // have to duplicate the logic for checking if the node is visible or not for all the parents starting with
+ // child node.
+ if (parentElement != null && parentElement.nodeType === 1) {
+ // When we have a parent element going through the isNodeVisible function we have to mark it as such
+ // so that in the function we can skip checking visibility: hidden for parent elements since visibility: hidden
+ // is inherited, which allows a child to have a different setting then the child. This property only needs to be checked
+ // once for the first element that is passed down and that is all. Ignore it for all the parents that we iterate over.
+ RPTUtil.setCache(parentElement, "Visibility_Check_Parent", true);
+ // Check upwards recursively, and save the results in an variable
+ var nodeVisible = RPTUtil.isNodeVisible(parentElement);
+ // If the node is found to not be visible then add the custom PT_NODE_HIDDEN to true.
+ // so that we can use this in the rules.
+ if (!nodeVisible) {
+ RPTUtil.setCache(node, "PT_NODE_HIDDEN", true);
+ }
+ // Check upwards recursively
+ return nodeVisible;
+ }
+ // Return true (node is visible)
+ return true;
+ };
+ /**
+ * return true if the node or its ancester is natively hidden or aria-hidden = 'true'
+ * @param node
+ */
+ RPTUtil.isNodeHiddenFromAT = function (node) {
+ if (!RPTUtil.isNodeVisible(node) || node.getAttribute("aria-hidden") === 'true')
+ return true;
+ var ancestor = RPTUtil.getAncestorWithAttribute(node, "aria-hidden", "true");
+ if (ancestor)
+ return true;
+ return false;
+ };
+ RPTUtil.getControlOfLabel = function (node) {
+ // Handle the easy case of label -> for
+ var labelAncestor = RPTUtil.getAncestor(node, "label");
+ if (labelAncestor) {
+ if (labelAncestor.hasAttribute("for")) {
+ return fragment_1.FragmentUtil.getById(node, labelAncestor.getAttribute("for"));
+ }
+ }
+ // Create a dictionary containing ids of parent nodes
+ var idDict = {};
+ var parentWalk = node;
+ while (parentWalk) {
+ if (parentWalk.nodeType === 1 /* Node.ELEMENT_NODE */) {
+ var ancestor = parentWalk;
+ if (ancestor.hasAttribute("id")) {
+ idDict[ancestor.getAttribute("id")] = true;
+ }
+ }
+ parentWalk = DOMUtil_1.DOMUtil.parentNode(parentWalk);
+ }
+ // Iterate through controls that use aria-labelledby and see if any of them reference one of my ancestor ids
+ var inputsUsingLabelledBy = node.ownerDocument.querySelectorAll("*[aria-labelledby]");
+ for (var idx = 0; idx < inputsUsingLabelledBy.length; ++idx) {
+ var inputUsingLabelledBy = inputsUsingLabelledBy[idx];
+ var ariaLabelledBy = inputUsingLabelledBy.getAttribute("aria-labelledby");
+ var sp = ariaLabelledBy.split(" ");
+ for (var _i = 0, sp_1 = sp; _i < sp_1.length; _i++) {
+ var id = sp_1[_i];
+ if (id in idDict) {
+ return inputUsingLabelledBy;
+ }
+ }
+ }
+ // Find the cases where we're within an aria labelledby
+ return null;
+ };
+ /**
+ * This function is responsible for checking if the node that is provied is
+ * disabled or not. Following is how the check is performed:
+ * 1. Check if the current node is disabled with the following options:
+ * attribute --> disabled
+ * Also needs to be "button", "input", "select", "textarea", "optgroup", "option",
+ * "menuitem", "fieldset" nodes (in array elementsAllowedDisabled)
+ * attribute --> aria-disabled="true"
+ * 2. Check if any of the current nodes parents are disabled with the same
+ * options listed in 1.
+ *
+ * Note: If either current node or any of the parent nodes are disabled then this
+ * function will return true (node is disabled).
+ *
+ * @parm {HTMLElement} node - The node which should be checked if it is disabled or not.
+ * @return {bool} true if the node is disabled, false otherwise
+ *
+ * @memberOf RPTUtil
+ */
+ RPTUtil.isNodeDisabled = function (node) {
+ // Set PT_NODE_DISABLED to false for all the nodes, before the check and this will be changed to
+ // true when we detect that the node is disabled. We have to set it to false so that we know
+ // the node has already been checked. Only set it to false if the setting is undefined or null
+ // as if it is defined we do not wnat to reset it. As if it is true then we should make use of it
+ // to speed up the check.
+ var PT_NODE_DISABLED = RPTUtil.getCache(node, "PT_NODE_DISABLED", false);
+ // Check the nodeType of this node, if this node is a text node then
+ // we get the parentnode and set that as the node as a text nodes,
+ // disabled is directly related to the parent node.
+ if (node.nodeType === 3) {
+ node = DOMUtil_1.DOMUtil.parentNode(node);
+ }
+ // Variable Declaration
+ var nodeName = node.nodeName.toLowerCase();
+ // Get the disabled element property, disabled and aria-disabled attribute and check that it is true
+ var disabledAttribute = node.hasAttribute("disabled");
+ var disabledPropertyCustom = PT_NODE_DISABLED;
+ var ariaDisabledAttribute = node.hasAttribute('aria-disabled') && node.getAttribute("aria-disabled") === 'true';
+ // If this node has disabled attribute and the node allows disabled attribute, then return true.
+ // Disabled attribute is only allowed on "button", "input", "select", "textarea", "optgroup", "option", "menuitem", "fieldset"
+ // In the case aria-disabled is set to true, then also return true
+ if (disabledPropertyCustom || (disabledAttribute && ARIADefinitions_1.ARIADefinitions.elementsAllowedDisabled.indexOf(nodeName) > -1) || ariaDisabledAttribute) {
+ PT_NODE_DISABLED = true;
+ RPTUtil.setCache(node, "PT_NODE_DISABLED", PT_NODE_DISABLED);
+ return true;
+ }
+ // Get the parentNode for this node, becuase we have to check all parents to make sure they do not have
+ // disabled attribute. Only keep checking until we are all the way back to the parentNode
+ // element.
+ var parentElement = DOMUtil_1.DOMUtil.parentNode(node);
+ // If the parent node exists and the nodetype is element (1), then run recursive call to perform the check
+ // all the way up to the very parent node. Use recursive call here instead of a while loop so that we do not
+ // have to duplicate the logic for checking if the node is disabled or not for all the parents starting with
+ // child node.
+ if (parentElement != null && parentElement.nodeType === 1) {
+ // Check upwards recursively, and save the results in an variable
+ var nodeDisabled = RPTUtil.isNodeDisabled(parentElement);
+ // If the node is found to be disabled then add the custom PT_NODE_DISABLED to true.
+ // so that we can use this next time, to quickly determine if node is disabled or not.
+ // This is extra percaution, the isNodeDisabled function already sets this.
+ if (nodeDisabled) {
+ PT_NODE_DISABLED = true;
+ }
+ // Check upwards recursively
+ RPTUtil.setCache(node, "PT_NODE_DISABLED", PT_NODE_DISABLED);
+ return nodeDisabled;
+ }
+ // Return false (node is not disabled)
+ return false;
+ };
+ /**
+ * This function is responsible for determine if hidden content should be checked
+ * in rules.
+ *
+ * @parm {element} node - A node so that the document can be accessed to check for the
+ * option. Can be document element or a simple node element.
+ * @return {bool} true if hidden content should be checked, false otherwise
+ *
+ * @memberOf RPTUtil
+ */
+ RPTUtil.shouldCheckHiddenContent = function (node) {
+ return false;
+ };
+ /**
+ * This function is responsible for determining if node should be skipped from checking or not, based
+ * on the Check Hidden Content settings and if the node is visible or not.
+ *
+ * @parm {element} node - Node to check if it is visible or not based on the Check Hidden Content
+ * setting.
+ *
+ * @return {bool} true if node should be skipped, false otherwise
+ *
+ * @memberOf RPTUtil
+ */
+ RPTUtil.shouldNodeBeSkippedHidden = function (node) {
+ // Following are the steps that are executed at this stage to determine if the node should be classified as hidden
+ // or not.
+ // 1. Only run isNodeVisible check if hidden content should NOT be checked. In the case that hidden content is to,
+ // be scanned then we can just scan everything as normal. In the case that the current node is hidden we
+ // return true to identify that the node should not be scanned/added to any hash/array.
+ //
+ // Note: The if conditions uses short-circuiting so if the first condition is not true it will not check the next one,
+ // so on and so forth.
+ if (!RPTUtil.shouldCheckHiddenContent(node) && !RPTUtil.isNodeVisible(node)) {
+ return true;
+ }
+ return false;
+ };
+ RPTUtil.isfocusableByDefault = function (node) {
+ var focusableElements = ['input', 'select', 'button', 'textarea', 'option', 'area'];
+ if (node.nodeName.toLowerCase() === "a" && RPTUtil.hasAttribute(node, 'href'))
+ return true;
+ if (node.nodeName.toLowerCase() === "area" && RPTUtil.hasAttribute(node, 'href'))
+ return true;
+ if (focusableElements.indexOf(node.nodeName.toLowerCase()) != -1)
+ return true;
+ return false;
+ };
+ /**
+ * This function check if a non-tabable node has valid tabable content.
+ * If it is tabable (the tabindex is not speicified or is not -1), returns false;
+ * If it is non-tabable, but a child is tabable and does not have element content, returns false;
+ * Otherwise, returns true.
+ */
+ RPTUtil.nonTabableChildCheck = function (element) {
+ if (!element.hasAttribute("tabindex") ||
+ (parseInt(element.getAttribute("tabindex")) != -1)) {
+ return false;
+ }
+ var nw = new NodeWalker(element);
+ while (nw.nextNode()) {
+ var child = nw.elem();
+ if (child === null) { // Text node. usually is a cartridge return.
+ continue;
+ }
+ if (child.hasAttribute("tabindex") &&
+ (parseInt(child.getAttribute("tabindex")) != -1) &&
+ !RPTUtil.hasInnerContent(child)) {
+ return false;
+ }
+ }
+ return true;
+ };
+ // Rewrite the color object to account for alpha
+ RPTUtil.Color = function (cssStyleColor) {
+ cssStyleColor = cssStyleColor.toLowerCase();
+ if (cssStyleColor === "transparent")
+ return new ColorObj(255, 255, 255, 0);
+ if (cssStyleColor in RPTUtil.CSSColorLookup)
+ cssStyleColor = RPTUtil.CSSColorLookup[cssStyleColor];
+ if (cssStyleColor.startsWith("rgb(")) {
+ var rgbRegex = /\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/;
+ var m = cssStyleColor.match(rgbRegex);
+ if (m === null)
+ return null;
+ else {
+ return new ColorObj(m[1], m[2], m[3]);
+ }
+ }
+ else if (cssStyleColor.startsWith("rgba(")) {
+ var rgbRegex = /\s*rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(.+)\s*\)/;
+ var m = cssStyleColor.match(rgbRegex);
+ if (m === null)
+ return null;
+ else {
+ return new ColorObj(m[1], m[2], m[3], m[4]);
+ }
+ }
+ else if (cssStyleColor.charAt(0) != "#") {
+ return null;
+ }
+ else {
+ if (cssStyleColor.length === 4) {
+ // The three-digit RGB (#rgb) is converted to six-digit form (#rrggbb) by replicating digits
+ // (https://www.w3.org/TR/css-color-3/#rgb-color)
+ cssStyleColor = "#" + cssStyleColor.charAt(1).repeat(2) +
+ cssStyleColor.charAt(2).repeat(2) +
+ cssStyleColor.charAt(3).repeat(2);
+ }
+ var thisRed = parseInt(cssStyleColor.substring(1, 3), 16);
+ var thisGreen = parseInt(cssStyleColor.substring(3, 5), 16);
+ var thisBlue = parseInt(cssStyleColor.substring(5, 7), 16);
+ return new ColorObj(thisRed, thisGreen, thisBlue);
+ }
+ // return null; // Unreachable
+ };
+ ;
+ RPTUtil.ColorCombo = function (ruleContext) {
+ var doc = ruleContext.ownerDocument;
+ if (!doc) {
+ return null;
+ }
+ var win = doc.defaultView;
+ if (!win) {
+ return null;
+ }
+ var ancestors = [];
+ var walkNode = ruleContext;
+ while (walkNode) {
+ if (walkNode.nodeType === 1)
+ ancestors.push(walkNode);
+ walkNode = DOMUtil_1.DOMUtil.parentElement(walkNode);
+ }
+ var retVal = {
+ "hasGradient": false,
+ "hasBGImage": false,
+ "fg": null,
+ "bg": null
+ };
+ var compStyleColor = win.getComputedStyle(ruleContext).color;
+ if (!compStyleColor)
+ compStyleColor = "black";
+ var fg = RPTUtil.Color(compStyleColor);
+ var reColor = /transparent|rgba?\([^)]+\)/gi;
+ var guessGradColor = function (gradList, bgColor, fgColor) {
+ try {
+ // If there's only one color, return that
+ if (typeof gradList.length === "undefined")
+ return gradList;
+ var overallWorst = null;
+ var overallWorstRatio = null;
+ for (var iGrad = 1; iGrad < gradList.length; ++iGrad) {
+ var worstColor = gradList[iGrad - 1];
+ var worstRatio = fgColor.contrastRatio(gradList[iGrad - 1]);
+ var step = .1;
+ var idx = 0;
+ while (step > .0001) {
+ while (idx + step <= 1 && worstRatio > fgColor.contrastRatio(gradList[iGrad].mix(gradList[iGrad - 1], idx + step).getOverlayColor(bgColor))) {
+ worstColor = gradList[iGrad].mix(gradList[iGrad - 1], idx + step).getOverlayColor(bgColor);
+ worstRatio = fgColor.contrastRatio(worstColor);
+ idx = idx + step;
+ }
+ while (idx - step >= 0 && worstRatio > fgColor.contrastRatio(gradList[iGrad].mix(gradList[iGrad - 1], idx - step).getOverlayColor(bgColor))) {
+ worstColor = gradList[iGrad].mix(gradList[iGrad - 1], idx - step).getOverlayColor(bgColor);
+ worstRatio = fgColor.contrastRatio(worstColor);
+ idx = idx - step;
+ }
+ step = step / 10;
+ }
+ if (overallWorstRatio === null || overallWorstRatio > worstRatio) {
+ overallWorstRatio = worstRatio;
+ overallWorst = worstColor;
+ }
+ }
+ return overallWorst;
+ }
+ catch (e) {
+ console.log(e);
+ }
+ return bgColor;
+ };
+ var priorStackBG = RPTUtil.Color("white");
+ var thisStackOpacity = null;
+ var thisStackAlpha = null;
+ var thisStackBG = null;
+ // Ancestors processed from the topmost parent toward the child
+ while (ancestors.length > 0) {
+ var procNext = ancestors.pop();
+ // cStyle is the computed style of this layer
+ var cStyle = win.getComputedStyle(procNext);
+ if (cStyle === null)
+ continue;
+ // thisBgColor is the color of this layer or null if the layer is transparent
+ var thisBgColor = null;
+ if (cStyle.backgroundColor && cStyle.backgroundColor != "transparent" && cStyle.backgroundColor != "rgba(0, 0, 0, 0)") {
+ thisBgColor = RPTUtil.Color(cStyle.backgroundColor);
+ }
+ // If there is a gradient involved, set thisBgColor to the worst color combination available against the foreground
+ if (cStyle.backgroundImage && cStyle.backgroundImage.indexOf && cStyle.backgroundImage.indexOf("gradient") != -1) {
+ var gradColors = cStyle.backgroundImage.match(reColor);
+ if (gradColors) {
+ var gradColorComp = [];
+ for (var i = 0; i < gradColors.length; ++i) {
+ if (!gradColors[i].length) {
+ gradColors.splice(i--, 1);
+ }
+ else {
+ gradColorComp.push(RPTUtil.Color(gradColors[i]));
+ }
+ }
+ thisBgColor = guessGradColor(gradColorComp, thisStackBG || priorStackBG, fg);
+ }
+ }
+ // Handle non-solid opacity
+ if (thisStackOpacity === null || (cStyle.opacity && cStyle.opacity.length > 0 && parseFloat(cStyle.opacity) < 1)) {
+ // New stack, reset
+ if (thisStackBG != null) {
+ // Overlay
+ thisStackBG.alpha = thisStackOpacity * thisStackAlpha;
+ priorStackBG = thisStackBG.getOverlayColor(priorStackBG);
+ }
+ thisStackOpacity = 1.0;
+ thisStackAlpha = null;
+ thisStackBG = null;
+ if (cStyle.opacity && cStyle.opacity.length > 0) {
+ thisStackOpacity = parseFloat(cStyle.opacity);
+ }
+ if (thisBgColor != null) {
+ thisStackBG = thisBgColor;
+ thisStackAlpha = thisStackBG.alpha || 1.0;
+ delete thisStackBG.alpha;
+ if (thisStackOpacity === 1.0 && thisStackAlpha === 1.0) {
+ retVal.hasBGImage = false;
+ retVal.hasGradient = false;
+ }
+ }
+ }
+ // Handle solid color backgrounds and gradient color backgrounds
+ else if (thisBgColor != null) {
+ // If this stack already has a background color, blend it
+ if (thisStackBG === null) {
+ thisStackBG = thisBgColor;
+ thisStackAlpha = thisStackBG.alpha || 1.0;
+ delete thisStackBG.alpha;
+ }
+ else {
+ thisStackBG = thisBgColor.getOverlayColor(thisStackBG);
+ }
+ // #526: If thisBgColor had an alpha value, it may not expose through thisStackBG in the above code
+ // We can't wipe out the gradient info if this layer was transparent
+ if (thisStackOpacity === 1.0 && thisStackAlpha === 1.0 && (thisStackBG.alpha || 1.0) === 1.0 && (thisBgColor.alpha || 1.0) === 0) {}
+ }
+ if (cStyle.backgroundImage && cStyle.backgroundImage != "none") {
+ if (cStyle.backgroundImage.indexOf && cStyle.backgroundImage.indexOf("gradient") != -1) {
+ retVal.hasGradient = true;
+ }
+ else {
+ retVal.hasBGImage = true;
+ }
+ }
+ }
+ if (thisStackBG != null) {
+ fg = fg.getOverlayColor(thisStackBG);
+ delete fg.alpha;
+ }
+ fg.alpha = (fg.alpha || 1) * thisStackOpacity;
+ fg = fg.getOverlayColor(priorStackBG);
+ if (thisStackBG != null) {
+ thisStackBG.alpha = thisStackOpacity * thisStackAlpha;
+ priorStackBG = thisStackBG.getOverlayColor(priorStackBG);
+ }
+ retVal.fg = fg;
+ retVal.bg = priorStackBG;
+ return retVal;
+ };
+ ;
+ RPTUtil.hasAttribute = function (element, attributeName) {
+ var hasAttribute = false;
+ if (element.hasAttribute) {
+ hasAttribute = element.hasAttribute(attributeName);
+ }
+ else if (element.attributes && element.attributes.getNamedItem) {
+ var attr = element.attributes.getNamedItem(attributeName);
+ hasAttribute = attr && attr.specified;
+ }
+ return hasAttribute;
+ };
+ // This list contains a list of element tags which can not be hidden, when hidden is
+ // added to theses elements it does not do anything at all.
+ // area --> area element is part of a map element and it can not be hidden because it is used to
+ // make an certian parts of an map interactive.
+ // param --> element can only be part of object elment and it cannot be hidden directly, it
+ // can only be hidden if the parent is hidden.
+ // audio --> If this element is hidden it will still play the music, so we should still trigger
+ // violations for this element.
+ // Note: All element tags that are added here should be added as lowercase, as we are using indexOf to do the check.
+ RPTUtil.unhideableElements = ['area', 'param', 'audio'];
+ // This list contains a list of elements tags which have display: none by default, since we have rules triggering
+ // on theses elements we need to make then visible by default so that the rules can trigger regardless of the
+ // Check Hidden Content option in the tools.
+ // script --> script elements have display: none by default
+ // link --> link elements have display: none by default, but the actually CSS script is still executed so we have to
+ // mark this element as visible at all times.
+ // style --> style elements have display: none by default, but the actually CSS script is still executed so we have to
+ // mark this element as visible at all times.
+ // head --> head elements have display: none by default, but it will still behave correct
+ // title --> title elements have display: none by default, but it will still display the title
+ // meta --> meta elements have display: none by default, but it will still perform the action that meta is suppose to
+ // base --> base elements have display: none by default, but it will still perform the action that meta is suppose to
+ // noscript --> noscript elements have display: none by default, but it will still perform the action that meta is suppose to
+ // template --> template elements have display: none by default, because they are just a mechanism for holding client-side content
+ // that is not to be rendered when a page is loaded. https://developer.mozilla.org/en/docs/Web/HTML/Element/template
+ // datalist --> datalist elements have display: none by default,
+ RPTUtil.hiddenByDefaultElements = ['script', 'link', 'style', 'head', 'title', 'meta', 'base', 'noscript', 'template', 'datalist'];
+ // This list contains a list of elements tags which have display: none by default, since we have rules triggering
+ RPTUtil.navLinkKeywords = ['start', 'next', 'prev', 'previous', 'contents', 'index'];
+ // This list contains a list of rule ids for the rules that have to check for hidden content regardless of the Check Hidden
+ // Content Setting. This means that when the engine is actually determine which elements to mass to the rules, it will always
+ // pass theses rules no matter what the Check Hidden Content Setting is.
+ RPTUtil.rulesThatHaveToCheckHidden = ['RPT_Elem_UniqueId'];
+ // https://www.w3.org/TR/wai-aria-1.1/#introstates
+ RPTUtil.ariaAttributeRoleDefaults = {
+ "alert": {
+ "aria-live": "assertive",
+ "aria-atomic": "true"
+ },
+ "combobox": {
+ "aria-haspopup": "listbox"
+ },
+ "listbox": {
+ "aria-orientation": "vertical"
+ },
+ "log": {
+ "aria-live": "polite"
+ },
+ "menu": {
+ "aria-orientation": "vertical"
+ },
+ "menubar": {
+ "aria-orientation": "horizontal"
+ },
+ "meter": {
+ "aria-valuemin": "0",
+ "aria-valuemax": "100"
+ },
+ "option": {
+ "aria-selected": "false"
+ },
+ "progressbar": {
+ "aria-valuemin": "0",
+ "aria-valuemax": "100"
+ },
+ "scrollbar": {
+ "aria-orientation": "vertical",
+ "aria-valuemin": "0",
+ "aria-valuemax": "100"
+ },
+ "separator": {
+ "aria-orientation": "horizontal",
+ "aria-valuemin": "0",
+ "aria-valuemax": "100"
+ },
+ "slider": {
+ "aria-orientation": "horizontal",
+ "aria-valuemin": "0",
+ "aria-valuemax": "100"
+ },
+ "spinbutton": {
+ // Not sure how to encode min/max (or now in 1.2 - "has no value")
+ //"aria-valuenow": "0" TODO: at risk: maybe delete after ARIA 1.2 reaches proposed rec
+ // Probably just delete spinbutton from this list completely and let user agents handle "defaults"
+ },
+ "status": {
+ "aria-live": "polite",
+ "aria-atomic": "true"
+ },
+ "tab": {
+ "aria-selected": "false"
+ },
+ "tablist": {
+ "aria-orientation": "horizontal"
+ },
+ "toolbar": {
+ "aria-orientation": "horizontal"
+ },
+ "tree": {
+ "aria-orientation": "vertical"
+ }
+ };
+ // https://www.w3.org/TR/wai-aria-1.1/#aria-atomic
+ RPTUtil.ariaAttributeGlobalDefaults = {
+ "aria-atomic": "false",
+ "aria-autocomplete": "none",
+ "aria-busy": "false",
+ "aria-checked": undefined,
+ "aria-current": "false",
+ "aria-disabled": "false",
+ "aria-dropeffect": "none",
+ "aria-expanded": undefined,
+ "aria-grabbed": undefined,
+ "aria-haspopup": "false",
+ "aria-hidden": undefined,
+ "aria-invalid": "false",
+ "aria-live": "off",
+ "aria-modal": "false",
+ "aria-multiline": "false",
+ "aria-multiselectable": "false",
+ "aria-orientation": undefined,
+ "aria-pressed": undefined,
+ "aria-readonly": "false",
+ //"aria-relevant": "additions text", TODO: are multiple values supported?
+ "aria-required": "false",
+ "aria-selected": undefined,
+ "aria-sort": "none"
+ };
+ // https://www.w3.org/TR/html-aam-1.0/#html-attribute-state-and-property-mappings
+ RPTUtil.ariaAttributeImplicitMappings = {
+ "aria-autocomplete": {
+ "form": function (e) {
+ return "off" === e.getAttribute("autocomplete") ? "none" : "both";
+ },
+ "input": function (e) {
+ return "off" === e.getAttribute("autocomplete") ? "none" : "both";
+ },
+ "select": function (e) {
+ return "off" === e.getAttribute("autocomplete") ? "none" : "both";
+ },
+ "textarea": function (e) {
+ return "off" === e.getAttribute("autocomplete") ? "none" : "both";
+ }
+ },
+ "aria-checked": {
+ "input": function (e) {
+ if (e.hasAttribute("indeterminate"))
+ return "mixed";
+ return "" + e.hasAttribute("checked");
+ },
+ "menuitem": function (e) {
+ if (e.hasAttribute("indeterminate"))
+ return "mixed";
+ return "" + e.hasAttribute("checked");
+ },
+ "*": function (e) {
+ if (e.hasAttribute("indeterminate"))
+ return "mixed";
+ },
+ },
+ "aria-disabled": {
+ "button": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ },
+ "fieldset": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ },
+ "input": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ },
+ "optgroup": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ },
+ "option": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ },
+ "select": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ },
+ "textarea": function (e) {
+ return e.hasAttribute("disabled") ? "true" : "false";
+ }
+ },
+ "aria-expanded": {
+ "details": function (e) {
+ return e.getAttribute("open");
+ },
+ "dialog": function (e) {
+ return e.getAttribute("open");
+ }
+ },
+ "aria-multiselectable": {
+ "select": function (e) {
+ if (e.hasAttribute("multiple"))
+ return "true";
+ return;
+ }
+ },
+ "aria-placeholder": {
+ "input": function (e) {
+ return e.getAttribute("placeholder");
+ },
+ "textarea": function (e) {
+ return e.getAttribute("placeholder");
+ }
+ },
+ "aria-required": {
+ "input": function (e) {
+ return e.getAttribute("required");
+ },
+ "select": function (e) {
+ return e.getAttribute("required");
+ },
+ "textarea": function (e) {
+ return e.getAttribute("required");
+ }
+ }
+ };
+ RPTUtil.tabTagMap = {
+ "button": function (element) {
+ return !element.hasAttribute("disabled");
+ },
+ "iframe": true,
+ "input": function (element) {
+ return element.getAttribute("type") !== "hidden" && !element.hasAttribute("disabled");
+ },
+ "select": function (element) {
+ return !element.hasAttribute("disabled");
+ },
+ "textarea": true,
+ "div": function (element) {
+ return element.hasAttribute("contenteditable");
+ },
+ "a": function (element) {
+ // xlink:href?? see svg
+ return element.hasAttribute("href");
+ },
+ "area": function (element) {
+ return element.hasAttribute("href");
+ },
+ "audio": function (element) {
+ return element.hasAttribute("controls");
+ },
+ "video": function (element) {
+ return element.hasAttribute("controls");
+ },
+ "summary": true
+ };
+ RPTUtil.CSSColorLookup = {
+ "aliceblue": "#f0f8ff",
+ "antiquewhite": "#faebd7",
+ "aqua": "#00ffff",
+ "aquamarine": "#7fffd4",
+ "azure": "#f0ffff",
+ "beige": "#f5f5dc",
+ "bisque": "#ffe4c4",
+ "black": "#000000",
+ "blanchedalmond": "#ffebcd",
+ "blue": "#0000ff",
+ "blueviolet": "#8a2be2",
+ "brown": "#a52a2a",
+ "burlywood": "#deb887",
+ "cadetblue": "#5f9ea0",
+ "chartreuse": "#7fff00",
+ "chocolate": "#d2691e",
+ "coral": "#ff7f50",
+ "cornflowerblue": "#6495ed",
+ "cornsilk": "#fff8dc",
+ "crimson": "#dc143c",
+ "cyan": "#00ffff",
+ "darkblue": "#00008b",
+ "darkcyan": "#008b8b",
+ "darkgoldenrod": "#b8860b",
+ "darkgray": "#a9a9a9",
+ "darkgreen": "#006400",
+ "darkkhaki": "#bdb76b",
+ "darkmagenta": "#8b008b",
+ "darkolivegreen": "#556b2f",
+ "darkorange": "#ff8c00",
+ "darkorchid": "#9932cc",
+ "darkred": "#8b0000",
+ "darksalmon": "#e9967a",
+ "darkseagreen": "#8fbc8f",
+ "darkslateblue": "#483d8b",
+ "darkslategray": "#2f4f4f",
+ "darkturquoise": "#00ced1",
+ "darkviolet": "#9400d3",
+ "deeppink": "#ff1493",
+ "deepskyblue": "#00bfff",
+ "dimgray": "#696969",
+ "dodgerblue": "#1e90ff",
+ "firebrick": "#b22222",
+ "floralwhite": "#fffaf0",
+ "forestgreen": "#228b22",
+ "fuchsia": "#ff00ff",
+ "gainsboro": "#dcdcdc",
+ "ghostwhite": "#f8f8ff",
+ "gold": "#ffd700",
+ "goldenrod": "#daa520",
+ "gray": "#808080",
+ "green": "#008000",
+ "greenyellow": "#adff2f",
+ "honeydew": "#f0fff0",
+ "hotpink": "#ff69b4",
+ "indianred": "#cd5c5c",
+ "indigo": "#4b0082",
+ "ivory": "#fffff0",
+ "khaki": "#f0e68c",
+ "lavender": "#e6e6fa",
+ "lavenderblush": "#fff0f5",
+ "lawngreen": "#7cfc00",
+ "lemonchiffon": "#fffacd",
+ "lightblue": "#add8e6",
+ "lightcoral": "#f08080",
+ "lightcyan": "#e0ffff",
+ "lightgoldenrodyellow": "#fafad2",
+ "lightgrey": "#d3d3d3",
+ "lightgreen": "#90ee90",
+ "lightpink": "#ffb6c1",
+ "lightsalmon": "#ffa07a",
+ "lightseagreen": "#20b2aa",
+ "lightskyblue": "#87cefa",
+ "lightslategray": "#778899",
+ "lightsteelblue": "#b0c4de",
+ "lightyellow": "#ffffe0",
+ "lime": "#00ff00",
+ "limegreen": "#32cd32",
+ "linen": "#faf0e6",
+ "magenta": "#ff00ff",
+ "maroon": "#800000",
+ "mediumaquamarine": "#66cdaa",
+ "mediumblue": "#0000cd",
+ "mediumorchid": "#ba55d3",
+ "mediumpurple": "#9370d8",
+ "mediumseagreen": "#3cb371",
+ "mediumslateblue": "#7b68ee",
+ "mediumspringgreen": "#00fa9a",
+ "mediumturquoise": "#48d1cc",
+ "mediumvioletred": "#c71585",
+ "midnightblue": "#191970",
+ "mintcream": "#f5fffa",
+ "mistyrose": "#ffe4e1",
+ "moccasin": "#ffe4b5",
+ "navajowhite": "#ffdead",
+ "navy": "#000080",
+ "oldlace": "#fdf5e6",
+ "olive": "#808000",
+ "olivedrab": "#6b8e23",
+ "orange": "#ffa500",
+ "orangered": "#ff4500",
+ "orchid": "#da70d6",
+ "palegoldenrod": "#eee8aa",
+ "palegreen": "#98fb98",
+ "paleturquoise": "#afeeee",
+ "palevioletred": "#d87093",
+ "papayawhip": "#ffefd5",
+ "peachpuff": "#ffdab9",
+ "peru": "#cd853f",
+ "pink": "#ffc0cb",
+ "plum": "#dda0dd",
+ "powderblue": "#b0e0e6",
+ "purple": "#800080",
+ "red": "#ff0000",
+ "rosybrown": "#bc8f8f",
+ "royalblue": "#4169e1",
+ "saddlebrown": "#8b4513",
+ "salmon": "#fa8072",
+ "sandybrown": "#f4a460",
+ "seagreen": "#2e8b57",
+ "seashell": "#fff5ee",
+ "sienna": "#a0522d",
+ "silver": "#c0c0c0",
+ "skyblue": "#87ceeb",
+ "slateblue": "#6a5acd",
+ "slategray": "#708090",
+ "snow": "#fffafa",
+ "springgreen": "#00ff7f",
+ "steelblue": "#4682b4",
+ "tan": "#d2b48c",
+ "teal": "#008080",
+ "thistle": "#d8bfd8",
+ "tomato": "#ff6347",
+ "turquoise": "#40e0d0",
+ "violet": "#ee82ee",
+ "wheat": "#f5deb3",
+ "white": "#ffffff",
+ "whitesmoke": "#f5f5f5",
+ "yellow": "#ffff00",
+ "yellowgreen": "#9acd32",
+ "buttontext": "rgba(0, 0, 0, 0.847)",
+ "buttonface": "#ffffff",
+ "graytext": "rgba(0, 0, 0, 0.247)"
+ };
+ return RPTUtil;
+}());
+exports.RPTUtil = RPTUtil;
+var RPTUtilStyle = /** @class */ (function () {
+ function RPTUtilStyle() {
+ }
+ RPTUtilStyle.getWeightNumber = function (styleVal) {
+ var map = {
+ "light": 100,
+ "bold": 700
+ };
+ var retVal = parseInt(styleVal);
+ if (retVal)
+ return retVal;
+ if (styleVal in map)
+ return map[styleVal];
+ return 400;
+ };
+ RPTUtilStyle.getFontInPixels = function (styleVal) {
+ var map = {
+ "xx-small": 16,
+ "x-small": 10,
+ "small": 13,
+ "medium": 16,
+ "large": 18,
+ "x-large": 24,
+ "xx-large": 32
+ };
+ var value = parseFloat(styleVal);
+ if (!value) {
+ return map[styleVal];
+ }
+ var units = styleVal.substring(("" + value).length);
+ if (units === "" || units === "px")
+ return value;
+ if (units === "em")
+ return value * 16;
+ if (units === "%")
+ return value / 100 * 16;
+ if (units === "pt")
+ return value * 4 / 3;
+ return Math.round(value);
+ };
+ return RPTUtilStyle;
+}());
+exports.RPTUtilStyle = RPTUtilStyle;
+var ColorObj = /** @class */ (function () {
+ function ColorObj(red, green, blue, alpha) {
+ function fixComponent(comp) {
+ if (typeof (comp) != typeof (""))
+ return comp;
+ var compStr = comp;
+ compStr = compStr.trim();
+ if (compStr[compStr.length - 1] != "%")
+ return parseInt(compStr);
+ return Math.round(parseFloat(compStr.substring(0, compStr.length - 1)) * 2.55);
+ }
+ this.red = fixComponent(red);
+ this.green = fixComponent(green);
+ this.blue = fixComponent(blue);
+ if (typeof (alpha) != "undefined") {
+ this.alpha = (typeof (alpha) === typeof ("")) ? parseFloat(alpha) : alpha;
+ }
+ }
+ ColorObj.prototype.toHexHelp = function (value) {
+ var retVal = Math.round(value).toString(16);
+ if (retVal.length === 1)
+ return "0" + retVal;
+ return retVal;
+ };
+ ;
+ ColorObj.prototype.toHex = function () {
+ return "#" + this.toHexHelp(this.red) + this.toHexHelp(this.green) + this.toHexHelp(this.blue);
+ };
+ ;
+ ColorObj.prototype.contrastRatio = function (bgColor) {
+ var fgColor = this;
+ if (typeof (this.alpha) != "undefined")
+ fgColor = this.getOverlayColor(bgColor);
+ var lum1 = fgColor.relativeLuminance();
+ if (!bgColor.relativeLuminance) {
+ var s = "";
+ for (var key in bgColor) {
+ s += key + "\n";
+ }
+ alert(bgColor);
+ alert(s);
+ }
+ var lum2 = bgColor.relativeLuminance();
+ var ratio = (lum1 > lum2) ? (lum1 + .05) / (lum2 + .05) : (lum2 + .05) / (lum1 + .05);
+ return ratio;
+ };
+ ;
+ ColorObj.prototype.relativeLuminance = function () {
+ var R = this.red / 255.0;
+ var G = this.green / 255.0;
+ var B = this.blue / 255.0;
+ R = R <= .04045 ? R / 12.92 : Math.pow((R + .055) / 1.055, 2.4);
+ G = G <= .04045 ? G / 12.92 : Math.pow((G + .055) / 1.055, 2.4);
+ B = B <= .04045 ? B / 12.92 : Math.pow((B + .055) / 1.055, 2.4);
+ return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+ };
+ ;
+ ColorObj.prototype.mix = function (color2, percThis) {
+ if (typeof (this.alpha) === "undefined" && typeof (color2.alpha) === "undefined") {
+ return new ColorObj(percThis * this.red + (1 - percThis) * color2.red, percThis * this.green + (1 - percThis) * color2.green, percThis * this.blue + (1 - percThis) * color2.blue);
+ }
+ else {
+ var alphaThis = this.alpha ? this.alpha : 1;
+ var alphaOther = color2.alpha ? color2.alpha : 1;
+ return new ColorObj(percThis * this.red + (1 - percThis) * color2.red, percThis * this.green + (1 - percThis) * color2.green, percThis * this.blue + (1 - percThis) * color2.blue, percThis * alphaThis + (1 - percThis) * alphaOther);
+ }
+ };
+ ;
+ ColorObj.prototype.getOverlayColor = function (bgColor) {
+ if (typeof (this.alpha) === "undefined" || this.alpha >= 1) {
+ // No mixing required - it's opaque
+ return this;
+ }
+ if (this.alpha < 0) {
+ // Haac.Error.logError("Invalid alpha value");
+ return null;
+ }
+ if (typeof (bgColor.alpha) != "undefined" && bgColor.alpha < 1) {
+ // Haac.Error.logError("Cannot mix with a background alpha");
+ return null;
+ }
+ var retVal = this.mix(bgColor, this.alpha);
+ delete retVal.alpha;
+ return retVal;
+ };
+ ColorObj.fromCSSColor = function (cssStyleColor) {
+ var thisRed = -1;
+ var thisGreen = -1;
+ var thisBlue = -1;
+ cssStyleColor = cssStyleColor.toLowerCase();
+ if (cssStyleColor.startsWith("rgb(")) {
+ var rgbRegex = /\s*rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/;
+ var m = cssStyleColor.match(rgbRegex);
+ if (m === null)
+ return null;
+ else {
+ thisRed = m[1];
+ thisGreen = m[2];
+ thisBlue = m[3];
+ }
+ }
+ else if (cssStyleColor.startsWith("rgba(")) {
+ var rgbRegex = /\s*rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(.+)\s*\)/;
+ var m = cssStyleColor.match(rgbRegex);
+ if (m === null)
+ return null;
+ else {
+ thisRed = m[1];
+ thisGreen = m[2];
+ thisBlue = m[3];
+ }
+ }
+ else {
+ if (cssStyleColor.charAt(0) != "#") {
+ if (cssStyleColor in RPTUtil.CSSColorLookup)
+ cssStyleColor = RPTUtil.CSSColorLookup[cssStyleColor];
+ else
+ return null;
+ }
+ var fromHex = function (val) {
+ var lookup = {
+ "a": 10,
+ "b": 11,
+ "c": 12,
+ "d": 13,
+ "e": 14,
+ "f": 15
+ };
+ var retVal = 0;
+ for (var i = 0; i < val.length; ++i) {
+ retVal = retVal * 16 +
+ parseInt(val.charAt(i) in lookup ? lookup[val.charAt(i)] : val.charAt(i));
+ }
+ return retVal;
+ };
+ if (cssStyleColor.length === 4) {
+ // The three-digit RGB (#rgb) is converted to six-digit form (#rrggbb) by replicating digits
+ // (https://www.w3.org/TR/css-color-3/#rgb-color)
+ cssStyleColor = "#" + cssStyleColor.charAt(1).repeat(2) +
+ cssStyleColor.charAt(2).repeat(2) +
+ cssStyleColor.charAt(3).repeat(2);
+ }
+ thisRed = fromHex(cssStyleColor.substring(1, 3));
+ thisGreen = fromHex(cssStyleColor.substring(3, 5));
+ thisBlue = fromHex(cssStyleColor.substring(5, 7));
+ }
+ return new ColorObj(thisRed, thisGreen, thisBlue);
+ };
+ return ColorObj;
+}());
+exports.ColorObj = ColorObj;
+/* Return a node walker for the given element.
+ * bEnd is optional and defaults to false
+ * but if true, indicates the node is the end node*/
+var NodeWalker = /** @class */ (function () {
+ function NodeWalker(node, bEnd) {
+ this.node = node;
+ this.bEndTag = (bEnd === undefined ? false : bEnd === true);
+ }
+ NodeWalker.prototype.elem = function () {
+ return this.node.nodeType === 1 && this.node || null;
+ };
+ NodeWalker.prototype.nextNode = function () {
+ if (!this.bEndTag) {
+ var iframeNode = this.node;
+ var elementNode = this.node;
+ var slotElement = this.node;
+ if (this.node.nodeType === 1 /* Node.ELEMENT_NODE */
+ && this.node.nodeName.toUpperCase() === "IFRAME"
+ && iframeNode.contentDocument
+ && iframeNode.contentDocument.documentElement) {
+ var ownerElement = this.node;
+ this.node = iframeNode.contentDocument.documentElement;
+ this.node.ownerElement = ownerElement;
+ }
+ else if (this.node.nodeType === 1 /* Node.ELEMENT_NODE */
+ && elementNode.shadowRoot
+ && elementNode.shadowRoot.firstChild) {
+ var ownerElement = this.node;
+ this.node = elementNode.shadowRoot;
+ this.node.ownerElement = ownerElement;
+ }
+ else if (this.node.nodeType === 1
+ && elementNode.nodeName.toLowerCase() === "slot"
+ && slotElement.assignedNodes().length > 0) {
+ var slotOwner = this.node;
+ this.node = slotElement.assignedNodes()[0];
+ this.node.slotOwner = slotOwner;
+ }
+ else if (this.node.firstChild) {
+ this.node = this.node.firstChild;
+ }
+ else {
+ this.bEndTag = true;
+ return this.nextNode();
+ }
+ }
+ else {
+ if (this.node.nextSibling) {
+ this.node = this.node.nextSibling;
+ this.bEndTag = false;
+ }
+ else if (this.node.ownerElement) {
+ this.node = this.node.ownerElement;
+ this.bEndTag = true;
+ }
+ else if (this.node.slotOwner) {
+ if (this.node.nodeType !== 1 || !this.node.hasAttribute("slot")) {
+ // If this wasn't a named slot, look for the next unnamed node to put in the slot
+ var n = this.node.nextSibling;
+ while (n && this.node.nodeType === 1 && this.node.hasAttribute("slot")) {
+ n = this.node.nextSibling;
+ }
+ if (n) {
+ // We found another unnamed slot
+ var slotOwner = this.node.slotOwner;
+ this.node = n;
+ this.node.slotOwner = slotOwner;
+ this.bEndTag = false;
+ }
+ else {
+ this.node = this.node.slotOwner;
+ this.bEndTag = true;
+ }
+ }
+ else {
+ this.node = this.node.slotOwner;
+ this.bEndTag = true;
+ }
+ }
+ else if (this.node.parentNode) {
+ this.node = this.node.parentNode;
+ this.bEndTag = true;
+ }
+ else {
+ return false;
+ }
+ }
+ return true;
+ };
+ NodeWalker.prototype.prevNode = function () {
+ if (this.bEndTag && this.node.lastChild) {
+ this.node = this.node.lastChild;
+ this.bEndTag = true;
+ }
+ else if (this.node.previousSibling) {
+ this.node = this.node.previousSibling;
+ this.bEndTag = true;
+ }
+ else if (this.node.parentNode) {
+ this.node = this.node.parentNode;
+ this.bEndTag = false;
+ }
+ else {
+ return false;
+ }
+ if (this.bEndTag && (this.node.firstChild === null || typeof (this.node.firstChild) === 'undefined'))
+ this.bEndTag = false;
+ return true;
+ };
+ return NodeWalker;
+}());
+exports.NodeWalker = NodeWalker;
+
+
+/***/ }),
+
+/***/ "./src/v2/common/CommonMapper.ts":
+/*!***************************************!*\
+ !*** ./src/v2/common/CommonMapper.ts ***!
+ \***************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+/******************************************************************************
+ Copyright:: 2020- IBM, Inc
+
+ 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.
+ *****************************************************************************/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.CommonMapper = void 0;
+var DOMUtil_1 = __webpack_require__(/*! ../dom/DOMUtil */ "./src/v2/dom/DOMUtil.ts");
+var CommonMapper = /** @class */ (function () {
+ function CommonMapper() {
+ this.hierarchyRole = null;
+ this.hierarchyChildrenHaveRole = null;
+ this.hierarchyPath = null;
+ this.hierarchyResults = null;
+ }
+ CommonMapper.prototype.getBounds = function (node) {
+ return null;
+ };
+ CommonMapper.prototype.reset = function (node) {
+ this.hierarchyRole = [];
+ this.hierarchyResults = [];
+ this.hierarchyChildrenHaveRole = [];
+ this.hierarchyPath = [{
+ rolePath: "",
+ roleCount: {}
+ }];
+ var ancestors = [];
+ var parent = DOMUtil_1.DOMUtil.parentNode(node);
+ while (parent && parent.nodeType != 9 /* Node.DOCUMENT_NODE */) {
+ ancestors.push(parent);
+ parent = DOMUtil_1.DOMUtil.parentNode(parent);
+ }
+ ancestors = ancestors.reverse();
+ for (var _i = 0, ancestors_1 = ancestors; _i < ancestors_1.length; _i++) {
+ var ancestor = ancestors_1[_i];
+ var siblings = [];
+ var sibling = ancestor.previousSibling;
+ while (sibling) {
+ siblings.push(sibling);
+ sibling = sibling.previousSibling;
+ }
+ siblings = siblings.reverse();
+ for (var _a = 0, siblings_1 = siblings; _a < siblings_1.length; _a++) {
+ var sibling_1 = siblings_1[_a];
+ this.pushHierarchy(sibling_1);
+ this.popHierarchy();
+ }
+ this.pushHierarchy(ancestor);
+ }
+ };
+ CommonMapper.prototype.pushHierarchy = function (node) {
+ var role;
+ var presentationalContainer = this.hierarchyChildrenHaveRole.length > 0 && !this.hierarchyChildrenHaveRole[this.hierarchyChildrenHaveRole.length - 1];
+ if (presentationalContainer) {
+ role = "none";
+ this.hierarchyChildrenHaveRole.push(false);
+ }
+ else {
+ role = this.getRole(node) || "none";
+ this.hierarchyChildrenHaveRole.push(this.childrenHaveRole(node, role));
+ }
+ this.hierarchyRole.push(role);
+ if (role !== "none") {
+ var parentPathInfo = this.hierarchyPath[this.hierarchyPath.length - 1];
+ parentPathInfo.roleCount[role] = (parentPathInfo.roleCount[role] || 0) + 1;
+ this.hierarchyPath.push({
+ "rolePath": parentPathInfo.rolePath + "/" + role + "[" + parentPathInfo.roleCount[role] + "]",
+ "roleCount": {}
+ });
+ }
+ var attr = {};
+ if (node.nodeType === 1) {
+ attr = this.getAttributes(node);
+ }
+ this.hierarchyResults.push({
+ node: node,
+ namespace: this.getNamespace(),
+ role: role,
+ attributes: attr,
+ rolePath: this.hierarchyPath[this.hierarchyPath.length - 1].rolePath,
+ bounds: this.getBounds(node)
+ });
+ };
+ CommonMapper.prototype.popHierarchy = function () {
+ var role = this.hierarchyRole.pop();
+ this.hierarchyChildrenHaveRole.pop();
+ if (role !== "none") {
+ this.hierarchyPath.pop();
+ }
+ this.hierarchyResults.pop();
+ };
+ CommonMapper.prototype.openScope = function (node) {
+ if (this.hierarchyRole === null) {
+ this.reset(node);
+ }
+ this.pushHierarchy(node);
+ return this.hierarchyResults;
+ };
+ CommonMapper.prototype.closeScope = function (node) {
+ var retVal = [];
+ for (var _i = 0, _a = this.hierarchyResults; _i < _a.length; _i++) {
+ var res = _a[_i];
+ // const temp = res.node;
+ // res.node = null;
+ // let cloned = JSON.parse(JSON.stringify(res));
+ // cloned.node = res.node = temp;
+ // retVal.push(cloned);
+ retVal.push(res);
+ }
+ retVal[retVal.length - 1].role = "/" + retVal[retVal.length - 1].role;
+ this.popHierarchy();
+ return retVal;
+ };
+ return CommonMapper;
+}());
+exports.CommonMapper = CommonMapper;
+
+
+/***/ }),
+
+/***/ "./src/v2/common/Context.ts":
+/*!**********************************!*\
+ !*** ./src/v2/common/Context.ts ***!
+ \**********************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+
+/******************************************************************************
+ Copyright:: 2020- IBM, Inc
+
+ 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.
+ *****************************************************************************/
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Context = exports.PartInfo = exports.AttrInfo = void 0;
+// Context that will cause this rule to execute.
+// Context syntax:
+// Triggers:
+// aria:role - Triggers on element with ARIA role role
+// aria:role[attribute] - Triggers on elements with the equivalent logical
+// aria- attribute (e.g., button[disabled] will trigger on
+//