Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "checkClass", "(", "node", ")", "{", "if", "(", "!", "node", ".", "superClass", ")", "{", "return", ";", "}", "/*\n * If `node.superClass` is a LeftHandSideExpression, parentheses are extra.\n * Otherwise, parentheses are needed.\n */", "const", "hasExtraParens", "=", "precedence", "(", "node", ".", "superClass", ")", ">", "PRECEDENCE_OF_UPDATE_EXPR", "?", "hasExcessParens", "(", "node", ".", "superClass", ")", ":", "hasDoubleExcessParens", "(", "node", ".", "superClass", ")", ";", "if", "(", "hasExtraParens", ")", "{", "report", "(", "node", ".", "superClass", ")", ";", "}", "}" ]

[ "Check", "the", "parentheses", "around", "the", "super", "class", "of", "the", "given", "class", "definition", "." ]

[ "function", "checkSpreadOperator", "(", "node", ")", "{", "const", "hasExtraParens", "=", "precedence", "(", "node", ".", "argument", ")", ">=", "PRECEDENCE_OF_ASSIGNMENT_EXPR", "?", "hasExcessParens", "(", "node", ".", "argument", ")", ":", "hasDoubleExcessParens", "(", "node", ".", "argument", ")", ";", "if", "(", "hasExtraParens", ")", "{", "report", "(", "node", ".", "argument", ")", ";", "}", "}" ]

[ "Check", "the", "parentheses", "around", "the", "argument", "of", "the", "given", "spread", "operator", "." ]

[ "function", "checkExpressionOrExportStatement", "(", "node", ")", "{", "const", "firstToken", "=", "isParenthesised", "(", "node", ")", "?", "sourceCode", ".", "getTokenBefore", "(", "node", ")", ":", "sourceCode", ".", "getFirstToken", "(", "node", ")", ";", "const", "secondToken", "=", "sourceCode", ".", "getTokenAfter", "(", "firstToken", ",", "astUtils", ".", "isNotOpeningParenToken", ")", ";", "const", "thirdToken", "=", "secondToken", "?", "sourceCode", ".", "getTokenAfter", "(", "secondToken", ")", ":", "null", ";", "const", "tokenAfterClosingParens", "=", "secondToken", "?", "sourceCode", ".", "getTokenAfter", "(", "secondToken", ",", "astUtils", ".", "isNotClosingParenToken", ")", ":", "null", ";", "if", "(", "astUtils", ".", "isOpeningParenToken", "(", "firstToken", ")", "&&", "(", "astUtils", ".", "isOpeningBraceToken", "(", "secondToken", ")", "||", "secondToken", ".", "type", "===", "\"Keyword\"", "&&", "(", "secondToken", ".", "value", "===", "\"function\"", "||", "secondToken", ".", "value", "===", "\"class\"", "||", "secondToken", ".", "value", "===", "\"let\"", "&&", "tokenAfterClosingParens", "&&", "(", "astUtils", ".", "isOpeningBracketToken", "(", "tokenAfterClosingParens", ")", "||", "tokenAfterClosingParens", ".", "type", "===", "\"Identifier\"", ")", ")", "||", "secondToken", "&&", "secondToken", ".", "type", "===", "\"Identifier\"", "&&", "secondToken", ".", "value", "===", "\"async\"", "&&", "thirdToken", "&&", "thirdToken", ".", "type", "===", "\"Keyword\"", "&&", "thirdToken", ".", "value", "===", "\"function\"", ")", ")", "{", "tokensToIgnore", ".", "add", "(", "secondToken", ")", ";", "}", "if", "(", "hasExcessParens", "(", "node", ")", ")", "{", "report", "(", "node", ")", ";", "}", "}" ]

[ "Checks", "the", "parentheses", "for", "an", "ExpressionStatement", "or", "ExportDefaultDeclaration" ]

[ "function", "checkDestructured", "(", "node", ")", "{", "if", "(", "ignoreDestructuring", ")", "{", "return", ";", "}", "const", "properties", "=", "node", ".", "properties", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "properties", ".", "length", ";", "i", "++", ")", "{", "if", "(", "properties", "[", "i", "]", ".", "shorthand", ")", "{", "continue", ";", "}", "/**\n * If an ObjectPattern property is computed, we have no idea\n * if a rename is useless or not. If an ObjectPattern property\n * lacks a key, it is likely an ExperimentalRestProperty and\n * so there is no \"renaming\" occurring here.\n */", "if", "(", "properties", "[", "i", "]", ".", "computed", "||", "!", "properties", "[", "i", "]", ".", "key", ")", "{", "continue", ";", "}", "if", "(", "properties", "[", "i", "]", ".", "key", ".", "type", "===", "\"Identifier\"", "&&", "properties", "[", "i", "]", ".", "key", ".", "name", "===", "properties", "[", "i", "]", ".", "value", ".", "name", "||", "properties", "[", "i", "]", ".", "key", ".", "type", "===", "\"Literal\"", "&&", "properties", "[", "i", "]", ".", "key", ".", "value", "===", "properties", "[", "i", "]", ".", "value", ".", "name", ")", "{", "reportError", "(", "properties", "[", "i", "]", ",", "properties", "[", "i", "]", ".", "key", ",", "properties", "[", "i", "]", ".", "value", ",", "\"Destructuring assignment\"", ")", ";", "}", "}", "}" ]

[ "Checks", "whether", "a", "destructured", "assignment", "is", "unnecessarily", "renamed" ]

[ "function", "checkImport", "(", "node", ")", "{", "if", "(", "ignoreImport", ")", "{", "return", ";", "}", "if", "(", "node", ".", "imported", ".", "name", "===", "node", ".", "local", ".", "name", "&&", "node", ".", "imported", ".", "range", "[", "0", "]", "!==", "node", ".", "local", ".", "range", "[", "0", "]", ")", "{", "reportError", "(", "node", ",", "node", ".", "imported", ",", "node", ".", "local", ",", "\"Import\"", ")", ";", "}", "}" ]

[ "Checks", "whether", "an", "import", "is", "unnecessarily", "renamed" ]

[ "function", "checkExport", "(", "node", ")", "{", "if", "(", "ignoreExport", ")", "{", "return", ";", "}", "if", "(", "node", ".", "local", ".", "name", "===", "node", ".", "exported", ".", "name", "&&", "node", ".", "local", ".", "range", "[", "0", "]", "!==", "node", ".", "exported", ".", "range", "[", "0", "]", ")", "{", "reportError", "(", "node", ",", "node", ".", "local", ",", "node", ".", "exported", ",", "\"Export\"", ")", ";", "}", "}" ]

[ "Checks", "whether", "an", "export", "is", "unnecessarily", "renamed" ]

[ "function", "checkFunction", "(", "node", ")", "{", "if", "(", "node", ".", "params", ".", "length", ">", "numParams", ")", "{", "context", ".", "report", "(", "{", "loc", ":", "astUtils", ".", "getFunctionHeadLoc", "(", "node", ",", "sourceCode", ")", ",", "node", ",", "messageId", ":", "\"exceed\"", ",", "data", ":", "{", "name", ":", "lodash", ".", "upperFirst", "(", "astUtils", ".", "getFunctionNameWithKind", "(", "node", ")", ")", ",", "count", ":", "node", ".", "params", ".", "length", ",", "max", ":", "numParams", "}", "}", ")", ";", "}", "}" ]

[ "Checks", "a", "function", "to", "see", "if", "it", "has", "too", "many", "parameters", "." ]

[ "function", "reportBegin", "(", "node", ",", "message", ",", "match", ",", "refChar", ")", "{", "const", "type", "=", "node", ".", "type", ".", "toLowerCase", "(", ")", ",", "commentIdentifier", "=", "type", "===", "\"block\"", "?", "\"/*\"", ":", "\"//\"", ";", "context", ".", "report", "(", "{", "node", ",", "fix", "(", "fixer", ")", "{", "const", "start", "=", "node", ".", "range", "[", "0", "]", ";", "let", "end", "=", "start", "+", "2", ";", "if", "(", "requireSpace", ")", "{", "if", "(", "match", ")", "{", "end", "+=", "match", "[", "0", "]", ".", "length", ";", "}", "return", "fixer", ".", "insertTextAfterRange", "(", "[", "start", ",", "end", "]", ",", "\" \"", ")", ";", "}", "end", "+=", "match", "[", "0", "]", ".", "length", ";", "return", "fixer", ".", "replaceTextRange", "(", "[", "start", ",", "end", "]", ",", "commentIdentifier", "+", "(", "match", "[", "1", "]", "?", "match", "[", "1", "]", ":", "\"\"", ")", ")", ";", "}", ",", "message", ",", "data", ":", "{", "refChar", "}", "}", ")", ";", "}" ]

[ "Reports", "a", "beginning", "spacing", "error", "with", "an", "appropriate", "message", "." ]

[ "function", "reportEnd", "(", "node", ",", "message", ",", "match", ")", "{", "context", ".", "report", "(", "{", "node", ",", "fix", "(", "fixer", ")", "{", "if", "(", "requireSpace", ")", "{", "return", "fixer", ".", "insertTextAfterRange", "(", "[", "node", ".", "range", "[", "0", "]", ",", "node", ".", "range", "[", "1", "]", "-", "2", "]", ",", "\" \"", ")", ";", "}", "const", "end", "=", "node", ".", "range", "[", "1", "]", "-", "2", ",", "start", "=", "end", "-", "match", "[", "0", "]", ".", "length", ";", "return", "fixer", ".", "replaceTextRange", "(", "[", "start", ",", "end", "]", ",", "\"\"", ")", ";", "}", ",", "message", "}", ")", ";", "}" ]

[ "Reports", "an", "ending", "spacing", "error", "with", "an", "appropriate", "message", "." ]

[ "function", "checkCommentForSpace", "(", "node", ")", "{", "const", "type", "=", "node", ".", "type", ".", "toLowerCase", "(", ")", ",", "rule", "=", "styleRules", "[", "type", "]", ",", "commentIdentifier", "=", "type", "===", "\"block\"", "?", "\"/*\"", ":", "\"//\"", ";", "// Ignores empty comments.", "if", "(", "node", ".", "value", ".", "length", "===", "0", ")", "{", "return", ";", "}", "const", "beginMatch", "=", "rule", ".", "beginRegex", ".", "exec", "(", "node", ".", "value", ")", ";", "const", "endMatch", "=", "rule", ".", "endRegex", ".", "exec", "(", "node", ".", "value", ")", ";", "// Checks.", "if", "(", "requireSpace", ")", "{", "if", "(", "!", "beginMatch", ")", "{", "const", "hasMarker", "=", "rule", ".", "markers", ".", "exec", "(", "node", ".", "value", ")", ";", "const", "marker", "=", "hasMarker", "?", "commentIdentifier", "+", "hasMarker", "[", "0", "]", ":", "commentIdentifier", ";", "if", "(", "rule", ".", "hasExceptions", ")", "{", "reportBegin", "(", "node", ",", "\"Expected exception block, space or tab after '{{refChar}}' in comment.\"", ",", "hasMarker", ",", "marker", ")", ";", "}", "else", "{", "reportBegin", "(", "node", ",", "\"Expected space or tab after '{{refChar}}' in comment.\"", ",", "hasMarker", ",", "marker", ")", ";", "}", "}", "if", "(", "balanced", "&&", "type", "===", "\"block\"", "&&", "!", "endMatch", ")", "{", "reportEnd", "(", "node", ",", "\"Expected space or tab before '*/' in comment.\"", ")", ";", "}", "}", "else", "{", "if", "(", "beginMatch", ")", "{", "if", "(", "!", "beginMatch", "[", "1", "]", ")", "{", "reportBegin", "(", "node", ",", "\"Unexpected space or tab after '{{refChar}}' in comment.\"", ",", "beginMatch", ",", "commentIdentifier", ")", ";", "}", "else", "{", "reportBegin", "(", "node", ",", "\"Unexpected space or tab after marker ({{refChar}}) in comment.\"", ",", "beginMatch", ",", "beginMatch", "[", "1", "]", ")", ";", "}", "}", "if", "(", "balanced", "&&", "type", "===", "\"block\"", "&&", "endMatch", ")", "{", "reportEnd", "(", "node", ",", "\"Unexpected space or tab before '*/' in comment.\"", ",", "endMatch", ")", ";", "}", "}", "}" ]

[ "Reports", "a", "given", "comment", "if", "it", "s", "invalid", "." ]

[ "function", "isolateBadConfig", "(", "text", ",", "config", ",", "problemType", ")", "{", "for", "(", "const", "ruleId", "of", "Object", ".", "keys", "(", "config", ".", "rules", ")", ")", "{", "const", "reducedConfig", "=", "Object", ".", "assign", "(", "{", "}", ",", "config", ",", "{", "rules", ":", "{", "[", "ruleId", "]", ":", "config", ".", "rules", "[", "ruleId", "]", "}", "}", ")", ";", "let", "fixResult", ";", "try", "{", "fixResult", "=", "linter", ".", "verifyAndFix", "(", "text", ",", "reducedConfig", ",", "{", "}", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "reducedConfig", ";", "}", "if", "(", "fixResult", ".", "messages", ".", "length", "===", "1", "&&", "fixResult", ".", "messages", "[", "0", "]", ".", "fatal", "&&", "problemType", "===", "\"autofix\"", ")", "{", "return", "reducedConfig", ";", "}", "}", "return", "config", ";", "}" ]

[ "Tries", "to", "isolate", "the", "smallest", "config", "that", "reproduces", "a", "problem" ]

[ "function", "isolateBadAutofixPass", "(", "originalText", ",", "config", ")", "{", "let", "lastGoodText", "=", "originalText", ";", "let", "currentText", "=", "originalText", ";", "do", "{", "let", "messages", ";", "try", "{", "messages", "=", "linter", ".", "verify", "(", "currentText", ",", "config", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "lastGoodText", ";", "}", "if", "(", "messages", ".", "length", "===", "1", "&&", "messages", "[", "0", "]", ".", "fatal", ")", "{", "return", "lastGoodText", ";", "}", "lastGoodText", "=", "currentText", ";", "currentText", "=", "SourceCodeFixer", ".", "applyFixes", "(", "currentText", ",", "messages", ")", ".", "output", ";", "}", "while", "(", "lastGoodText", "!==", "currentText", ")", ";", "return", "lastGoodText", ";", "}" ]

[ "Runs", "multipass", "autofix", "one", "pass", "at", "a", "time", "to", "find", "the", "last", "good", "source", "text", "before", "a", "fatal", "error", "occurs" ]

[ "function", "getRelativePath", "(", "filepath", ",", "baseDir", ")", "{", "const", "absolutePath", "=", "path", ".", "isAbsolute", "(", "filepath", ")", "?", "filepath", ":", "path", ".", "resolve", "(", "filepath", ")", ";", "if", "(", "baseDir", ")", "{", "if", "(", "!", "path", ".", "isAbsolute", "(", "baseDir", ")", ")", "{", "throw", "new", "Error", "(", "`", "${", "baseDir", "}", "`", ")", ";", "}", "return", "path", ".", "relative", "(", "baseDir", ",", "absolutePath", ")", ";", "}", "return", "absolutePath", ".", "replace", "(", "/", "^\\/", "/", "u", ",", "\"\"", ")", ";", "}" ]

[ "Converts", "an", "absolute", "filepath", "to", "a", "relative", "path", "from", "a", "given", "base", "path" ]

[ "function", "formatSponsors", "(", "sponsors", ")", "{", "const", "nonEmptySponsors", "=", "Object", ".", "keys", "(", "sponsors", ")", ".", "filter", "(", "tier", "=>", "sponsors", "[", "tier", "]", ".", "length", ">", "0", ")", ";", "/* eslint-disable indent*/", "return", "stripIndents", "`", "${", "nonEmptySponsors", ".", "map", "(", "tier", "=>", "`", "${", "tier", "[", "0", "]", ".", "toUpperCase", "(", ")", "}", "${", "tier", ".", "slice", "(", "1", ")", "}", "${", "sponsors", "[", "tier", "]", ".", "map", "(", "sponsor", "=>", "`", "${", "sponsor", ".", "url", "}", "${", "sponsor", ".", "image", "}", "${", "sponsor", ".", "name", "}", "${", "heights", "[", "tier", "]", "}", "`", ")", ".", "join", "(", "\" \"", ")", "}", "`", ")", ".", "join", "(", "\"\"", ")", "}", "`", ";", "/* eslint-enable indent*/", "}" ]

[ "Formats", "an", "array", "of", "sponsors", "into", "HTML", "for", "the", "readme", "." ]

[ "function", "computeLineLength", "(", "line", ",", "tabWidth", ")", "{", "let", "extraCharacterCount", "=", "0", ";", "line", ".", "replace", "(", "/", "\\t", "/", "gu", ",", "(", "match", ",", "offset", ")", "=>", "{", "const", "totalOffset", "=", "offset", "+", "extraCharacterCount", ",", "previousTabStopOffset", "=", "tabWidth", "?", "totalOffset", "%", "tabWidth", ":", "0", ",", "spaceCount", "=", "tabWidth", "-", "previousTabStopOffset", ";", "extraCharacterCount", "+=", "spaceCount", "-", "1", ";", "// -1 for the replaced tab", "}", ")", ";", "return", "Array", ".", "from", "(", "line", ")", ".", "length", "+", "extraCharacterCount", ";", "}" ]

[ "Computes", "the", "length", "of", "a", "line", "that", "may", "contain", "tabs", ".", "The", "width", "of", "each", "tab", "will", "be", "the", "number", "of", "spaces", "to", "the", "next", "tab", "stop", "." ]

[ "function", "stripTrailingComment", "(", "line", ",", "comment", ")", "{", "// loc.column is zero-indexed", "return", "line", ".", "slice", "(", "0", ",", "comment", ".", "loc", ".", "start", ".", "column", ")", ".", "replace", "(", "/", "\\s+$", "/", "u", ",", "\"\"", ")", ";", "}" ]

[ "Gets", "the", "line", "after", "the", "comment", "and", "any", "remaining", "trailing", "whitespace", "is", "stripped", "." ]

[ "function", "groupByLineNumber", "(", "acc", ",", "node", ")", "{", "for", "(", "let", "i", "=", "node", ".", "loc", ".", "start", ".", "line", ";", "i", "<=", "node", ".", "loc", ".", "end", ".", "line", ";", "++", "i", ")", "{", "ensureArrayAndPush", "(", "acc", ",", "i", ",", "node", ")", ";", "}", "return", "acc", ";", "}" ]

[ "A", "reducer", "to", "group", "an", "AST", "node", "by", "line", "number", "both", "start", "and", "end", "." ]

[ "function", "checkProgramForMaxLength", "(", "node", ")", "{", "// split (honors line-ending)", "const", "lines", "=", "sourceCode", ".", "lines", ",", "// list of comments to ignore", "comments", "=", "ignoreComments", "||", "maxCommentLength", "||", "ignoreTrailingComments", "?", "sourceCode", ".", "getAllComments", "(", ")", ":", "[", "]", ";", "// we iterate over comments in parallel with the lines", "let", "commentsIndex", "=", "0", ";", "const", "strings", "=", "getAllStrings", "(", ")", ";", "const", "stringsByLine", "=", "strings", ".", "reduce", "(", "groupByLineNumber", ",", "{", "}", ")", ";", "const", "templateLiterals", "=", "getAllTemplateLiterals", "(", ")", ";", "const", "templateLiteralsByLine", "=", "templateLiterals", ".", "reduce", "(", "groupByLineNumber", ",", "{", "}", ")", ";", "const", "regExpLiterals", "=", "getAllRegExpLiterals", "(", ")", ";", "const", "regExpLiteralsByLine", "=", "regExpLiterals", ".", "reduce", "(", "groupByLineNumber", ",", "{", "}", ")", ";", "lines", ".", "forEach", "(", "(", "line", ",", "i", ")", "=>", "{", "// i is zero-indexed, line numbers are one-indexed", "const", "lineNumber", "=", "i", "+", "1", ";", "/*\n * if we're checking comment length; we need to know whether this\n * line is a comment\n */", "let", "lineIsComment", "=", "false", ";", "let", "textToMeasure", ";", "/*\n * We can short-circuit the comment checks if we're already out of\n * comments to check.\n */", "if", "(", "commentsIndex", "<", "comments", ".", "length", ")", "{", "let", "comment", "=", "null", ";", "// iterate over comments until we find one past the current line", "do", "{", "comment", "=", "comments", "[", "++", "commentsIndex", "]", ";", "}", "while", "(", "comment", "&&", "comment", ".", "loc", ".", "start", ".", "line", "<=", "lineNumber", ")", ";", "// and step back by one", "comment", "=", "comments", "[", "--", "commentsIndex", "]", ";", "if", "(", "isFullLineComment", "(", "line", ",", "lineNumber", ",", "comment", ")", ")", "{", "lineIsComment", "=", "true", ";", "textToMeasure", "=", "line", ";", "}", "else", "if", "(", "ignoreTrailingComments", "&&", "isTrailingComment", "(", "line", ",", "lineNumber", ",", "comment", ")", ")", "{", "textToMeasure", "=", "stripTrailingComment", "(", "line", ",", "comment", ")", ";", "}", "else", "{", "textToMeasure", "=", "line", ";", "}", "}", "else", "{", "textToMeasure", "=", "line", ";", "}", "if", "(", "ignorePattern", "&&", "ignorePattern", ".", "test", "(", "textToMeasure", ")", "||", "ignoreUrls", "&&", "URL_REGEXP", ".", "test", "(", "textToMeasure", ")", "||", "ignoreStrings", "&&", "stringsByLine", "[", "lineNumber", "]", "||", "ignoreTemplateLiterals", "&&", "templateLiteralsByLine", "[", "lineNumber", "]", "||", "ignoreRegExpLiterals", "&&", "regExpLiteralsByLine", "[", "lineNumber", "]", ")", "{", "// ignore this line", "return", ";", "}", "const", "lineLength", "=", "computeLineLength", "(", "textToMeasure", ",", "tabWidth", ")", ";", "const", "commentLengthApplies", "=", "lineIsComment", "&&", "maxCommentLength", ";", "if", "(", "lineIsComment", "&&", "ignoreComments", ")", "{", "return", ";", "}", "if", "(", "commentLengthApplies", ")", "{", "if", "(", "lineLength", ">", "maxCommentLength", ")", "{", "context", ".", "report", "(", "{", "node", ",", "loc", ":", "{", "line", ":", "lineNumber", ",", "column", ":", "0", "}", ",", "messageId", ":", "\"maxComment\"", ",", "data", ":", "{", "lineNumber", ":", "i", "+", "1", ",", "maxCommentLength", "}", "}", ")", ";", "}", "}", "else", "if", "(", "lineLength", ">", "maxLength", ")", "{", "context", ".", "report", "(", "{", "node", ",", "loc", ":", "{", "line", ":", "lineNumber", ",", "column", ":", "0", "}", ",", "messageId", ":", "\"max\"", ",", "data", ":", "{", "lineNumber", ":", "i", "+", "1", ",", "maxLength", "}", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Check", "the", "program", "for", "max", "length" ]

[ "function", "isConstant", "(", "node", ",", "name", ")", "{", "switch", "(", "node", ".", "type", ")", "{", "case", "\"Literal\"", ":", "return", "node", ".", "value", "===", "name", ";", "case", "\"TemplateLiteral\"", ":", "return", "(", "node", ".", "expressions", ".", "length", "===", "0", "&&", "node", ".", "quasis", "[", "0", "]", ".", "value", ".", "cooked", "===", "name", ")", ";", "default", ":", "return", "false", ";", "}", "}" ]

[ "Checks", "a", "given", "node", "is", "a", "Literal", "node", "of", "the", "specified", "string", "value", "." ]

[ "function", "report", "(", "node", ")", "{", "const", "parent", "=", "node", ".", "parent", ";", "const", "locationNode", "=", "node", ".", "type", "===", "\"MemberExpression\"", "?", "node", ".", "property", ":", "node", ";", "const", "reportNode", "=", "parent", ".", "type", "===", "\"CallExpression\"", "&&", "parent", ".", "callee", "===", "node", "?", "parent", ":", "node", ";", "context", ".", "report", "(", "{", "node", ":", "reportNode", ",", "loc", ":", "locationNode", ".", "loc", ".", "start", ",", "messageId", ":", "\"unexpected\"", "}", ")", ";", "}" ]

[ "Reports", "a", "given", "node", "." ]

[ "function", "reportAccessingEvalViaGlobalObject", "(", "globalScope", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "candidatesOfGlobalObject", ".", "length", ";", "++", "i", ")", "{", "const", "name", "=", "candidatesOfGlobalObject", "[", "i", "]", ";", "const", "variable", "=", "astUtils", ".", "getVariableByName", "(", "globalScope", ",", "name", ")", ";", "if", "(", "!", "variable", ")", "{", "continue", ";", "}", "const", "references", "=", "variable", ".", "references", ";", "for", "(", "let", "j", "=", "0", ";", "j", "<", "references", ".", "length", ";", "++", "j", ")", "{", "const", "identifier", "=", "references", "[", "j", "]", ".", "identifier", ";", "let", "node", "=", "identifier", ".", "parent", ";", "// To detect code like `window.window.eval`.", "while", "(", "isMember", "(", "node", ",", "name", ")", ")", "{", "node", "=", "node", ".", "parent", ";", "}", "// Reports.", "if", "(", "isMember", "(", "node", ",", "\"eval\"", ")", ")", "{", "report", "(", "node", ")", ";", "}", "}", "}", "}" ]

[ "Reports", "accesses", "of", "eval", "via", "the", "global", "object", "." ]

[ "function", "getShorthandName", "(", "fullname", ",", "prefix", ")", "{", "if", "(", "fullname", "[", "0", "]", "===", "\"@\"", ")", "{", "let", "matchResult", "=", "new", "RegExp", "(", "`", "${", "prefix", "}", "`", ",", "\"u\"", ")", ".", "exec", "(", "fullname", ")", ";", "if", "(", "matchResult", ")", "{", "return", "matchResult", "[", "1", "]", ";", "}", "matchResult", "=", "new", "RegExp", "(", "`", "${", "prefix", "}", "`", ",", "\"u\"", ")", ".", "exec", "(", "fullname", ")", ";", "if", "(", "matchResult", ")", "{", "return", "`", "${", "matchResult", "[", "1", "]", "}", "${", "matchResult", "[", "2", "]", "}", "`", ";", "}", "}", "else", "if", "(", "fullname", ".", "startsWith", "(", "`", "${", "prefix", "}", "`", ")", ")", "{", "return", "fullname", ".", "slice", "(", "prefix", ".", "length", "+", "1", ")", ";", "}", "return", "fullname", ";", "}" ]

[ "Removes", "the", "prefix", "from", "a", "fullname", "." ]

[ "function", "isStringContained", "(", "compare", ",", "compareWith", ")", "{", "const", "curatedCompareWith", "=", "curateString", "(", "compareWith", ")", ";", "const", "curatedCompare", "=", "curateString", "(", "compare", ")", ";", "if", "(", "!", "curatedCompareWith", "||", "!", "curatedCompare", ")", "{", "return", "false", ";", "}", "return", "curatedCompareWith", ".", "includes", "(", "curatedCompare", ")", ";", "}" ]

[ "Check", "if", "a", "given", "text", "exists", "in", "another" ]

[ "function", "curateString", "(", "str", ")", "{", "const", "noUnicodeStr", "=", "text", ".", "removeUnicode", "(", "str", ",", "{", "emoji", ":", "true", ",", "nonBmp", ":", "true", ",", "punctuations", ":", "true", "}", ")", ";", "return", "text", ".", "sanitize", "(", "noUnicodeStr", ")", ";", "}" ]

[ "Curate", "given", "text", "by", "removing", "emoji", "s", "punctuations", "unicode", "and", "trim", "whitespace", "." ]

[ "function", "findTextMethods", "(", "virtualNode", ")", "{", "const", "{", "nativeElementType", ",", "nativeTextMethods", "}", "=", "text", ";", "const", "nativeType", "=", "nativeElementType", ".", "find", "(", "(", "{", "matches", "}", ")", "=>", "{", "return", "axe", ".", "commons", ".", "matches", "(", "virtualNode", ",", "matches", ")", ";", "}", ")", ";", "// Use concat because namingMethods can be a string or an array of strings", "const", "methods", "=", "nativeType", "?", "[", "]", ".", "concat", "(", "nativeType", ".", "namingMethods", ")", ":", "[", "]", ";", "return", "methods", ".", "map", "(", "methodName", "=>", "nativeTextMethods", "[", "methodName", "]", ")", ";", "}" ]

[ "Get", "accessible", "text", "functions", "for", "a", "specific", "native", "HTML", "element" ]

[ "function", "shouldMatchElement", "(", "el", ")", "{", "if", "(", "!", "el", ")", "{", "return", "true", ";", "}", "if", "(", "el", ".", "getAttribute", "(", "'aria-hidden'", ")", "===", "'true'", ")", "{", "return", "false", ";", "}", "return", "shouldMatchElement", "(", "getComposedParent", "(", "el", ")", ")", ";", "}" ]

[ "Only", "match", "the", "outer", "-", "most", "aria", "-", "hidden", "=", "true", "element" ]

[ "function", "getAttributeNameValue", "(", "node", ",", "at", ")", "{", "const", "name", "=", "at", ".", "name", ";", "let", "atnv", ";", "if", "(", "name", ".", "indexOf", "(", "'href'", ")", "!==", "-", "1", "||", "name", ".", "indexOf", "(", "'src'", ")", "!==", "-", "1", ")", "{", "let", "friendly", "=", "axe", ".", "utils", ".", "getFriendlyUriEnd", "(", "node", ".", "getAttribute", "(", "name", ")", ")", ";", "if", "(", "friendly", ")", "{", "let", "value", "=", "encodeURI", "(", "friendly", ")", ";", "if", "(", "value", ")", "{", "atnv", "=", "escapeSelector", "(", "at", ".", "name", ")", "+", "'$=\"'", "+", "escapeSelector", "(", "value", ")", "+", "'\"'", ";", "}", "else", "{", "return", ";", "}", "}", "else", "{", "atnv", "=", "escapeSelector", "(", "at", ".", "name", ")", "+", "'=\"'", "+", "escapeSelector", "(", "node", ".", "getAttribute", "(", "name", ")", ")", "+", "'\"'", ";", "}", "}", "else", "{", "atnv", "=", "escapeSelector", "(", "name", ")", "+", "'=\"'", "+", "escapeSelector", "(", "at", ".", "value", ")", "+", "'\"'", ";", "}", "return", "atnv", ";", "}" ]

[ "get", "the", "attribute", "name", "and", "value", "as", "a", "string" ]

[ "function", "filterAttributes", "(", "at", ")", "{", "return", "(", "!", "ignoredAttributes", ".", "includes", "(", "at", ".", "name", ")", "&&", "at", ".", "name", ".", "indexOf", "(", "':'", ")", "===", "-", "1", "&&", "(", "!", "at", ".", "value", "||", "at", ".", "value", ".", "length", "<", "MAXATTRIBUTELENGTH", ")", ")", ";", "}" ]

[ "Filter", "the", "attributes" ]

[ "function", "uncommonClasses", "(", "node", ",", "selectorData", ")", "{", "// eslint no-loop-func:false", "let", "retVal", "=", "[", "]", ";", "let", "classData", "=", "selectorData", ".", "classes", ";", "let", "tagData", "=", "selectorData", ".", "tags", ";", "if", "(", "node", ".", "classList", ")", "{", "Array", ".", "from", "(", "node", ".", "classList", ")", ".", "forEach", "(", "cl", "=>", "{", "let", "ind", "=", "escapeSelector", "(", "cl", ")", ";", "if", "(", "classData", "[", "ind", "]", "<", "tagData", "[", "node", ".", "nodeName", "]", ")", "{", "retVal", ".", "push", "(", "{", "name", ":", "ind", ",", "count", ":", "classData", "[", "ind", "]", ",", "species", ":", "'class'", "}", ")", ";", "}", "}", ")", ";", "}", "return", "retVal", ".", "sort", "(", "countSort", ")", ";", "}" ]

[ "Given", "a", "node", "and", "the", "statistics", "on", "class", "frequency", "on", "the", "page", "return", "all", "its", "uncommon", "class", "data", "sorted", "in", "order", "of", "decreasing", "uniqueness" ]

[ "function", "getElmId", "(", "elm", ")", "{", "if", "(", "!", "elm", ".", "getAttribute", "(", "'id'", ")", ")", "{", "return", ";", "}", "let", "doc", "=", "(", "elm", ".", "getRootNode", "&&", "elm", ".", "getRootNode", "(", ")", ")", "||", "document", ";", "const", "id", "=", "'#'", "+", "escapeSelector", "(", "elm", ".", "getAttribute", "(", "'id'", ")", "||", "''", ")", ";", "if", "(", "// Don't include youtube's uid values, they change\ton reload", "!", "id", ".", "match", "(", "/", "player_uid_", "/", ")", "&&", "// Don't include IDs that occur more then once on the page", "doc", ".", "querySelectorAll", "(", "id", ")", ".", "length", "===", "1", ")", "{", "return", "id", ";", "}", "}" ]

[ "Get", "ID", "selector" ]

[ "function", "getBaseSelector", "(", "elm", ")", "{", "if", "(", "typeof", "isXHTML", "===", "'undefined'", ")", "{", "isXHTML", "=", "axe", ".", "utils", ".", "isXHTML", "(", "document", ")", ";", "}", "return", "escapeSelector", "(", "isXHTML", "?", "elm", ".", "localName", ":", "elm", ".", "nodeName", ".", "toLowerCase", "(", ")", ")", ";", "}" ]

[ "Return", "the", "base", "CSS", "selector", "for", "a", "given", "element" ]

[ "function", "uncommonAttributes", "(", "node", ",", "selectorData", ")", "{", "let", "retVal", "=", "[", "]", ";", "let", "attData", "=", "selectorData", ".", "attributes", ";", "let", "tagData", "=", "selectorData", ".", "tags", ";", "if", "(", "node", ".", "hasAttributes", "(", ")", ")", "{", "Array", ".", "from", "(", "axe", ".", "utils", ".", "getNodeAttributes", "(", "node", ")", ")", ".", "filter", "(", "filterAttributes", ")", ".", "forEach", "(", "at", "=>", "{", "const", "atnv", "=", "getAttributeNameValue", "(", "node", ",", "at", ")", ";", "if", "(", "atnv", "&&", "attData", "[", "atnv", "]", "<", "tagData", "[", "node", ".", "nodeName", "]", ")", "{", "retVal", ".", "push", "(", "{", "name", ":", "atnv", ",", "count", ":", "attData", "[", "atnv", "]", ",", "species", ":", "'attribute'", "}", ")", ";", "}", "}", ")", ";", "}", "return", "retVal", ".", "sort", "(", "countSort", ")", ";", "}" ]

[ "Given", "a", "node", "and", "the", "statistics", "on", "attribute", "frequency", "on", "the", "page", "return", "all", "its", "uncommon", "attribute", "data", "sorted", "in", "order", "of", "decreasing", "uniqueness" ]

[ "function", "generateSelector", "(", "elm", ",", "options", ",", "doc", ")", "{", "/*eslint no-loop-func:0*/", "if", "(", "!", "axe", ".", "_selectorData", ")", "{", "throw", "new", "Error", "(", "'Expect axe._selectorData to be set up'", ")", ";", "}", "const", "{", "toRoot", "=", "false", "}", "=", "options", ";", "let", "selector", ";", "let", "similar", ";", "/**\n\t * Try to find a unique selector by filtering out all the clashing\n\t * nodes by adding ancestor selectors iteratively.\n\t * This loop is much faster than recursing and using querySelectorAll\n\t */", "do", "{", "let", "features", "=", "getElmId", "(", "elm", ")", ";", "if", "(", "!", "features", ")", "{", "features", "=", "getThreeLeastCommonFeatures", "(", "elm", ",", "axe", ".", "_selectorData", ")", ";", "features", "+=", "getNthChildString", "(", "elm", ",", "features", ")", ";", "}", "if", "(", "selector", ")", "{", "selector", "=", "features", "+", "' > '", "+", "selector", ";", "}", "else", "{", "selector", "=", "features", ";", "}", "if", "(", "!", "similar", ")", "{", "similar", "=", "Array", ".", "from", "(", "doc", ".", "querySelectorAll", "(", "selector", ")", ")", ";", "}", "else", "{", "similar", "=", "similar", ".", "filter", "(", "item", "=>", "{", "return", "axe", ".", "utils", ".", "matchesSelector", "(", "item", ",", "selector", ")", ";", "}", ")", ";", "}", "elm", "=", "elm", ".", "parentElement", ";", "}", "while", "(", "(", "similar", ".", "length", ">", "1", "||", "toRoot", ")", "&&", "elm", "&&", "elm", ".", "nodeType", "!==", "11", ")", ";", "if", "(", "similar", ".", "length", "===", "1", ")", "{", "return", "selector", ";", "}", "else", "if", "(", "selector", ".", "indexOf", "(", "' > '", ")", "!==", "-", "1", ")", "{", "// For the odd case that document doesn't have a unique selector", "return", "':root'", "+", "selector", ".", "substring", "(", "selector", ".", "indexOf", "(", "' > '", ")", ")", ";", "}", "return", "':root'", ";", "}" ]

[ "generates", "a", "single", "selector", "for", "an", "element" ]

[ "function", "matchTags", "(", "rule", ",", "runOnly", ")", "{", "'use strict'", ";", "var", "include", ",", "exclude", ",", "matching", ";", "var", "defaultExclude", "=", "axe", ".", "_audit", "&&", "axe", ".", "_audit", ".", "tagExclude", "?", "axe", ".", "_audit", ".", "tagExclude", ":", "[", "]", ";", "// normalize include/exclude", "if", "(", "runOnly", ".", "hasOwnProperty", "(", "'include'", ")", "||", "runOnly", ".", "hasOwnProperty", "(", "'exclude'", ")", ")", "{", "// Wrap include and exclude if it's not already an array", "include", "=", "runOnly", ".", "include", "||", "[", "]", ";", "include", "=", "Array", ".", "isArray", "(", "include", ")", "?", "include", ":", "[", "include", "]", ";", "exclude", "=", "runOnly", ".", "exclude", "||", "[", "]", ";", "exclude", "=", "Array", ".", "isArray", "(", "exclude", ")", "?", "exclude", ":", "[", "exclude", "]", ";", "// add defaults, unless mentioned in include", "exclude", "=", "exclude", ".", "concat", "(", "defaultExclude", ".", "filter", "(", "function", "(", "tag", ")", "{", "return", "include", ".", "indexOf", "(", "tag", ")", "===", "-", "1", ";", "}", ")", ")", ";", "// Otherwise, only use the include value, ignore exclude", "}", "else", "{", "include", "=", "Array", ".", "isArray", "(", "runOnly", ")", "?", "runOnly", ":", "[", "runOnly", "]", ";", "// exclude the defaults not included", "exclude", "=", "defaultExclude", ".", "filter", "(", "function", "(", "tag", ")", "{", "return", "include", ".", "indexOf", "(", "tag", ")", "===", "-", "1", ";", "}", ")", ";", "}", "matching", "=", "include", ".", "some", "(", "function", "(", "tag", ")", "{", "return", "rule", ".", "tags", ".", "indexOf", "(", "tag", ")", "!==", "-", "1", ";", "}", ")", ";", "if", "(", "matching", "||", "(", "include", ".", "length", "===", "0", "&&", "rule", ".", "enabled", "!==", "false", ")", ")", "{", "return", "exclude", ".", "every", "(", "function", "(", "tag", ")", "{", "return", "rule", ".", "tags", ".", "indexOf", "(", "tag", ")", "===", "-", "1", ";", "}", ")", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Check", "if", "a", "rule", "matches", "the", "value", "of", "runOnly", "type", "=", "tag" ]

[ "function", "getDeepest", "(", "collection", ")", "{", "'use strict'", ";", "return", "collection", ".", "sort", "(", "function", "(", "a", ",", "b", ")", "{", "if", "(", "axe", ".", "utils", ".", "contains", "(", "a", ",", "b", ")", ")", "{", "return", "1", ";", "}", "return", "-", "1", ";", "}", ")", "[", "0", "]", ";", "}" ]

[ "Get", "the", "deepest", "node", "in", "a", "given", "collection" ]

[ "function", "isNodeInContext", "(", "node", ",", "context", ")", "{", "'use strict'", ";", "var", "include", "=", "context", ".", "include", "&&", "getDeepest", "(", "context", ".", "include", ".", "filter", "(", "function", "(", "candidate", ")", "{", "return", "axe", ".", "utils", ".", "contains", "(", "candidate", ",", "node", ")", ";", "}", ")", ")", ";", "var", "exclude", "=", "context", ".", "exclude", "&&", "getDeepest", "(", "context", ".", "exclude", ".", "filter", "(", "function", "(", "candidate", ")", "{", "return", "axe", ".", "utils", ".", "contains", "(", "candidate", ",", "node", ")", ";", "}", ")", ")", ";", "if", "(", "(", "!", "exclude", "&&", "include", ")", "||", "(", "exclude", "&&", "axe", ".", "utils", ".", "contains", "(", "exclude", ",", "include", ")", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Determines", "if", "a", "node", "is", "included", "or", "excluded", "in", "a", "given", "context" ]

[ "function", "pushNode", "(", "result", ",", "nodes", ")", "{", "'use strict'", ";", "var", "temp", ";", "if", "(", "result", ".", "length", "===", "0", ")", "{", "return", "nodes", ";", "}", "if", "(", "result", ".", "length", "<", "nodes", ".", "length", ")", "{", "// switch so the comparison is shortest", "temp", "=", "result", ";", "result", "=", "nodes", ";", "nodes", "=", "temp", ";", "}", "for", "(", "var", "i", "=", "0", ",", "l", "=", "nodes", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "if", "(", "!", "result", ".", "includes", "(", "nodes", "[", "i", "]", ")", ")", "{", "result", ".", "push", "(", "nodes", "[", "i", "]", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Pushes", "unique", "nodes", "that", "are", "in", "context", "to", "an", "array" ]

[ "function", "reduceIncludes", "(", "includes", ")", "{", "return", "includes", ".", "reduce", "(", "(", "res", ",", "el", ")", "=>", "{", "if", "(", "!", "res", ".", "length", "||", "!", "res", "[", "res", ".", "length", "-", "1", "]", ".", "actualNode", ".", "contains", "(", "el", ".", "actualNode", ")", ")", "{", "res", ".", "push", "(", "el", ")", ";", "}", "return", "res", ";", "}", ",", "[", "]", ")", ";", "}" ]

[ "reduces", "the", "includes", "list", "to", "only", "the", "outermost", "includes" ]

[ "function", "getExplicitLabels", "(", "{", "actualNode", "}", ")", "{", "if", "(", "!", "actualNode", ".", "id", ")", "{", "return", "[", "]", ";", "}", "return", "dom", ".", "findElmsInContext", "(", "{", "elm", ":", "'label'", ",", "attr", ":", "'for'", ",", "value", ":", "actualNode", ".", "id", ",", "context", ":", "actualNode", "}", ")", ";", "}" ]

[ "Find", "a", "non", "-", "ARIA", "label", "for", "an", "element" ]

[ "function", "sortPageBackground", "(", "elmStack", ")", "{", "let", "bodyIndex", "=", "elmStack", ".", "indexOf", "(", "document", ".", "body", ")", ";", "let", "bgNodes", "=", "elmStack", ";", "if", "(", "// Check that the body background is the page's background", "bodyIndex", ">", "1", "&&", "// only if there are negative z-index elements", "!", "color", ".", "elementHasImage", "(", "document", ".", "documentElement", ")", "&&", "color", ".", "getOwnBackgroundColor", "(", "window", ".", "getComputedStyle", "(", "document", ".", "documentElement", ")", ")", ".", "alpha", "===", "0", ")", "{", "// Remove body and html from it's current place", "bgNodes", ".", "splice", "(", "bodyIndex", ",", "1", ")", ";", "bgNodes", ".", "splice", "(", "elmStack", ".", "indexOf", "(", "document", ".", "documentElement", ")", ",", "1", ")", ";", "// Put the body background as the lowest element", "bgNodes", ".", "push", "(", "document", ".", "body", ")", ";", "}", "return", "bgNodes", ";", "}" ]

[ "Look", "at", "document", "and", "body", "elements", "for", "relevant", "background", "information" ]

[ "function", "elmPartiallyObscured", "(", "elm", ",", "bgElm", ",", "bgColor", ")", "{", "var", "obscured", "=", "elm", "!==", "bgElm", "&&", "!", "dom", ".", "visuallyContains", "(", "elm", ",", "bgElm", ")", "&&", "bgColor", ".", "alpha", "!==", "0", ";", "if", "(", "obscured", ")", "{", "axe", ".", "commons", ".", "color", ".", "incompleteData", ".", "set", "(", "'bgColor'", ",", "'elmPartiallyObscured'", ")", ";", "}", "return", "obscured", ";", "}" ]

[ "Determine", "if", "element", "is", "partially", "overlapped", "triggering", "a", "Can", "t", "Tell", "result" ]

[ "function", "calculateObscuringAlpha", "(", "elmIndex", ",", "elmStack", ",", "originalElm", ")", "{", "var", "totalAlpha", "=", "0", ";", "if", "(", "elmIndex", ">", "0", ")", "{", "// there are elements above our element, check if they contribute to the background", "for", "(", "var", "i", "=", "elmIndex", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "let", "bgElm", "=", "elmStack", "[", "i", "]", ";", "let", "bgElmStyle", "=", "window", ".", "getComputedStyle", "(", "bgElm", ")", ";", "let", "bgColor", "=", "color", ".", "getOwnBackgroundColor", "(", "bgElmStyle", ")", ";", "if", "(", "bgColor", ".", "alpha", "&&", "contentOverlapping", "(", "originalElm", ",", "bgElm", ")", ")", "{", "totalAlpha", "+=", "bgColor", ".", "alpha", ";", "}", "else", "{", "// remove elements not contributing to the background", "elmStack", ".", "splice", "(", "i", ",", "1", ")", ";", "}", "}", "}", "return", "totalAlpha", ";", "}" ]

[ "Calculate", "alpha", "transparency", "of", "a", "background", "element", "obscuring", "the", "current", "node" ]

[ "function", "contentOverlapping", "(", "targetElement", ",", "bgNode", ")", "{", "// get content box of target element", "// check to see if the current bgNode is overlapping", "var", "targetRect", "=", "targetElement", ".", "getClientRects", "(", ")", "[", "0", "]", ";", "var", "obscuringElements", "=", "dom", ".", "shadowElementsFromPoint", "(", "targetRect", ".", "left", ",", "targetRect", ".", "top", ")", ";", "if", "(", "obscuringElements", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "obscuringElements", ".", "length", ";", "i", "++", ")", "{", "if", "(", "obscuringElements", "[", "i", "]", "!==", "targetElement", "&&", "obscuringElements", "[", "i", "]", "===", "bgNode", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "Determines", "overlap", "of", "node", "s", "content", "with", "a", "bgNode", ".", "Used", "for", "inline", "elements" ]

[ "function", "(", "key", ",", "reason", ")", "{", "if", "(", "typeof", "key", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'Incomplete data: key must be a string'", ")", ";", "}", "if", "(", "reason", ")", "{", "data", "[", "key", "]", "=", "reason", ";", "}", "return", "data", "[", "key", "]", ";", "}" ]

[ "Store", "incomplete", "data", "by", "key", "with", "a", "string", "value" ]

[ "function", "nativeSelectValue", "(", "node", ")", "{", "node", "=", "node", ".", "actualNode", "||", "node", ";", "if", "(", "node", ".", "nodeName", ".", "toUpperCase", "(", ")", "!==", "'SELECT'", ")", "{", "return", "''", ";", "}", "return", "(", "Array", ".", "from", "(", "node", ".", "options", ")", ".", "filter", "(", "option", "=>", "option", ".", "selected", ")", ".", "map", "(", "option", "=>", "option", ".", "text", ")", ".", "join", "(", "' '", ")", "||", "''", ")", ";", "}" ]

[ "Calculate", "value", "of", "a", "select", "element" ]

[ "function", "ariaTextboxValue", "(", "virtualNode", ")", "{", "const", "{", "actualNode", "}", "=", "virtualNode", ";", "const", "role", "=", "aria", ".", "getRole", "(", "actualNode", ")", ";", "if", "(", "role", "!==", "'textbox'", ")", "{", "return", "''", ";", "}", "if", "(", "!", "dom", ".", "isHiddenWithCSS", "(", "actualNode", ")", ")", "{", "return", "text", ".", "visibleVirtual", "(", "virtualNode", ",", "true", ")", ";", "}", "else", "{", "return", "actualNode", ".", "textContent", ";", "}", "}" ]

[ "Calculate", "value", "of", "a", "an", "element", "with", "role", "=", "textbox" ]

[ "function", "ariaRangeValue", "(", "node", ")", "{", "node", "=", "node", ".", "actualNode", "||", "node", ";", "const", "role", "=", "aria", ".", "getRole", "(", "node", ")", ";", "if", "(", "!", "rangeRoles", ".", "includes", "(", "role", ")", "||", "!", "node", ".", "hasAttribute", "(", "'aria-valuenow'", ")", ")", "{", "return", "''", ";", "}", "// Validate the number, if not, return 0.", "// Chrome 70 typecasts this, Firefox 62 does not", "const", "valueNow", "=", "+", "node", ".", "getAttribute", "(", "'aria-valuenow'", ")", ";", "return", "!", "isNaN", "(", "valueNow", ")", "?", "String", "(", "valueNow", ")", ":", "'0'", ";", "}" ]

[ "Calculate", "value", "of", "an", "element", "with", "range", "-", "type", "role" ]

[ "function", "(", "e", ")", "{", "err", "=", "e", ";", "setTimeout", "(", "function", "(", ")", "{", "if", "(", "err", "!==", "undefined", "&&", "err", "!==", "null", ")", "{", "axe", ".", "log", "(", "'Uncaught error (of queue)'", ",", "err", ")", ";", "}", "}", ",", "1", ")", ";", "}" ]

[ "By", "default", "wait", "until", "the", "next", "tick", "if", "no", "catch", "was", "set", "throw", "to", "console", "." ]

[ "function", "(", "fn", ")", "{", "if", "(", "typeof", "fn", "===", "'object'", "&&", "fn", ".", "then", "&&", "fn", ".", "catch", ")", "{", "var", "defer", "=", "fn", ";", "fn", "=", "function", "(", "resolve", ",", "reject", ")", "{", "defer", ".", "then", "(", "resolve", ")", ".", "catch", "(", "reject", ")", ";", "}", ";", "}", "funcGuard", "(", "fn", ")", ";", "if", "(", "err", "!==", "undefined", ")", "{", "return", ";", "}", "else", "if", "(", "complete", ")", "{", "throw", "new", "Error", "(", "'Queue already completed'", ")", ";", "}", "tasks", ".", "push", "(", "fn", ")", ";", "++", "remaining", ";", "pop", "(", ")", ";", "return", "q", ";", "}" ]

[ "Defer", "a", "function", "that", "may", "or", "may", "not", "run", "asynchronously", "." ]

[ "function", "(", "fn", ")", "{", "funcGuard", "(", "fn", ")", ";", "if", "(", "completeQueue", "!==", "noop", ")", "{", "throw", "new", "Error", "(", "'queue `then` already set'", ")", ";", "}", "if", "(", "!", "err", ")", "{", "completeQueue", "=", "fn", ";", "if", "(", "!", "remaining", ")", "{", "complete", "=", "true", ";", "completeQueue", "(", "tasks", ")", ";", "}", "}", "return", "q", ";", "}" ]

[ "The", "callback", "to", "execute", "once", "all", "deferred", "functions", "have", "completed", ".", "Will", "only", "be", "invoked", "once", "." ]

[ "function", "getAriaQueryAttributes", "(", ")", "{", "const", "ariaKeys", "=", "Array", ".", "from", "(", "props", ")", ".", "map", "(", "(", "[", "key", "]", ")", "=>", "key", ")", ";", "const", "roleAriaKeys", "=", "Array", ".", "from", "(", "roles", ")", ".", "reduce", "(", "(", "out", ",", "[", "name", ",", "rule", "]", ")", "=>", "{", "return", "[", "...", "out", ",", "...", "Object", ".", "keys", "(", "rule", ".", "props", ")", "]", ";", "}", ",", "[", "]", ")", ";", "return", "new", "Set", "(", "axe", ".", "utils", ".", "uniqueArray", "(", "roleAriaKeys", ",", "ariaKeys", ")", ")", ";", "}" ]

[ "Get", "list", "of", "aria", "attributes", "from", "aria", "-", "query" ]

[ "function", "getDiff", "(", "base", ",", "subject", ",", "type", ")", "{", "const", "diff", "=", "[", "]", ";", "const", "notes", "=", "[", "]", ";", "const", "sortedBase", "=", "Array", ".", "from", "(", "base", ".", "entries", "(", ")", ")", ".", "sort", "(", ")", ";", "sortedBase", ".", "forEach", "(", "(", "[", "key", "]", "=", "item", ")", "=>", "{", "switch", "(", "type", ")", "{", "case", "'supported'", ":", "if", "(", "subject", ".", "hasOwnProperty", "(", "key", ")", "&&", "subject", "[", "key", "]", ".", "unsupported", "===", "false", ")", "{", "diff", ".", "push", "(", "[", "`", "${", "key", "}", "`", ",", "'Yes'", "]", ")", ";", "}", "break", ";", "case", "'unsupported'", ":", "if", "(", "(", "subject", "[", "key", "]", "&&", "subject", "[", "key", "]", ".", "unsupported", "===", "true", ")", "||", "!", "subject", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "diff", ".", "push", "(", "[", "`", "${", "key", "}", "`", ",", "'No'", "]", ")", ";", "}", "else", "if", "(", "subject", "[", "key", "]", "&&", "subject", "[", "key", "]", ".", "unsupported", "&&", "subject", "[", "key", "]", ".", "unsupported", ".", "exceptions", ")", "{", "diff", ".", "push", "(", "[", "`", "${", "key", "}", "`", ",", "`", "${", "notes", ".", "length", "+", "1", "}", "`", "]", ")", ";", "notes", ".", "push", "(", "getSupportedElementsAsFootnote", "(", "subject", "[", "key", "]", ".", "unsupported", ".", "exceptions", ")", ")", ";", "}", "break", ";", "case", "'all'", ":", "default", ":", "diff", ".", "push", "(", "[", "`", "${", "key", "}", "`", ",", "subject", ".", "hasOwnProperty", "(", "key", ")", "&&", "subject", "[", "key", "]", ".", "unsupported", "===", "false", "?", "'Yes'", ":", "'No'", "]", ")", ";", "break", ";", "}", "}", ")", ";", "return", "{", "diff", ",", "notes", "}", ";", "}" ]

[ "Given", "a", "base", "Map", "and", "subject", "Map", "object", "The", "function", "converts", "the", "base", "Map", "entries", "to", "an", "array", "which", "is", "sorted", "then", "enumerated", "to", "compare", "each", "entry", "against", "the", "subject", "Map", "The", "function", "constructs", "a", "string", "to", "represent", "a", "markdown", "table", "as", "well", "as", "returns", "notes", "to", "append", "to", "footnote" ]

[ "function", "getSupportedElementsAsFootnote", "(", "elements", ")", "{", "const", "notes", "=", "[", "]", ";", "const", "supportedElements", "=", "elements", ".", "map", "(", "element", "=>", "{", "if", "(", "typeof", "element", "===", "'string'", ")", "{", "return", "`", "\\`", "${", "element", "}", "\\`", "`", ";", "}", "/**\n\t\t\t\t\t * if element is not a string it will be an object with structure:\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tnodeName: string,\n\t\t\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\t\t\ttype: {string|string[]}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t*/", "return", "Object", ".", "keys", "(", "element", ".", "properties", ")", ".", "map", "(", "prop", "=>", "{", "const", "value", "=", "element", ".", "properties", "[", "prop", "]", ";", "// the 'type' property can be a string or an array", "if", "(", "typeof", "value", "===", "'string'", ")", "{", "return", "`", "\\`", "${", "element", ".", "nodeName", "}", "${", "prop", "}", "${", "value", "}", "\\`", "`", ";", "}", "// output format for an array of types:", "// <input type=\"button\" | \"checkbox\">", "const", "values", "=", "value", ".", "map", "(", "v", "=>", "`", "${", "v", "}", "`", ")", ".", "join", "(", "' | '", ")", ";", "return", "`", "\\`", "${", "element", ".", "nodeName", "}", "${", "prop", "}", "${", "values", "}", "\\`", "`", ";", "}", ")", ";", "}", ")", ";", "notes", ".", "push", "(", "'Supported on elements: '", "+", "supportedElements", ".", "join", "(", "', '", ")", ")", ";", "return", "notes", ";", "}" ]

[ "Parse", "a", "list", "of", "unsupported", "exception", "elements", "and", "add", "a", "footnote", "detailing", "which", "HTML", "elements", "are", "supported", "." ]

[ "function", "shouldIgnoreHidden", "(", "{", "actualNode", "}", ",", "context", ")", "{", "if", "(", "// If the parent isn't ignored, the text node should not be either", "actualNode", ".", "nodeType", "!==", "1", "||", "// If the target of aria-labelledby is hidden, ignore all descendents", "context", ".", "includeHidden", ")", "{", "return", "false", ";", "}", "return", "!", "dom", ".", "isVisible", "(", "actualNode", ",", "true", ")", ";", "}" ]

[ "Check", "if", "the" ]

[ "function", "prepareContext", "(", "virtualNode", ",", "context", ")", "{", "const", "{", "actualNode", "}", "=", "virtualNode", ";", "if", "(", "!", "context", ".", "startNode", ")", "{", "context", "=", "{", "startNode", ":", "virtualNode", ",", "...", "context", "}", ";", "}", "/**\n\t * When `aria-labelledby` directly references a `hidden` element\n\t * the element needs to be included in the accessible name.\n\t *\n\t * When a descendent of the `aria-labelledby` reference is `hidden`\n\t * the element should not be included in the accessible name.\n\t *\n\t * This is done by setting `includeHidden` for the `aria-labelledby` reference.\n\t */", "if", "(", "actualNode", ".", "nodeType", "===", "1", "&&", "context", ".", "inLabelledByContext", "&&", "context", ".", "includeHidden", "===", "undefined", ")", "{", "context", "=", "{", "includeHidden", ":", "!", "dom", ".", "isVisible", "(", "actualNode", ",", "true", ")", ",", "...", "context", "}", ";", "}", "return", "context", ";", "}" ]

[ "Apply", "defaults", "to", "the", "context" ]

[ "function", "findAfterChecks", "(", "rule", ")", "{", "'use strict'", ";", "return", "axe", ".", "utils", ".", "getAllChecks", "(", "rule", ")", ".", "map", "(", "function", "(", "c", ")", "{", "var", "check", "=", "rule", ".", "_audit", ".", "checks", "[", "c", ".", "id", "||", "c", "]", ";", "return", "check", "&&", "typeof", "check", ".", "after", "===", "'function'", "?", "check", ":", "null", ";", "}", ")", ".", "filter", "(", "Boolean", ")", ";", "}" ]

[ "Iterates", "the", "rule", "s", "Checks", "looking", "for", "ones", "that", "have", "an", "after", "function" ]

[ "function", "findCheckResults", "(", "nodes", ",", "checkID", ")", "{", "'use strict'", ";", "var", "checkResults", "=", "[", "]", ";", "nodes", ".", "forEach", "(", "function", "(", "nodeResult", ")", "{", "var", "checks", "=", "axe", ".", "utils", ".", "getAllChecks", "(", "nodeResult", ")", ";", "checks", ".", "forEach", "(", "function", "(", "checkResult", ")", "{", "if", "(", "checkResult", ".", "id", "===", "checkID", ")", "{", "checkResults", ".", "push", "(", "checkResult", ")", ";", "}", "}", ")", ";", "}", ")", ";", "return", "checkResults", ";", "}" ]

[ "Finds", "and", "collates", "all", "results", "for", "a", "given", "Check", "on", "a", "specific", "Rule" ]

[ "function", "getScroll", "(", "elm", ")", "{", "const", "style", "=", "window", ".", "getComputedStyle", "(", "elm", ")", ";", "const", "visibleOverflowY", "=", "style", ".", "getPropertyValue", "(", "'overflow-y'", ")", "===", "'visible'", ";", "const", "visibleOverflowX", "=", "style", ".", "getPropertyValue", "(", "'overflow-x'", ")", "===", "'visible'", ";", "if", "(", "// See if the element hides overflowing content", "(", "!", "visibleOverflowY", "&&", "elm", ".", "scrollHeight", ">", "elm", ".", "clientHeight", ")", "||", "(", "!", "visibleOverflowX", "&&", "elm", ".", "scrollWidth", ">", "elm", ".", "clientWidth", ")", ")", "{", "return", "{", "elm", ",", "top", ":", "elm", ".", "scrollTop", ",", "left", ":", "elm", ".", "scrollLeft", "}", ";", "}", "}" ]

[ "Return", "the", "scroll", "position", "of", "scrollable", "elements" ]

[ "function", "setScroll", "(", "elm", ",", "top", ",", "left", ")", "{", "if", "(", "elm", "===", "window", ")", "{", "return", "elm", ".", "scroll", "(", "left", ",", "top", ")", ";", "}", "else", "{", "elm", ".", "scrollTop", "=", "top", ";", "elm", ".", "scrollLeft", "=", "left", ";", "}", "}" ]

[ "set", "the", "scroll", "position", "of", "an", "element" ]

[ "function", "getElmScrollRecursive", "(", "root", ")", "{", "return", "Array", ".", "from", "(", "root", ".", "children", ")", ".", "reduce", "(", "(", "scrolls", ",", "elm", ")", "=>", "{", "const", "scroll", "=", "getScroll", "(", "elm", ")", ";", "if", "(", "scroll", ")", "{", "scrolls", ".", "push", "(", "scroll", ")", ";", "}", "return", "scrolls", ".", "concat", "(", "getElmScrollRecursive", "(", "elm", ")", ")", ";", "}", ",", "[", "]", ")", ";", "}" ]

[ "Create", "an", "array", "scroll", "positions", "from", "descending", "elements" ]

[ "function", "pushFrame", "(", "resultSet", ",", "options", ",", "frameElement", ",", "frameSelector", ")", "{", "'use strict'", ";", "var", "frameXpath", "=", "axe", ".", "utils", ".", "getXpath", "(", "frameElement", ")", ";", "var", "frameSpec", "=", "{", "element", ":", "frameElement", ",", "selector", ":", "frameSelector", ",", "xpath", ":", "frameXpath", "}", ";", "resultSet", ".", "forEach", "(", "function", "(", "res", ")", "{", "res", ".", "node", "=", "axe", ".", "utils", ".", "DqElement", ".", "fromFrame", "(", "res", ".", "node", ",", "options", ",", "frameSpec", ")", ";", "var", "checks", "=", "axe", ".", "utils", ".", "getAllChecks", "(", "res", ")", ";", "if", "(", "checks", ".", "length", ")", "{", "checks", ".", "forEach", "(", "function", "(", "check", ")", "{", "check", ".", "relatedNodes", "=", "check", ".", "relatedNodes", ".", "map", "(", "node", "=>", "axe", ".", "utils", ".", "DqElement", ".", "fromFrame", "(", "node", ",", "options", ",", "frameSpec", ")", ")", ";", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "Adds", "the", "owning", "frame", "s", "CSS", "selector", "onto", "each", "instance", "of", "DqElement" ]

[ "function", "spliceNodes", "(", "target", ",", "to", ")", "{", "'use strict'", ";", "var", "firstFromFrame", "=", "to", "[", "0", "]", ".", "node", ",", "sorterResult", ",", "t", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "target", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "t", "=", "target", "[", "i", "]", ".", "node", ";", "sorterResult", "=", "axe", ".", "utils", ".", "nodeSorter", "(", "{", "actualNode", ":", "t", ".", "element", "}", ",", "{", "actualNode", ":", "firstFromFrame", ".", "element", "}", ")", ";", "if", "(", "sorterResult", ">", "0", "||", "(", "sorterResult", "===", "0", "&&", "firstFromFrame", ".", "selector", ".", "length", "<", "t", ".", "selector", ".", "length", ")", ")", "{", "target", ".", "splice", ".", "apply", "(", "target", ",", "[", "i", ",", "0", "]", ".", "concat", "(", "to", ")", ")", ";", "return", ";", "}", "}", "target", ".", "push", ".", "apply", "(", "target", ",", "to", ")", ";", "}" ]

[ "Adds", "to", "to", "from", "and", "then", "re", "-", "sorts", "by", "DOM", "order" ]

[ "function", "isRegion", "(", "virtualNode", ")", "{", "const", "node", "=", "virtualNode", ".", "actualNode", ";", "const", "explicitRole", "=", "axe", ".", "commons", ".", "aria", ".", "getRole", "(", "node", ",", "{", "noImplicit", ":", "true", "}", ")", ";", "const", "ariaLive", "=", "(", "node", ".", "getAttribute", "(", "'aria-live'", ")", "||", "''", ")", ".", "toLowerCase", "(", ")", ".", "trim", "(", ")", ";", "if", "(", "explicitRole", ")", "{", "return", "explicitRole", "===", "'dialog'", "||", "landmarkRoles", ".", "includes", "(", "explicitRole", ")", ";", "}", "// Ignore content inside of aria-live", "if", "(", "[", "'assertive'", ",", "'polite'", "]", ".", "includes", "(", "ariaLive", ")", ")", "{", "return", "true", ";", "}", "// Check if the node matches any of the CSS selectors of implicit landmarks", "return", "implicitLandmarks", ".", "some", "(", "implicitSelector", "=>", "{", "let", "matches", "=", "axe", ".", "utils", ".", "matchesSelector", "(", "node", ",", "implicitSelector", ")", ";", "if", "(", "node", ".", "nodeName", ".", "toUpperCase", "(", ")", "===", "'FORM'", ")", "{", "let", "titleAttr", "=", "node", ".", "getAttribute", "(", "'title'", ")", ";", "let", "title", "=", "titleAttr", "&&", "titleAttr", ".", "trim", "(", ")", "!==", "''", "?", "axe", ".", "commons", ".", "text", ".", "sanitize", "(", "titleAttr", ")", ":", "null", ";", "return", "matches", "&&", "(", "!", "!", "aria", ".", "labelVirtual", "(", "virtualNode", ")", "||", "!", "!", "title", ")", ";", "}", "return", "matches", ";", "}", ")", ";", "}" ]

[ "Check", "if", "the", "current", "element", "is", "a", "landmark" ]

[ "function", "findRegionlessElms", "(", "virtualNode", ")", "{", "const", "node", "=", "virtualNode", ".", "actualNode", ";", "// End recursion if the element is a landmark, skiplink, or hidden content", "if", "(", "isRegion", "(", "virtualNode", ")", "||", "(", "dom", ".", "isSkipLink", "(", "virtualNode", ".", "actualNode", ")", "&&", "dom", ".", "getElementByReference", "(", "virtualNode", ".", "actualNode", ",", "'href'", ")", ")", "||", "!", "dom", ".", "isVisible", "(", "node", ",", "true", ")", ")", "{", "return", "[", "]", ";", "// Return the node is a content element", "}", "else", "if", "(", "dom", ".", "hasContent", "(", "node", ",", "/* noRecursion: */", "true", ")", ")", "{", "return", "[", "node", "]", ";", "// Recursively look at all child elements", "}", "else", "{", "return", "virtualNode", ".", "children", ".", "filter", "(", "(", "{", "actualNode", "}", ")", "=>", "actualNode", ".", "nodeType", "===", "1", ")", ".", "map", "(", "findRegionlessElms", ")", ".", "reduce", "(", "(", "a", ",", "b", ")", "=>", "a", ".", "concat", "(", "b", ")", ",", "[", "]", ")", ";", "// flatten the results", "}", "}" ]

[ "Find", "all", "visible", "elements", "not", "wrapped", "inside", "a", "landmark", "or", "skiplink" ]

[ "function", "_getSource", "(", ")", "{", "var", "application", "=", "'axeAPI'", ",", "version", "=", "''", ",", "src", ";", "if", "(", "typeof", "axe", "!==", "'undefined'", "&&", "axe", ".", "_audit", "&&", "axe", ".", "_audit", ".", "application", ")", "{", "application", "=", "axe", ".", "_audit", ".", "application", ";", "}", "if", "(", "typeof", "axe", "!==", "'undefined'", ")", "{", "version", "=", "axe", ".", "version", ";", "}", "src", "=", "application", "+", "'.'", "+", "version", ";", "return", "src", ";", "}" ]

[ "get", "the", "unique", "string", "to", "be", "used", "to", "identify", "our", "instance", "of", "axe" ]

[ "function", "verify", "(", "postedMessage", ")", "{", "if", "(", "// Check incoming message is valid", "typeof", "postedMessage", "===", "'object'", "&&", "typeof", "postedMessage", ".", "uuid", "===", "'string'", "&&", "postedMessage", ".", "_respondable", "===", "true", ")", "{", "var", "messageSource", "=", "_getSource", "(", ")", ";", "return", "(", "// Check the version matches", "postedMessage", ".", "_source", "===", "messageSource", "||", "// Allow free communication with axe test", "postedMessage", ".", "_source", "===", "'axeAPI.x.y.z'", "||", "messageSource", "===", "'axeAPI.x.y.z'", ")", ";", "}", "return", "false", ";", "}" ]

[ "Verify", "the", "received", "message", "is", "from", "the", "respondable", "module" ]

[ "function", "post", "(", "win", ",", "topic", ",", "message", ",", "uuid", ",", "keepalive", ",", "callback", ")", "{", "var", "error", ";", "if", "(", "message", "instanceof", "Error", ")", "{", "error", "=", "{", "name", ":", "message", ".", "name", ",", "message", ":", "message", ".", "message", ",", "stack", ":", "message", ".", "stack", "}", ";", "message", "=", "undefined", ";", "}", "var", "data", "=", "{", "uuid", ":", "uuid", ",", "topic", ":", "topic", ",", "message", ":", "message", ",", "error", ":", "error", ",", "_respondable", ":", "true", ",", "_source", ":", "_getSource", "(", ")", ",", "_keepalive", ":", "keepalive", "}", ";", "if", "(", "typeof", "callback", "===", "'function'", ")", "{", "messages", "[", "uuid", "]", "=", "callback", ";", "}", "win", ".", "postMessage", "(", "JSON", ".", "stringify", "(", "data", ")", ",", "'*'", ")", ";", "}" ]

[ "Posts", "the", "message", "to", "correct", "frame", ".", "This", "abstraction", "necessary", "because", "IE9", "&", "10", "do", "not", "support", "posting", "Objects", ";", "only", "strings" ]

[ "function", "respondable", "(", "win", ",", "topic", ",", "message", ",", "keepalive", ",", "callback", ")", "{", "var", "id", "=", "uuid", ".", "v1", "(", ")", ";", "post", "(", "win", ",", "topic", ",", "message", ",", "id", ",", "keepalive", ",", "callback", ")", ";", "}" ]

[ "Post", "a", "message", "to", "a", "window", "who", "may", "or", "may", "not", "respond", "to", "it", "." ]

[ "function", "createResponder", "(", "source", ",", "topic", ",", "uuid", ")", "{", "return", "function", "(", "message", ",", "keepalive", ",", "callback", ")", "{", "post", "(", "source", ",", "topic", ",", "message", ",", "uuid", ",", "keepalive", ",", "callback", ")", ";", "}", ";", "}" ]

[ "Helper", "closure", "to", "create", "a", "function", "that", "may", "be", "used", "to", "respond", "to", "a", "message" ]

[ "function", "publish", "(", "source", ",", "data", ",", "keepalive", ")", "{", "var", "topic", "=", "data", ".", "topic", ";", "var", "subscriber", "=", "subscribers", "[", "topic", "]", ";", "if", "(", "subscriber", ")", "{", "var", "responder", "=", "createResponder", "(", "source", ",", "null", ",", "data", ".", "uuid", ")", ";", "subscriber", "(", "data", ".", "message", ",", "keepalive", ",", "responder", ")", ";", "}", "}" ]

[ "Publishes", "the", "respondable", "message", "to", "the", "appropriate", "subscriber" ]

[ "function", "buildErrorObject", "(", "error", ")", "{", "var", "msg", "=", "error", ".", "message", "||", "'Unknown error occurred'", ";", "var", "errorName", "=", "errorTypes", ".", "includes", "(", "error", ".", "name", ")", "?", "error", ".", "name", ":", "'Error'", ";", "var", "ErrConstructor", "=", "window", "[", "errorName", "]", "||", "Error", ";", "if", "(", "error", ".", "stack", ")", "{", "msg", "+=", "'\\n'", "+", "error", ".", "stack", ".", "replace", "(", "error", ".", "message", ",", "''", ")", ";", "}", "return", "new", "ErrConstructor", "(", "msg", ")", ";", "}" ]

[ "Convert", "a", "javascript", "Error", "into", "something", "that", "can", "be", "stringified" ]

[ "function", "parseMessage", "(", "dataString", ")", "{", "/*eslint no-empty: 0*/", "var", "data", ";", "if", "(", "typeof", "dataString", "!==", "'string'", ")", "{", "return", ";", "}", "try", "{", "data", "=", "JSON", ".", "parse", "(", "dataString", ")", ";", "}", "catch", "(", "ex", ")", "{", "}", "if", "(", "!", "verify", "(", "data", ")", ")", "{", "return", ";", "}", "if", "(", "typeof", "data", ".", "error", "===", "'object'", ")", "{", "data", ".", "error", "=", "buildErrorObject", "(", "data", ".", "error", ")", ";", "}", "else", "{", "data", ".", "error", "=", "undefined", ";", "}", "return", "data", ";", "}" ]

[ "Parse", "the", "received", "message", "for", "processing" ]

[ "function", "getAllRootNodesInTree", "(", "tree", ")", "{", "let", "ids", "=", "[", "]", ";", "const", "rootNodes", "=", "axe", ".", "utils", ".", "querySelectorAllFilter", "(", "tree", ",", "'*'", ",", "node", "=>", "{", "if", "(", "ids", ".", "includes", "(", "node", ".", "shadowId", ")", ")", "{", "return", "false", ";", "}", "ids", ".", "push", "(", "node", ".", "shadowId", ")", ";", "return", "true", ";", "}", ")", ".", "map", "(", "node", "=>", "{", "return", "{", "shadowId", ":", "node", ".", "shadowId", ",", "rootNode", ":", "axe", ".", "utils", ".", "getRootNode", "(", "node", ".", "actualNode", ")", "}", ";", "}", ")", ";", "return", "axe", ".", "utils", ".", "uniqueArray", "(", "rootNodes", ",", "[", "]", ")", ";", "}" ]

[ "Returns", "am", "array", "of", "source", "nodes", "containing", "document", "and", "documentFragment", "in", "a", "given", "tree", "." ]

[ "function", "getCssomForAllRootNodes", "(", "rootNodes", ",", "convertDataToStylesheet", ",", "timeout", ")", "{", "const", "q", "=", "axe", ".", "utils", ".", "queue", "(", ")", ";", "rootNodes", ".", "forEach", "(", "(", "{", "rootNode", ",", "shadowId", "}", ",", "index", ")", "=>", "q", ".", "defer", "(", "(", "resolve", ",", "reject", ")", "=>", "loadCssom", "(", "{", "rootNode", ",", "shadowId", ",", "timeout", ",", "convertDataToStylesheet", ",", "rootIndex", ":", "index", "+", "1", "}", ")", ".", "then", "(", "resolve", ")", ".", "catch", "(", "reject", ")", ")", ")", ";", "return", "q", ";", "}" ]

[ "Deferred", "function", "for", "CSSOM", "queue", "processing", "on", "all", "root", "nodes" ]

[ "function", "parseNonCrossOriginStylesheet", "(", "sheet", ",", "options", ",", "priority", ")", "{", "const", "q", "=", "axe", ".", "utils", ".", "queue", "(", ")", ";", "/**\n\t * `sheet.cssRules` throws an error on `cross-origin` stylesheets\n\t */", "const", "cssRules", "=", "sheet", ".", "cssRules", ";", "const", "rules", "=", "Array", ".", "from", "(", "cssRules", ")", ";", "if", "(", "!", "rules", ")", "{", "return", "q", ";", "}", "/**\n\t * reference -> https://developer.mozilla.org/en-US/docs/Web/API/CSSRule#Type_constants\n\t */", "const", "cssImportRules", "=", "rules", ".", "filter", "(", "r", "=>", "r", ".", "type", "===", "3", ")", ";", "// type === 3 -> CSSRule.IMPORT_RULE", "/**\n\t * when no `@import` rules in given sheet\n\t * -> resolve the current `sheet` & exit\n\t */", "if", "(", "!", "cssImportRules", ".", "length", ")", "{", "q", ".", "defer", "(", "resolve", "=>", "resolve", "(", "{", "isExternal", ":", "false", ",", "priority", ",", "root", ":", "options", ".", "rootNode", ",", "shadowId", ":", "options", ".", "shadowId", ",", "sheet", "}", ")", ")", ";", "// exit", "return", "q", ";", "}", "/**\n\t * iterate `@import` rules and fetch styles\n\t */", "cssImportRules", ".", "forEach", "(", "(", "importRule", ",", "cssRuleIndex", ")", "=>", "q", ".", "defer", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "const", "importUrl", "=", "importRule", ".", "href", ";", "const", "newPriority", "=", "[", "...", "priority", ",", "cssRuleIndex", "]", ";", "const", "axiosOptions", "=", "{", "method", ":", "'get'", ",", "url", ":", "importUrl", ",", "timeout", ":", "options", ".", "timeout", "}", ";", "axe", ".", "imports", ".", "axios", "(", "axiosOptions", ")", ".", "then", "(", "(", "{", "data", "}", ")", "=>", "resolve", "(", "options", ".", "convertDataToStylesheet", "(", "{", "data", ",", "isExternal", ":", "true", ",", "priority", ":", "newPriority", ",", "root", ":", "options", ".", "rootNode", ",", "shadowId", ":", "options", ".", "shadowId", "}", ")", ")", ")", ".", "catch", "(", "reject", ")", ";", "}", ")", ")", ";", "const", "nonImportCSSRules", "=", "rules", ".", "filter", "(", "r", "=>", "r", ".", "type", "!==", "3", ")", ";", "// no further rules to process in this sheet", "if", "(", "!", "nonImportCSSRules", ".", "length", ")", "{", "return", "q", ";", "}", "// convert all `nonImportCSSRules` style rules into `text` and defer into queue", "q", ".", "defer", "(", "resolve", "=>", "resolve", "(", "options", ".", "convertDataToStylesheet", "(", "{", "data", ":", "nonImportCSSRules", ".", "map", "(", "rule", "=>", "rule", ".", "cssText", ")", ".", "join", "(", ")", ",", "isExternal", ":", "false", ",", "priority", ",", "root", ":", "options", ".", "rootNode", ",", "shadowId", ":", "options", ".", "shadowId", "}", ")", ")", ")", ";", "return", "q", ";", "}" ]

[ "Parse", "non", "cross", "-", "origin", "stylesheets" ]

[ "function", "parseCrossOriginStylesheet", "(", "url", ",", "options", ",", "priority", ")", "{", "const", "q", "=", "axe", ".", "utils", ".", "queue", "(", ")", ";", "if", "(", "!", "url", ")", "{", "return", "q", ";", "}", "const", "axiosOptions", "=", "{", "method", ":", "'get'", ",", "url", ",", "timeout", ":", "options", ".", "timeout", "}", ";", "q", ".", "defer", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "axe", ".", "imports", ".", "axios", "(", "axiosOptions", ")", ".", "then", "(", "(", "{", "data", "}", ")", "=>", "resolve", "(", "options", ".", "convertDataToStylesheet", "(", "{", "data", ",", "isExternal", ":", "true", ",", "priority", ",", "root", ":", "options", ".", "rootNode", ",", "shadowId", ":", "options", ".", "shadowId", "}", ")", ")", ")", ".", "catch", "(", "reject", ")", ";", "}", ")", ";", "return", "q", ";", "}" ]

[ "Parse", "cross", "-", "origin", "stylesheets" ]

[ "function", "getStylesheetsFromDocumentFragment", "(", "options", ")", "{", "const", "{", "rootNode", ",", "convertDataToStylesheet", "}", "=", "options", ";", "return", "(", "Array", ".", "from", "(", "rootNode", ".", "children", ")", ".", "filter", "(", "filerStyleAndLinkAttributesInDocumentFragment", ")", "// Reducer to convert `<style></style>` and `<link>` references to `CSSStyleSheet` object", ".", "reduce", "(", "(", "out", ",", "node", ")", "=>", "{", "const", "nodeName", "=", "node", ".", "nodeName", ".", "toUpperCase", "(", ")", ";", "const", "data", "=", "nodeName", "===", "'STYLE'", "?", "node", ".", "textContent", ":", "node", ";", "const", "isLink", "=", "nodeName", "===", "'LINK'", ";", "const", "stylesheet", "=", "convertDataToStylesheet", "(", "{", "data", ",", "isLink", ",", "root", ":", "rootNode", "}", ")", ";", "out", ".", "push", "(", "stylesheet", ".", "sheet", ")", ";", "return", "out", ";", "}", ",", "[", "]", ")", ")", ";", "}" ]

[ "Get", "stylesheets", "from", "documentFragment" ]

[ "function", "getStylesheetsFromDocument", "(", "rootNode", ")", "{", "return", "Array", ".", "from", "(", "rootNode", ".", "styleSheets", ")", ".", "filter", "(", "sheet", "=>", "filterMediaIsPrint", "(", "sheet", ".", "media", ".", "mediaText", ")", ")", ";", "}" ]

[ "Get", "stylesheets", "from", "document", "-", ">", "filter", "out", "stylesheet", "that", "are", "media", "=", "print" ]

[ "function", "filterStylesheetsWithSameHref", "(", "sheets", ")", "{", "let", "hrefs", "=", "[", "]", ";", "return", "sheets", ".", "filter", "(", "sheet", "=>", "{", "if", "(", "!", "sheet", ".", "href", ")", "{", "// include sheets without `href`", "return", "true", ";", "}", "// if `href` is present, ensure they are not duplicates", "if", "(", "hrefs", ".", "includes", "(", "sheet", ".", "href", ")", ")", "{", "return", "false", ";", "}", "hrefs", ".", "push", "(", "sheet", ".", "href", ")", ";", "return", "true", ";", "}", ")", ";", "}" ]

[ "Exclude", "any", "duplicate", "stylesheets", "that", "share", "the", "same", "href" ]

[ "async", "function", "runSample", "(", ")", "{", "const", "res", "=", "await", "youtube", ".", "search", ".", "list", "(", "{", "part", ":", "'id,snippet'", ",", "q", ":", "'Node.js on Google Cloud'", ",", "}", ")", ";", "console", ".", "log", "(", "res", ".", "data", ")", ";", "}" ]

[ "a", "very", "simple", "example", "of", "searching", "for", "youtube", "videos" ]

[ "async", "function", "runSample", "(", "fileName", ")", "{", "const", "fileSize", "=", "fs", ".", "statSync", "(", "fileName", ")", ".", "size", ";", "const", "res", "=", "await", "youtube", ".", "videos", ".", "insert", "(", "{", "part", ":", "'id,snippet,status'", ",", "notifySubscribers", ":", "false", ",", "requestBody", ":", "{", "snippet", ":", "{", "title", ":", "'Node.js YouTube Upload Test'", ",", "description", ":", "'Testing YouTube upload via Google APIs Node.js Client'", ",", "}", ",", "status", ":", "{", "privacyStatus", ":", "'private'", ",", "}", ",", "}", ",", "media", ":", "{", "body", ":", "fs", ".", "createReadStream", "(", "fileName", ")", ",", "}", ",", "}", ",", "{", "// Use the `onUploadProgress` event from Axios to track the", "// number of bytes uploaded to this point.", "onUploadProgress", ":", "evt", "=>", "{", "const", "progress", "=", "(", "evt", ".", "bytesRead", "/", "fileSize", ")", "*", "100", ";", "readline", ".", "clearLine", "(", "process", ".", "stdout", ",", "0", ")", ";", "readline", ".", "cursorTo", "(", "process", ".", "stdout", ",", "0", ",", "null", ")", ";", "process", ".", "stdout", ".", "write", "(", "`", "${", "Math", ".", "round", "(", "progress", ")", "}", "`", ")", ";", "}", ",", "}", ")", ";", "console", ".", "log", "(", "'\\n\\n'", ")", ";", "console", ".", "log", "(", "res", ".", "data", ")", ";", "return", "res", ".", "data", ";", "}" ]

[ "very", "basic", "example", "of", "uploading", "a", "video", "to", "youtube" ]

[ "async", "function", "runSample", "(", ")", "{", "// the first query will return data with an etag", "const", "res", "=", "await", "getPlaylistData", "(", "null", ")", ";", "const", "etag", "=", "res", ".", "data", ".", "etag", ";", "console", ".", "log", "(", "`", "${", "etag", "}", "`", ")", ";", "// the second query will (likely) return no data, and an HTTP 304", "// since the If-None-Match header was set with a matching eTag", "const", "res2", "=", "await", "getPlaylistData", "(", "etag", ")", ";", "console", ".", "log", "(", "res2", ".", "status", ")", ";", "}" ]

[ "a", "very", "simple", "example", "of", "getting", "data", "from", "a", "playlist" ]

[ "async", "function", "runSample", "(", ")", "{", "const", "res", "=", "await", "mirror", ".", "locations", ".", "list", "(", "{", "}", ")", ";", "console", ".", "log", "(", "res", ".", "data", ")", ";", "}" ]

[ "a", "very", "simple", "example", "of", "listing", "locations", "from", "the", "mirror", "API" ]

[ "async", "function", "runSample", "(", ")", "{", "// Create a new JWT client using the key file downloaded from the Google Developer Console", "const", "client", "=", "await", "google", ".", "auth", ".", "getClient", "(", "{", "keyFile", ":", "path", ".", "join", "(", "__dirname", ",", "'jwt.keys.json'", ")", ",", "scopes", ":", "'https://www.googleapis.com/auth/drive.readonly'", ",", "}", ")", ";", "// Obtain a new drive client, making sure you pass along the auth client", "const", "drive", "=", "google", ".", "drive", "(", "{", "version", ":", "'v2'", ",", "auth", ":", "client", ",", "}", ")", ";", "// Make an authorized request to list Drive files.", "const", "res", "=", "await", "drive", ".", "files", ".", "list", "(", ")", ";", "console", ".", "log", "(", "res", ".", "data", ")", ";", "return", "res", ".", "data", ";", "}" ]

[ "The", "JWT", "authorization", "is", "ideal", "for", "performing", "server", "-", "to", "-", "server", "communication", "without", "asking", "for", "user", "consent", "." ]

[ "async", "function", "main", "(", ")", "{", "// The `getClient` method will choose a service based authentication model", "const", "auth", "=", "await", "google", ".", "auth", ".", "getClient", "(", "{", "// Scopes can be specified either as an array or as a single, space-delimited string.", "scopes", ":", "[", "'https://www.googleapis.com/auth/compute'", "]", ",", "}", ")", ";", "// Obtain the current project Id", "const", "project", "=", "await", "google", ".", "auth", ".", "getProjectId", "(", ")", ";", "// Get the list of available compute zones for your project", "const", "res", "=", "await", "compute", ".", "zones", ".", "list", "(", "{", "project", ",", "auth", "}", ")", ";", "console", ".", "log", "(", "res", ".", "data", ")", ";", "}" ]

[ "The", "google", ".", "auth", ".", "getClient", "method", "creates", "the", "appropriate", "type", "of", "credential", "client", "for", "you", "depending", "upon", "whether", "the", "client", "is", "running", "in", "Google", "App", "Engine", "Google", "Compute", "Engine", "a", "Managed", "VM", "or", "on", "a", "local", "developer", "machine", ".", "This", "allows", "you", "to", "write", "one", "set", "of", "auth", "code", "that", "will", "work", "in", "all", "cases", ".", "It", "most", "situations", "it", "is", "advisable", "to", "use", "the", "getClient", "method", "rather", "than", "creating", "your", "own", "JWT", "or", "Compute", "client", "directly", "." ]

[ "function", "(", "tag", ",", "attrs", ",", "children", ")", "{", "var", "el", "=", "document", ".", "createElement", "(", "tag", ")", ";", "if", "(", "attrs", "!=", "null", "&&", "typeof", "attrs", "===", "typeof", "{", "}", ")", "{", "Object", ".", "keys", "(", "attrs", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "var", "val", "=", "attrs", "[", "key", "]", ";", "el", ".", "setAttribute", "(", "key", ",", "val", ")", ";", "}", ")", ";", "}", "else", "if", "(", "typeof", "attrs", "===", "typeof", "[", "]", ")", "{", "children", "=", "attrs", ";", "}", "if", "(", "children", "!=", "null", "&&", "typeof", "children", "===", "typeof", "[", "]", ")", "{", "children", ".", "forEach", "(", "function", "(", "child", ")", "{", "el", ".", "appendChild", "(", "child", ")", ";", "}", ")", ";", "}", "else", "if", "(", "children", "!=", "null", "&&", "typeof", "children", "===", "typeof", "''", ")", "{", "el", ".", "appendChild", "(", "document", ".", "createTextNode", "(", "children", ")", ")", ";", "}", "return", "el", ";", "}" ]

[ "hyperscript", "-", "like", "function" ]

[ "function", "(", "options", ")", "{", "this", ".", "options", "=", "options", ";", "registrant", ".", "call", "(", "this", ",", "options", ")", ";", "// make sure layout has _private for use w/ std apis like .on()", "if", "(", "!", "is", ".", "plainObject", "(", "this", ".", "_private", ")", ")", "{", "this", ".", "_private", "=", "{", "}", ";", "}", "this", ".", "_private", ".", "cy", "=", "options", ".", "cy", ";", "this", ".", "_private", ".", "listeners", "=", "[", "]", ";", "this", ".", "createEmitter", "(", ")", ";", "}" ]

[ "fill", "in", "missing", "layout", "functions", "in", "the", "prototype" ]

[ "function", "memoize", "(", "fn", ",", "keyFn", ")", "{", "if", "(", "!", "keyFn", ")", "{", "keyFn", "=", "function", "keyFn", "(", ")", "{", "if", "(", "arguments", ".", "length", "===", "1", ")", "{", "return", "arguments", "[", "0", "]", ";", "}", "else", "if", "(", "arguments", ".", "length", "===", "0", ")", "{", "return", "'undefined'", ";", "}", "var", "args", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arguments", ".", "length", ";", "i", "++", ")", "{", "args", ".", "push", "(", "arguments", "[", "i", "]", ")", ";", "}", "return", "args", ".", "join", "(", "'$'", ")", ";", "}", ";", "}", "var", "memoizedFn", "=", "function", "memoizedFn", "(", ")", "{", "var", "self", "=", "this", ";", "var", "args", "=", "arguments", ";", "var", "ret", ";", "var", "k", "=", "keyFn", ".", "apply", "(", "self", ",", "args", ")", ";", "var", "cache", "=", "memoizedFn", ".", "cache", ";", "if", "(", "!", "(", "ret", "=", "cache", "[", "k", "]", ")", ")", "{", "ret", "=", "cache", "[", "k", "]", "=", "fn", ".", "apply", "(", "self", ",", "args", ")", ";", "}", "return", "ret", ";", "}", ";", "memoizedFn", ".", "cache", "=", "{", "}", ";", "return", "memoizedFn", ";", "}" ]

[ "probably", "a", "better", "way", "to", "detect", "this", "..." ]

[ "function", "getMap", "(", "options", ")", "{", "var", "obj", "=", "options", ".", "map", ";", "var", "keys", "=", "options", ".", "keys", ";", "var", "l", "=", "keys", ".", "length", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "l", ";", "i", "++", ")", "{", "var", "key", "=", "keys", "[", "i", "]", ";", "if", "(", "plainObject", "(", "key", ")", ")", "{", "throw", "Error", "(", "'Tried to get map with object key'", ")", ";", "}", "obj", "=", "obj", "[", "key", "]", ";", "if", "(", "obj", "==", "null", ")", "{", "return", "obj", ";", "}", "}", "return", "obj", ";", "}" ]

[ "gets", "the", "value", "in", "a", "map", "even", "if", "it", "s", "not", "built", "in", "places" ]

[ "function", "contractUntil", "(", "metaNodeMap", ",", "remainingEdges", ",", "size", ",", "sizeLimit", ")", "{", "while", "(", "size", ">", "sizeLimit", ")", "{", "// Choose an edge randomly", "var", "edgeIndex", "=", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "remainingEdges", ".", "length", ")", ";", "// Collapse graph based on edge", "remainingEdges", "=", "collapse", "(", "edgeIndex", ",", "metaNodeMap", ",", "remainingEdges", ")", ";", "size", "--", ";", "}", "return", "remainingEdges", ";", "}" ]

[ "Contracts", "a", "graph", "until", "we", "reach", "a", "certain", "number", "of", "meta", "nodes" ]

[ "function", "removeData", "(", "params", ")", "{", "var", "defaults$$1", "=", "{", "field", ":", "'data'", ",", "event", ":", "'data'", ",", "triggerFnName", ":", "'trigger'", ",", "triggerEvent", ":", "false", ",", "immutableKeys", ":", "{", "}", "// key => true if immutable", "}", ";", "params", "=", "extend", "(", "{", "}", ",", "defaults$$1", ",", "params", ")", ";", "return", "function", "removeDataImpl", "(", "names", ")", "{", "var", "p", "=", "params", ";", "var", "self", "=", "this", ";", "var", "selfIsArrayLike", "=", "self", ".", "length", "!==", "undefined", ";", "var", "all", "=", "selfIsArrayLike", "?", "self", ":", "[", "self", "]", ";", "// put in array if not array-like", "// .removeData('foo bar')", "if", "(", "string", "(", "names", ")", ")", "{", "// then get the list of keys, and delete them", "var", "keys", "=", "names", ".", "split", "(", "/", "\\s+", "/", ")", ";", "var", "l", "=", "keys", ".", "length", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "l", ";", "i", "++", ")", "{", "// delete each non-empty key", "var", "key", "=", "keys", "[", "i", "]", ";", "if", "(", "emptyString", "(", "key", ")", ")", "{", "continue", ";", "}", "var", "valid", "=", "!", "p", ".", "immutableKeys", "[", "key", "]", ";", "// not valid if immutable", "if", "(", "valid", ")", "{", "for", "(", "var", "i_a", "=", "0", ",", "l_a", "=", "all", ".", "length", ";", "i_a", "<", "l_a", ";", "i_a", "++", ")", "{", "all", "[", "i_a", "]", ".", "_private", "[", "p", ".", "field", "]", "[", "key", "]", "=", "undefined", ";", "}", "}", "}", "if", "(", "p", ".", "triggerEvent", ")", "{", "self", "[", "p", ".", "triggerFnName", "]", "(", "p", ".", "event", ")", ";", "}", "// .removeData()", "}", "else", "if", "(", "names", "===", "undefined", ")", "{", "// then delete all keys", "for", "(", "var", "_i_a", "=", "0", ",", "_l_a", "=", "all", ".", "length", ";", "_i_a", "<", "_l_a", ";", "_i_a", "++", ")", "{", "var", "_privateFields", "=", "all", "[", "_i_a", "]", ".", "_private", "[", "p", ".", "field", "]", ";", "var", "_keys", "=", "Object", ".", "keys", "(", "_privateFields", ")", ";", "for", "(", "var", "_i2", "=", "0", ";", "_i2", "<", "_keys", ".", "length", ";", "_i2", "++", ")", "{", "var", "_key", "=", "_keys", "[", "_i2", "]", ";", "var", "validKeyToDelete", "=", "!", "p", ".", "immutableKeys", "[", "_key", "]", ";", "if", "(", "validKeyToDelete", ")", "{", "_privateFields", "[", "_key", "]", "=", "undefined", ";", "}", "}", "}", "if", "(", "p", ".", "triggerEvent", ")", "{", "self", "[", "p", ".", "triggerFnName", "]", "(", "p", ".", "event", ")", ";", "}", "}", "return", "self", ";", "// maintain chaining", "}", ";", "// function", "}" ]

[ "data", "remove", "data", "field" ]

[ "function", "consumeExpr", "(", "remaining", ")", "{", "var", "expr", ";", "var", "match", ";", "var", "name", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "exprs", ".", "length", ";", "j", "++", ")", "{", "var", "e", "=", "exprs", "[", "j", "]", ";", "var", "n", "=", "e", ".", "name", ";", "var", "m", "=", "remaining", ".", "match", "(", "e", ".", "regexObj", ")", ";", "if", "(", "m", "!=", "null", ")", "{", "match", "=", "m", ";", "expr", "=", "e", ";", "name", "=", "n", ";", "var", "consumed", "=", "m", "[", "0", "]", ";", "remaining", "=", "remaining", ".", "substring", "(", "consumed", ".", "length", ")", ";", "break", ";", "// we've consumed one expr, so we can return now", "}", "}", "return", "{", "expr", ":", "expr", ",", "match", ":", "match", ",", "name", ":", "name", ",", "remaining", ":", "remaining", "}", ";", "}" ]

[ "Of", "all", "the", "expressions", "find", "the", "first", "match", "in", "the", "remaining", "text", "." ]

[ "function", "consumeWhitespace", "(", "remaining", ")", "{", "var", "match", "=", "remaining", ".", "match", "(", "/", "^\\s+", "/", ")", ";", "if", "(", "match", ")", "{", "var", "consumed", "=", "match", "[", "0", "]", ";", "remaining", "=", "remaining", ".", "substring", "(", "consumed", ".", "length", ")", ";", "}", "return", "remaining", ";", "}" ]

[ "Consume", "all", "the", "leading", "whitespace" ]

[ "function", "parse", "(", "selector", ")", "{", "var", "self", "=", "this", ";", "var", "remaining", "=", "self", ".", "inputText", "=", "selector", ";", "var", "currentQuery", "=", "self", "[", "0", "]", "=", "newQuery", "(", ")", ";", "self", ".", "length", "=", "1", ";", "remaining", "=", "consumeWhitespace", "(", "remaining", ")", ";", "// get rid of leading whitespace", "for", "(", ";", ";", ")", "{", "var", "exprInfo", "=", "consumeExpr", "(", "remaining", ")", ";", "if", "(", "exprInfo", ".", "expr", "==", "null", ")", "{", "warn", "(", "'The selector `'", "+", "selector", "+", "'`is invalid'", ")", ";", "return", "false", ";", "}", "else", "{", "var", "args", "=", "exprInfo", ".", "match", ".", "slice", "(", "1", ")", ";", "// let the token populate the selector object in currentQuery", "var", "ret", "=", "exprInfo", ".", "expr", ".", "populate", "(", "self", ",", "currentQuery", ",", "args", ")", ";", "if", "(", "ret", "===", "false", ")", "{", "return", "false", ";", "// exit if population failed", "}", "else", "if", "(", "ret", "!=", "null", ")", "{", "currentQuery", "=", "ret", ";", "// change the current query to be filled if the expr specifies", "}", "}", "remaining", "=", "exprInfo", ".", "remaining", ";", "// we're done when there's nothing left to parse", "if", "(", "remaining", ".", "match", "(", "/", "^\\s*$", "/", ")", ")", "{", "break", ";", "}", "}", "var", "lastQ", "=", "self", "[", "self", ".", "length", "-", "1", "]", ";", "if", "(", "self", ".", "currentSubject", "!=", "null", ")", "{", "lastQ", ".", "subject", "=", "self", ".", "currentSubject", ";", "}", "lastQ", ".", "edgeCount", "=", "self", ".", "edgeCount", ";", "lastQ", ".", "compoundCount", "=", "self", ".", "compoundCount", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "self", ".", "length", ";", "i", "++", ")", "{", "var", "q", "=", "self", "[", "i", "]", ";", "// in future, this could potentially be allowed if there were operator precedence and detection of invalid combinations", "if", "(", "q", ".", "compoundCount", ">", "0", "&&", "q", ".", "edgeCount", ">", "0", ")", "{", "warn", "(", "'The selector `'", "+", "selector", "+", "'` is invalid because it uses both a compound selector and an edge selector'", ")", ";", "return", "false", ";", "}", "if", "(", "q", ".", "edgeCount", ">", "1", ")", "{", "warn", "(", "'The selector `'", "+", "selector", "+", "'` is invalid because it uses multiple edge selectors'", ")", ";", "return", "false", ";", "}", "else", "if", "(", "q", ".", "edgeCount", "===", "1", ")", "{", "warn", "(", "'The selector `'", "+", "selector", "+", "'` is deprecated. Edge selectors do not take effect on changes to source and target nodes after an edge is added, for performance reasons. Use a class or data selector on edges instead, updating the class or data of an edge when your app detects a change in source or target nodes.'", ")", ";", "}", "}", "return", "true", ";", "// success", "}" ]

[ "Parse", "the", "string", "and", "store", "the", "parsed", "representation", "in", "the", "Selector", "." ]

[ "function", "matches", "(", "query", ",", "ele", ")", "{", "return", "query", ".", "checks", ".", "every", "(", "function", "(", "chk", ")", "{", "return", "match", "[", "chk", ".", "type", "]", "(", "chk", ",", "ele", ")", ";", "}", ")", ";", "}" ]

[ "Returns", "whether", "the", "query", "matches", "for", "the", "element" ]

[ "function", "matches$$1", "(", "ele", ")", "{", "var", "self", "=", "this", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "self", ".", "length", ";", "j", "++", ")", "{", "var", "query", "=", "self", "[", "j", "]", ";", "if", "(", "matches", "(", "query", ",", "ele", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "filter", "does", "selector", "match", "a", "single", "element?" ]

[ "function", "byGroup", "(", ")", "{", "var", "nodes", "=", "this", ".", "spawn", "(", ")", ";", "var", "edges", "=", "this", ".", "spawn", "(", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "this", ".", "length", ";", "i", "++", ")", "{", "var", "ele", "=", "this", "[", "i", "]", ";", "if", "(", "ele", ".", "isNode", "(", ")", ")", "{", "nodes", ".", "merge", "(", "ele", ")", ";", "}", "else", "{", "edges", ".", "merge", "(", "ele", ")", ";", "}", "}", "return", "{", "nodes", ":", "nodes", ",", "edges", ":", "edges", "}", ";", "}" ]

[ "internal", "helper", "to", "get", "nodes", "and", "edges", "as", "separate", "collections", "with", "single", "iteration", "over", "elements" ]

[ "function", "merge", "(", "toAdd", ")", "{", "var", "_p", "=", "this", ".", "_private", ";", "var", "cy", "=", "_p", ".", "cy", ";", "if", "(", "!", "toAdd", ")", "{", "return", "this", ";", "}", "if", "(", "toAdd", "&&", "string", "(", "toAdd", ")", ")", "{", "var", "selector", "=", "toAdd", ";", "toAdd", "=", "cy", ".", "mutableElements", "(", ")", ".", "filter", "(", "selector", ")", ";", "}", "var", "map", "=", "_p", ".", "map", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "toAdd", ".", "length", ";", "i", "++", ")", "{", "var", "toAddEle", "=", "toAdd", "[", "i", "]", ";", "var", "id", "=", "toAddEle", ".", "_private", ".", "data", ".", "id", ";", "var", "add", "=", "!", "map", ".", "has", "(", "id", ")", ";", "if", "(", "add", ")", "{", "var", "index", "=", "this", ".", "length", "++", ";", "this", "[", "index", "]", "=", "toAddEle", ";", "map", ".", "set", "(", "id", ",", "{", "ele", ":", "toAddEle", ",", "index", ":", "index", "}", ")", ";", "}", "else", "{", "// replace", "var", "_index", "=", "map", ".", "get", "(", "id", ")", ".", "index", ";", "this", "[", "_index", "]", "=", "toAddEle", ";", "map", ".", "set", "(", "id", ",", "{", "ele", ":", "toAddEle", ",", "index", ":", "_index", "}", ")", ";", "}", "}", "return", "this", ";", "// chaining", "}" ]

[ "in", "place", "merge", "on", "calling", "collection" ]

[ "function", "unmergeOne", "(", "ele", ")", "{", "ele", "=", "ele", "[", "0", "]", ";", "var", "_p", "=", "this", ".", "_private", ";", "var", "id", "=", "ele", ".", "_private", ".", "data", ".", "id", ";", "var", "map", "=", "_p", ".", "map", ";", "var", "entry", "=", "map", ".", "get", "(", "id", ")", ";", "if", "(", "!", "entry", ")", "{", "return", "this", ";", "// no need to remove", "}", "var", "i", "=", "entry", ".", "index", ";", "this", ".", "unmergeAt", "(", "i", ")", ";", "return", "this", ";", "}" ]

[ "remove", "single", "ele", "in", "place", "in", "calling", "collection" ]

[ "function", "unmerge", "(", "toRemove", ")", "{", "var", "cy", "=", "this", ".", "_private", ".", "cy", ";", "if", "(", "!", "toRemove", ")", "{", "return", "this", ";", "}", "if", "(", "toRemove", "&&", "string", "(", "toRemove", ")", ")", "{", "var", "selector", "=", "toRemove", ";", "toRemove", "=", "cy", ".", "mutableElements", "(", ")", ".", "filter", "(", "selector", ")", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "toRemove", ".", "length", ";", "i", "++", ")", "{", "this", ".", "unmergeOne", "(", "toRemove", "[", "i", "]", ")", ";", "}", "return", "this", ";", "// chaining", "}" ]

[ "remove", "eles", "in", "place", "on", "calling", "collection" ]