Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "fileChanged", "(", "status", ",", "filepath", ")", "{", "if", "(", "changedFiles", "[", "filepath", "]", "===", "'deleted'", "&&", "status", "===", "'added'", ")", "{", "status", "=", "'changed'", ";", "}", "changedFiles", "[", "filepath", "]", "=", "status", ";", "if", "(", "grunt", ".", "event", ".", "listeners", "(", "'watch'", ")", ".", "length", ">", "0", ")", "{", "var", "matchingTargets", "=", "[", "]", ";", "targets", ".", "forEach", "(", "function", "(", "target", ")", "{", "if", "(", "grunt", ".", "file", ".", "match", "(", "target", ".", "files", ",", "filepath", ")", ".", "length", ">", "0", ")", "{", "matchingTargets", ".", "push", "(", "target", ".", "name", ")", ";", "}", "}", ")", ";", "matchingTargets", ".", "forEach", "(", "function", "(", "matchingTarget", ")", "{", "grunt", ".", "event", ".", "emit", "(", "'watch'", ",", "status", ",", "filepath", ",", "matchingTarget", ")", ";", "}", ")", ";", "}", "changedFiles", "[", "filepath", "]", "=", "status", ";", "done", "(", ")", ";", "}" ]

[ "Handle", "file", "changes", "." ]

[ "function", "watchFile", "(", "filepath", ")", "{", "if", "(", "!", "watchedFiles", "[", "filepath", "]", ")", "{", "var", "statStructure", "=", "null", ";", "try", "{", "statStructure", "=", "fs", ".", "statSync", "(", "filepath", ")", ";", "}", "catch", "(", "e", ")", "{", "return", ";", "}", "watchedFiles", "[", "filepath", "]", "=", "statStructure", ";", "mtimes", "[", "filepath", "]", "=", "+", "watchedFiles", "[", "filepath", "]", ".", "mtime", ";", "}", "}" ]

[ "Watch", "a", "file", "." ]

[ "function", "makeArray", "(", "obj", ")", "{", "var", "ary", "=", "[", "]", ";", "if", "(", "isArray", "(", "obj", ")", ")", "{", "ary", "=", "obj", ";", "}", "else", "if", "(", "typeof", "obj", ".", "length", "===", "'number'", ")", "{", "for", "(", "var", "i", "=", "0", ",", "len", "=", "obj", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "ary", ".", "push", "(", "obj", "[", "i", "]", ")", ";", "}", "}", "else", "{", "ary", ".", "push", "(", "obj", ")", ";", "}", "return", "ary", ";", "}" ]

[ "turn", "element", "or", "nodeList", "into", "an", "array" ]

[ "function", "(", "context", ",", "pkg", ",", "source", ")", "{", "source", "=", "source", "||", "\"{}\"", ";", "var", "packageJSON", "=", "JSON", ".", "parse", "(", "source", ")", ";", "utils", ".", "extend", "(", "pkg", ",", "packageJSON", ")", ";", "context", ".", "packages", ".", "push", "(", "pkg", ")", ";", "return", "pkg", ";", "}" ]

[ "Adds", "the", "properties", "read", "from", "a", "package", "s", "source", "to", "the", "pkg", "object", "." ]

[ "function", "(", "context", ",", "pkg", ")", "{", "var", "deps", "=", "crawl", ".", "getDependencyMap", "(", "context", ".", "loader", ",", "pkg", ",", "true", ")", ";", "var", "pluginsPromise", "=", "crawl", ".", "loadPlugins", "(", "context", ",", "pkg", ",", "true", ",", "deps", ",", "true", ")", ";", "var", "stealPromise", "=", "crawl", ".", "loadSteal", "(", "context", ",", "pkg", ",", "true", ",", "deps", ")", ";", "return", "Promise", ".", "all", "(", "[", "pluginsPromise", ",", "stealPromise", "]", ")", ";", "}" ]

[ "Crawl", "from", "the", "root", "only", "fetching", "Steal", "and", "its", "dependencies", "so", "that", "Node", "built", "-", "ins", "are", "autoconfigured", "." ]

[ "function", "(", "context", ",", "pkg", ",", "isRoot", ")", "{", "var", "deps", "=", "crawl", ".", "getDependencies", "(", "context", ".", "loader", ",", "pkg", ",", "isRoot", ")", ";", "return", "Promise", ".", "all", "(", "utils", ".", "filter", "(", "utils", ".", "map", "(", "deps", ",", "function", "(", "childPkg", ")", "{", "return", "crawl", ".", "fetchDep", "(", "context", ",", "pkg", ",", "childPkg", ",", "isRoot", ")", ";", "}", ")", ",", "truthy", ")", ")", ".", "then", "(", "function", "(", "packages", ")", "{", "return", "Promise", ".", "all", "(", "utils", ".", "map", "(", "packages", ",", "function", "(", "childPkg", ")", "{", "if", "(", "childPkg", "&&", "childPkg", ".", "name", "===", "'steal'", ")", "{", "return", "crawl", ".", "deps", "(", "context", ",", "childPkg", ")", ";", "}", "}", ")", ")", ".", "then", "(", "function", "(", ")", "{", "return", "packages", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Crawls", "the", "packages", "dependencies" ]

[ "function", "(", "context", ",", "parentPkg", ",", "childPkg", ",", "isRoot", ")", "{", "var", "pkg", "=", "parentPkg", ";", "var", "isFlat", "=", "context", ".", "isFlatFileStructure", ";", "if", "(", "childPkg", ".", "_isPeerDependency", "&&", "!", "isRoot", ")", "{", "childPkg", ".", "origFileUrl", "=", "nodeModuleAddress", "(", "pkg", ".", "fileUrl", ")", "+", "\"/\"", "+", "childPkg", ".", "name", "+", "\"/package.json\"", ";", "}", "else", "if", "(", "isRoot", ")", "{", "childPkg", ".", "origFileUrl", "=", "utils", ".", "path", ".", "depPackage", "(", "pkg", ".", "fileUrl", ",", "childPkg", ".", "name", ")", ";", "}", "else", "{", "childPkg", ".", "origFileUrl", "=", "childPkg", ".", "nestedFileUrl", "=", "utils", ".", "path", ".", "depPackage", "(", "pkg", ".", "fileUrl", ",", "childPkg", ".", "name", ")", ";", "if", "(", "isFlat", ")", "{", "childPkg", ".", "origFileUrl", "=", "crawl", ".", "parentMostAddress", "(", "context", ",", "childPkg", ")", ";", "}", "}", "if", "(", "crawl", ".", "hasParentPackageThatMatches", "(", "context", ",", "childPkg", ")", ")", "{", "return", ";", "}", "if", "(", "crawl", ".", "isSameRequestedVersionFound", "(", "context", ",", "childPkg", ")", ")", "{", "return", ";", "}", "var", "requestedVersion", "=", "childPkg", ".", "version", ";", "return", "npmLoad", "(", "context", ",", "childPkg", ",", "requestedVersion", ")", ".", "then", "(", "function", "(", "pkg", ")", "{", "crawl", ".", "setVersionsConfig", "(", "context", ",", "pkg", ",", "requestedVersion", ")", ";", "return", "pkg", ";", "}", ")", ";", "}" ]

[ "Fetch", "a", "particular", "package", ".", "json", "dependency" ]

[ "function", "(", "context", ",", "pkg", ",", "isRoot", ",", "deps", ")", "{", "var", "stealPkg", "=", "utils", ".", "filter", "(", "deps", ",", "function", "(", "dep", ")", "{", "return", "dep", "&&", "dep", ".", "name", "===", "\"steal\"", ";", "}", ")", "[", "0", "]", ";", "if", "(", "stealPkg", ")", "{", "return", "crawl", ".", "fetchDep", "(", "context", ",", "pkg", ",", "stealPkg", ",", "isRoot", ")", ".", "then", "(", "function", "(", "childPkg", ")", "{", "if", "(", "childPkg", ")", "{", "return", "crawl", ".", "deps", "(", "context", ",", "childPkg", ")", ";", "}", "}", ")", ";", "}", "else", "{", "return", "Promise", ".", "resolve", "(", ")", ";", "}", "}" ]

[ "Load", "steal", "and", "its", "dependencies", "if", "needed" ]

[ "function", "(", "loader", ",", "packageJSON", ",", "isRoot", ")", "{", "var", "deps", "=", "crawl", ".", "getDependencyMap", "(", "loader", ",", "packageJSON", ",", "isRoot", ")", ";", "var", "dependencies", "=", "[", "]", ";", "for", "(", "var", "name", "in", "deps", ")", "{", "dependencies", ".", "push", "(", "deps", "[", "name", "]", ")", ";", "}", "return", "dependencies", ";", "}" ]

[ "Returns", "an", "array", "of", "the", "dependency", "names", "that", "should", "be", "crawled", "." ]

[ "function", "(", "loader", ",", "packageJSON", ",", "isRoot", ")", "{", "var", "config", "=", "utils", ".", "pkg", ".", "config", "(", "packageJSON", ")", ";", "var", "hasConfig", "=", "!", "!", "config", ";", "var", "npmIgnore", "=", "hasConfig", "&&", "config", ".", "npmIgnore", ";", "function", "convertToMap", "(", "arr", ")", "{", "var", "npmMap", "=", "{", "}", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arr", ".", "length", ";", "i", "++", ")", "{", "npmMap", "[", "arr", "[", "i", "]", "]", "=", "true", ";", "}", "return", "npmMap", ";", "}", "if", "(", "npmIgnore", "&&", "typeof", "npmIgnore", ".", "length", "===", "'number'", ")", "{", "npmIgnore", "=", "config", ".", "npmIgnore", "=", "convertToMap", "(", "npmIgnore", ")", ";", "}", "var", "npmDependencies", "=", "hasConfig", "&&", "config", ".", "npmDependencies", ";", "if", "(", "npmDependencies", "&&", "typeof", "npmDependencies", ".", "length", "===", "\"number\"", ")", "{", "config", ".", "npmDependencies", "=", "convertToMap", "(", "npmDependencies", ")", ";", "}", "npmIgnore", "=", "npmIgnore", "||", "{", "}", ";", "var", "deps", "=", "{", "}", ";", "addDeps", "(", "packageJSON", ",", "packageJSON", ".", "peerDependencies", "||", "{", "}", ",", "deps", ",", "\"peerDependencies\"", ",", "{", "_isPeerDependency", ":", "true", "}", ")", ";", "addDeps", "(", "packageJSON", ",", "packageJSON", ".", "dependencies", "||", "{", "}", ",", "deps", ",", "\"dependencies\"", ")", ";", "if", "(", "isRoot", ")", "{", "addDeps", "(", "packageJSON", ",", "packageJSON", ".", "devDependencies", "||", "{", "}", ",", "deps", ",", "\"devDependencies\"", ")", ";", "}", "return", "deps", ";", "}" ]

[ "Returns", "a", "map", "of", "the", "dependencies", "and", "their", "ranges", "." ]

[ "function", "(", "context", ",", "childPkg", ")", "{", "var", "curAddress", "=", "childPkg", ".", "origFileUrl", ";", "var", "parentAddress", "=", "utils", ".", "path", ".", "parentNodeModuleAddress", "(", "childPkg", ".", "origFileUrl", ")", ";", "while", "(", "parentAddress", ")", "{", "var", "packageAddress", "=", "parentAddress", "+", "\"/\"", "+", "childPkg", ".", "name", "+", "\"/package.json\"", ";", "var", "parentPkg", "=", "context", ".", "paths", "[", "packageAddress", "]", ";", "if", "(", "parentPkg", "&&", "SemVer", ".", "valid", "(", "parentPkg", ".", "version", ")", ")", "{", "if", "(", "SemVer", ".", "satisfies", "(", "parentPkg", ".", "version", ",", "childPkg", ".", "version", ")", ")", "{", "return", "parentPkg", ".", "fileUrl", ";", "}", "else", "{", "return", "curAddress", ";", "}", "}", "parentAddress", "=", "utils", ".", "path", ".", "parentNodeModuleAddress", "(", "packageAddress", ")", ";", "curAddress", "=", "packageAddress", ";", "}", "return", "curAddress", ";", "}" ]

[ "Walk", "up", "the", "parent", "addresses", "until", "you", "run", "into", "the", "root", "or", "a", "conflicting", "package", "and", "return", "that", "as", "the", "address", "." ]

[ "function", "(", "pkg", ")", "{", "var", "pkg", "=", "pkg", "||", "this", ".", "getPackage", "(", ")", ";", "var", "requestedVersion", "=", "this", ".", "requestedVersion", ";", "return", "SemVer", ".", "validRange", "(", "requestedVersion", ")", "&&", "SemVer", ".", "valid", "(", "pkg", ".", "version", ")", "?", "SemVer", ".", "satisfies", "(", "pkg", ".", "version", ",", "requestedVersion", ")", ":", "true", ";", "}" ]

[ "Is", "the", "package", "fetched", "from", "this", "task", "a", "compatible", "version?" ]

[ "function", "(", ")", "{", "var", "loadingTask", "=", "this", ".", "context", ".", "loadingPaths", "[", "this", ".", "fileUrl", "]", ";", "if", "(", "!", "loadingTask", ")", "return", ";", "var", "task", "=", "this", ";", "return", "loadingTask", ".", "promise", ".", "then", "(", "function", "(", ")", "{", "task", ".", "_fetchedPackage", "=", "loadingTask", ".", "getPackage", "(", ")", ";", "var", "firstTaskFailed", "=", "loadingTask", ".", "hadErrorLoading", "(", ")", ";", "var", "currentTaskIsCompatible", "=", "task", ".", "isCompatibleVersion", "(", ")", ";", "var", "firstTaskIsNotCompatible", "=", "!", "loadingTask", ".", "isCompatibleVersion", "(", ")", ";", "if", "(", "currentTaskIsCompatible", "&&", "(", "!", "firstTaskFailed", "||", "firstTaskIsNotCompatible", ")", ")", "{", "task", ".", "failed", "=", "false", ";", "task", ".", "error", "=", "null", ";", "}", "else", "if", "(", "!", "currentTaskIsCompatible", ")", "{", "task", ".", "failed", "=", "true", ";", "task", ".", "error", "=", "new", "Error", "(", "\"Incompatible package version requested\"", ")", ";", "}", "else", "if", "(", "firstTaskFailed", ")", "{", "task", ".", "failed", "=", "true", ";", "task", ".", "error", "=", "loadingTask", ".", "error", ";", "}", "}", ")", ";", "}" ]

[ "Handle", "the", "case", "where", "this", "fileUrl", "is", "already", "loading" ]

[ "function", "(", ")", "{", "var", "loadedPkg", "=", "this", ".", "context", ".", "paths", "[", "this", ".", "fileUrl", "]", ";", "if", "(", "loadedPkg", ")", "{", "this", ".", "_fetchedPackage", "=", "loadedPkg", ";", "if", "(", "!", "this", ".", "isCompatibleVersion", "(", ")", ")", "{", "this", ".", "failed", "=", "true", ";", "}", "return", "Promise", ".", "resolve", "(", ")", ";", "}", "}" ]

[ "Handle", "the", "case", "where", "this", "fileUrl", "has", "already", "loaded", "." ]

[ "function", "(", ")", "{", "var", "pkg", "=", "utils", ".", "extend", "(", "{", "}", ",", "this", ".", "orig", ")", ";", "var", "isFlat", "=", "this", ".", "context", ".", "isFlatFileStructure", ";", "var", "fileUrl", "=", "this", ".", "pkg", ".", "fileUrl", ";", "var", "context", "=", "this", ".", "context", ";", "if", "(", "isFlat", "&&", "!", "pkg", ".", "__crawledNestedPosition", ")", "{", "pkg", ".", "__crawledNestedPosition", "=", "true", ";", "pkg", ".", "nextFileUrl", "=", "pkg", ".", "nestedFileUrl", ";", "}", "else", "{", "var", "parentAddress", "=", "utils", ".", "path", ".", "parentNodeModuleAddress", "(", "fileUrl", ")", ";", "if", "(", "!", "parentAddress", ")", "{", "throw", "new", "Error", "(", "'Did not find '", "+", "pkg", ".", "origFileUrl", ")", ";", "}", "var", "nodeModuleAddress", "=", "parentAddress", "+", "\"/\"", "+", "pkg", ".", "name", "+", "\"/package.json\"", ";", "pkg", ".", "nextFileUrl", "=", "nodeModuleAddress", ";", "}", "return", "pkg", ";", "}" ]

[ "Get", "the", "next", "package", "to", "look", "up", "by", "traversing", "up", "the", "node_modules", ".", "Create", "a", "new", "pkg", "by", "extending", "the", "existing", "one" ]

[ "function", "npmLoad", "(", "context", ",", "pkg", ")", "{", "var", "task", "=", "new", "FetchTask", "(", "context", ",", "pkg", ")", ";", "return", "task", ".", "load", "(", ")", ".", "then", "(", "function", "(", ")", "{", "if", "(", "task", ".", "failed", ")", "{", "return", "npmLoad", "(", "context", ",", "task", ".", "next", "(", ")", ")", ";", "}", "return", "task", ".", "getPackage", "(", ")", ";", "}", ")", ";", "}" ]

[ "Loads", "package", ".", "json", "if", "it", "finds", "one", "it", "sets", "that", "package", "in", "paths", "so", "it", "won", "t", "be", "loaded", "twice", "." ]

[ "function", "transformToString", "(", "xform", ")", "{", "var", "m", "=", "xform", ".", "matrix", ",", "text", "=", "''", ";", "switch", "(", "xform", ".", "type", ")", "{", "case", "1", ":", "text", "=", "'matrix('", "+", "[", "m", ".", "a", ",", "m", ".", "b", ",", "m", ".", "c", ",", "m", ".", "d", ",", "m", ".", "e", ",", "m", ".", "f", "]", ".", "join", "(", "','", ")", "+", "')'", ";", "break", ";", "case", "2", ":", "text", "=", "'translate('", "+", "m", ".", "e", "+", "','", "+", "m", ".", "f", "+", "')'", ";", "break", ";", "case", "3", ":", "if", "(", "m", ".", "a", "==", "m", ".", "d", ")", "{", "text", "=", "'scale('", "+", "m", ".", "a", "+", "')'", ";", "}", "else", "{", "text", "=", "'scale('", "+", "m", ".", "a", "+", "','", "+", "m", ".", "d", "+", "')'", ";", "}", "break", ";", "case", "4", ":", "var", "cx", "=", "0", ",", "cy", "=", "0", ";", "if", "(", "xform", ".", "angle", "!=", "0", ")", "{", "var", "K", "=", "1", "-", "m", ".", "a", ";", "cy", "=", "(", "K", "*", "m", ".", "f", "+", "m", ".", "b", "*", "m", ".", "e", ")", "/", "(", "K", "*", "K", "+", "m", ".", "b", "*", "m", ".", "b", ")", ";", "cx", "=", "(", "m", ".", "e", "-", "m", ".", "b", "*", "cy", ")", "/", "K", ";", "}", "text", "=", "'rotate('", "+", "xform", ".", "angle", "+", "' '", "+", "cx", "+", "','", "+", "cy", "+", "')'", ";", "break", ";", "}", "return", "text", ";", "}" ]

[ "Helper", "function", "." ]

[ "function", "basicIdentityIsSet", "(", ")", "{", "return", "_", ".", "has", "(", "user", ",", "'identities'", ")", "&&", "_", ".", "has", "(", "user", ".", "identities", ",", "'basic'", ")", "&&", "!", "_", ".", "isEmpty", "(", "user", ".", "identities", ".", "basic", ")", ";", "}" ]

[ "Function", "that", "returns", "is", "the", "user", ".", "identities", ".", "basic", "property", "has", "been", "set", "to", "a", "value", "." ]

[ "function", "exists", "(", "cmd", ")", "{", "return", "run", "(", "`", "${", "cmd", "}", "`", ")", ".", "then", "(", "stdout", "=>", "{", "if", "(", "stdout", ".", "trim", "(", ")", ".", "length", "===", "0", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "\"No output\"", ")", ")", ";", "}", "const", "rNotFound", "=", "/", "^[\\w\\-]+ not found", "/", "g", ";", "if", "(", "rNotFound", ".", "test", "(", "cmd", ")", ")", "{", "return", "Promise", ".", "resolve", "(", "false", ")", ";", "}", "return", "Promise", ".", "resolve", "(", "true", ")", ";", "}", ")", ";", "}" ]

[ "returns", "Promise", "which", "fulfills", "with", "true", "if", "command", "exists" ]

[ "function", "Fireproof", "(", "firebaseRef", ",", "promise", ")", "{", "if", "(", "!", "Fireproof", ".", "Promise", ")", "{", "try", "{", "Fireproof", ".", "Promise", "=", "Promise", ";", "}", "catch", "(", "e", ")", "{", "throw", "new", "Error", "(", "'You must supply a Promise library to Fireproof!'", ")", ";", "}", "}", "else", "if", "(", "typeof", "Fireproof", ".", "Promise", "!==", "'function'", ")", "{", "throw", "new", "Error", "(", "'The supplied value of Fireproof.Promise is not a constructor (got '", "+", "Fireproof", ".", "Promise", "+", "')'", ")", ";", "}", "this", ".", "_ref", "=", "firebaseRef", ";", "if", "(", "promise", "&&", "promise", ".", "then", ")", "{", "this", ".", "then", "=", "promise", ".", "then", ".", "bind", "(", "promise", ")", ";", "}", "else", "{", "this", ".", "then", "=", "function", "(", "ok", ",", "fail", ")", "{", "return", "this", ".", "once", "(", "'value'", ",", "function", "(", ")", "{", "}", ")", ".", "then", "(", "ok", "||", "null", ",", "fail", "||", "null", ")", ";", "}", ";", "}", "}" ]

[ "Fireproofs", "an", "existing", "Firebase", "reference", "giving", "it", "magic", "promise", "powers", "." ]

[ "function", "(", "win", ",", "elems", ")", "{", "var", "mode", "=", "svgCanvas", ".", "getMode", "(", ")", ";", "if", "(", "mode", "===", "'select'", ")", "{", "setSelectMode", "(", ")", ";", "}", "var", "is_node", "=", "(", "mode", "==", "\"pathedit\"", ")", ";", "selectedElement", "=", "(", "elems", ".", "length", "===", "1", "||", "elems", "[", "1", "]", "==", "null", "?", "elems", "[", "0", "]", ":", "null", ")", ";", "multiselected", "=", "(", "elems", ".", "length", ">=", "2", "&&", "elems", "[", "1", "]", "!=", "null", ")", ";", "if", "(", "selectedElement", "!=", "null", ")", "{", "if", "(", "!", "is_node", ")", "{", "updateToolbar", "(", ")", ";", "}", "}", "togglePathEditMode", "(", "is_node", ",", "elems", ")", ";", "updateContextPanel", "(", ")", ";", "svgCanvas", ".", "runExtensions", "(", "'selectedChanged'", ",", "{", "elems", ":", "elems", ",", "selectedElement", ":", "selectedElement", ",", "multiselected", ":", "multiselected", "}", ")", ";", "}" ]

[ "called", "when", "we", "ve", "selected", "a", "different", "element" ]

[ "function", "(", "win", ",", "elems", ")", "{", "var", "mode", "=", "svgCanvas", ".", "getMode", "(", ")", ";", "var", "elem", "=", "elems", "[", "0", "]", ";", "if", "(", "!", "elem", ")", "{", "return", ";", "}", "multiselected", "=", "(", "elems", ".", "length", ">=", "2", "&&", "elems", "[", "1", "]", "!=", "null", ")", ";", "if", "(", "!", "multiselected", ")", "{", "switch", "(", "mode", ")", "{", "case", "'rotate'", ":", "var", "ang", "=", "svgCanvas", ".", "getRotationAngle", "(", "elem", ")", ";", "$", "(", "'#angle'", ")", ".", "val", "(", "ang", ")", ";", "$", "(", "'#tool_reorient'", ")", ".", "toggleClass", "(", "'disabled'", ",", "ang", "===", "0", ")", ";", "break", ";", "}", "}", "svgCanvas", ".", "runExtensions", "(", "'elementTransition'", ",", "{", "elems", ":", "elems", "}", ")", ";", "}" ]

[ "Call", "when", "part", "of", "element", "is", "in", "process", "of", "changing", "generally", "on", "mousemove", "actions", "like", "rotate", "move", "etc", "." ]

[ "function", "(", "win", ",", "elems", ")", "{", "var", "i", ",", "mode", "=", "svgCanvas", ".", "getMode", "(", ")", ";", "if", "(", "mode", "===", "'select'", ")", "{", "setSelectMode", "(", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "elems", ".", "length", ";", "++", "i", ")", "{", "var", "elem", "=", "elems", "[", "i", "]", ";", "if", "(", "elem", "&&", "elem", ".", "tagName", "===", "'svg'", ")", "{", "populateLayers", "(", ")", ";", "updateCanvas", "(", ")", ";", "}", "else", "if", "(", "elem", "&&", "selectedElement", "&&", "selectedElement", ".", "parentNode", "==", "null", ")", "{", "selectedElement", "=", "elem", ";", "}", "}", "Editor", ".", "showSaveWarning", "=", "true", ";", "updateContextPanel", "(", ")", ";", "if", "(", "selectedElement", "&&", "mode", "===", "'select'", ")", "{", "paintBox", ".", "fill", ".", "update", "(", ")", ";", "paintBox", ".", "stroke", ".", "update", "(", ")", ";", "}", "svgCanvas", ".", "runExtensions", "(", "'elementChanged'", ",", "{", "elems", ":", "elems", "}", ")", ";", "}" ]

[ "called", "when", "any", "element", "has", "changed" ]

[ "function", "(", "event", ")", "{", "var", "options", "=", "opts", ";", "if", "(", "event", ".", "type", "===", "'keydown'", ")", "{", "var", "flyoutIsSelected", "=", "$", "(", "options", ".", "parent", "+", "'_show'", ")", ".", "hasClass", "(", "'tool_button_current'", ")", ";", "var", "currentOperation", "=", "$", "(", "options", ".", "parent", "+", "'_show'", ")", ".", "attr", "(", "'data-curopt'", ")", ";", "$", ".", "each", "(", "holders", "[", "opts", ".", "parent", "]", ",", "function", "(", "i", ",", "tool", ")", "{", "if", "(", "tool", ".", "sel", "==", "currentOperation", ")", "{", "if", "(", "!", "event", ".", "shiftKey", "||", "!", "flyoutIsSelected", ")", "{", "options", "=", "tool", ";", "}", "else", "{", "options", "=", "holders", "[", "opts", ".", "parent", "]", "[", "i", "+", "1", "]", "||", "holders", "[", "opts", ".", "parent", "]", "[", "0", "]", ";", "}", "}", "}", ")", ";", "}", "if", "(", "$", "(", "this", ")", ".", "hasClass", "(", "'disabled'", ")", ")", "{", "return", "false", ";", "}", "if", "(", "toolButtonClick", "(", "show_sel", ")", ")", "{", "options", ".", "fn", "(", ")", ";", "}", "var", "icon", ";", "if", "(", "options", ".", "icon", ")", "{", "icon", "=", "$", ".", "getSvgIcon", "(", "options", ".", "icon", ",", "true", ")", ";", "}", "else", "{", "icon", "=", "$", "(", "options", ".", "sel", ")", ".", "children", "(", ")", ".", "eq", "(", "0", ")", ".", "clone", "(", ")", ";", "}", "icon", "[", "0", "]", ".", "setAttribute", "(", "'width'", ",", "shower", ".", "width", "(", ")", ")", ";", "icon", "[", "0", "]", ".", "setAttribute", "(", "'height'", ",", "shower", ".", "height", "(", ")", ")", ";", "shower", ".", "children", "(", "':not(.flyout_arrow_horiz)'", ")", ".", "remove", "(", ")", ";", "shower", ".", "append", "(", "icon", ")", ".", "attr", "(", "'data-curopt'", ",", "options", ".", "sel", ")", ";", "}" ]

[ "Clicking", "the", "icon", "in", "flyout", "should", "set", "this", "set", "s", "icon" ]

[ "function", "(", "close", ")", "{", "var", "w", "=", "$", "(", "'#sidepanels'", ")", ".", "width", "(", ")", ";", "var", "deltaX", "=", "(", "w", ">", "2", "||", "close", "?", "2", ":", "SIDEPANEL_OPENWIDTH", ")", "-", "w", ";", "changeSidePanelWidth", "(", "deltaX", ")", ";", "}" ]

[ "if", "width", "is", "non", "-", "zero", "then", "fully", "close", "it", "otherwise", "fully", "open", "it", "the", "optional", "close", "argument", "forces", "the", "side", "panel", "closed" ]

[ "function", "(", "width", ",", "height", ")", "{", "var", "newImage", "=", "svgCanvas", ".", "addSvgElementFromJson", "(", "{", "element", ":", "'image'", ",", "attr", ":", "{", "x", ":", "0", ",", "y", ":", "0", ",", "width", ":", "width", ",", "height", ":", "height", ",", "id", ":", "svgCanvas", ".", "getNextId", "(", ")", ",", "style", ":", "'pointer-events:inherit'", "}", "}", ")", ";", "svgCanvas", ".", "setHref", "(", "newImage", ",", "e", ".", "target", ".", "result", ")", ";", "svgCanvas", ".", "selectOnly", "(", "[", "newImage", "]", ")", ";", "svgCanvas", ".", "alignSelectedElements", "(", "'m'", ",", "'page'", ")", ";", "svgCanvas", ".", "alignSelectedElements", "(", "'c'", ",", "'page'", ")", ";", "updateContextPanel", "(", ")", ";", "}" ]

[ "let", "s", "insert", "the", "new", "image", "until", "we", "know", "its", "dimensions" ]

[ "function", "(", "data", ",", "hashId", ",", "key", ")", "{", "if", "(", "hashId", "==", "-", "1", ")", "{", "data", ".", "inputChar", "=", "key", ";", "data", ".", "lastEvent", "=", "\"input\"", ";", "}", "else", "if", "(", "data", ".", "inputChar", "&&", "data", ".", "$lastHash", "==", "hashId", "&&", "data", ".", "$lastKey", "==", "key", ")", "{", "if", "(", "data", ".", "lastEvent", "==", "\"input\"", ")", "{", "data", ".", "lastEvent", "=", "\"input1\"", ";", "}", "else", "if", "(", "data", ".", "lastEvent", "==", "\"input1\"", ")", "{", "return", "true", ";", "}", "}", "else", "{", "data", ".", "$lastHash", "=", "hashId", ";", "data", ".", "$lastKey", "=", "key", ";", "data", ".", "lastEvent", "=", "\"keypress\"", ";", "}", "}" ]

[ "workaround", "for", "j", "not", "repeating", "with", "defaults", "write", "-", "g", "ApplePressAndHoldEnabled", "-", "bool", "true" ]

[ "function", "convertPropertyNames", "(", "context", ",", "pkg", ",", "map", ",", "root", ",", "waiting", ")", "{", "if", "(", "!", "map", ")", "{", "return", "map", ";", "}", "var", "clone", "=", "{", "}", ",", "value", ";", "for", "(", "var", "property", "in", "map", ")", "{", "value", "=", "convertName", "(", "context", ",", "pkg", ",", "map", ",", "root", ",", "property", ",", "waiting", ")", ";", "if", "(", "typeof", "value", "===", "'string'", ")", "{", "clone", "[", "value", "]", "=", "map", "[", "property", "]", ";", "}", "if", "(", "root", ")", "{", "value", "=", "convertName", "(", "context", ",", "pkg", ",", "map", ",", "false", ",", "property", ",", "waiting", ")", ";", "if", "(", "typeof", "value", "===", "'string'", ")", "{", "clone", "[", "value", "]", "=", "map", "[", "property", "]", ";", "}", "}", "}", "return", "clone", ";", "}" ]

[ "converts", "only", "the", "property", "name" ]

[ "function", "convertPropertyNamesAndValues", "(", "context", ",", "pkg", ",", "map", ",", "root", ",", "waiting", ")", "{", "if", "(", "!", "map", ")", "{", "return", "map", ";", "}", "var", "clone", "=", "{", "}", ",", "val", ",", "name", ";", "for", "(", "var", "property", "in", "map", ")", "{", "val", "=", "map", "[", "property", "]", ";", "name", "=", "convertName", "(", "context", ",", "pkg", ",", "map", ",", "root", ",", "property", ",", "waiting", ")", ";", "val", "=", "typeof", "val", "===", "\"object\"", "?", "convertPropertyNamesAndValues", "(", "context", ",", "pkg", ",", "val", ",", "root", ",", "waiting", ")", ":", "convertName", "(", "context", ",", "pkg", ",", "map", ",", "root", ",", "val", ",", "waiting", ")", ";", "if", "(", "typeof", "name", "!==", "'undefined'", "&&", "typeof", "val", "!==", "'undefined'", ")", "{", "clone", "[", "name", "]", "=", "val", ";", "}", "}", "return", "clone", ";", "}" ]

[ "converts", "both", "property", "name", "and", "value" ]

[ "function", "convertBrowser", "(", "pkg", ",", "browser", ")", "{", "var", "type", "=", "typeof", "browser", ";", "if", "(", "type", "===", "\"string\"", "||", "type", "===", "\"undefined\"", ")", "{", "return", "browser", ";", "}", "var", "map", "=", "{", "}", ";", "for", "(", "var", "fromName", "in", "browser", ")", "{", "convertBrowserProperty", "(", "map", ",", "pkg", ",", "fromName", ",", "browser", "[", "fromName", "]", ")", ";", "}", "return", "map", ";", "}" ]

[ "Converts", "browser", "names", "into", "actual", "module", "names", "." ]

[ "function", "convertForPackage", "(", "context", ",", "pkg", ")", "{", "var", "name", "=", "pkg", ".", "name", ";", "var", "version", "=", "pkg", ".", "version", ";", "var", "conv", "=", "context", ".", "deferredConversions", ";", "var", "pkgConv", "=", "conv", "[", "name", "]", ";", "var", "depPkg", ",", "fns", ",", "keys", "=", "0", ";", "if", "(", "pkgConv", ")", "{", "for", "(", "var", "range", "in", "pkgConv", ")", "{", "depPkg", "=", "crawl", ".", "matchedVersion", "(", "context", ",", "name", ",", "range", ")", ";", "if", "(", "depPkg", ")", "{", "fns", "=", "pkgConv", "[", "range", "]", ";", "for", "(", "var", "i", "=", "0", ",", "len", "=", "fns", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "fns", "[", "i", "]", ".", "call", "(", "context", ")", ";", "}", "delete", "pkgConv", "[", "range", "]", ";", "}", "else", "{", "keys", "++", ";", "}", "}", "if", "(", "keys", "===", "0", ")", "{", "delete", "conv", "[", "name", "]", ";", "}", "}", "}" ]

[ "When", "progressively", "loading", "package", ".", "jsons", "we", "need", "to", "convert", "any", "config", "that", "is", "waiting", "on", "a", "package", ".", "json", "to", "load", ".", "This", "function", "is", "called", "after", "a", "package", "is", "loaded", "and", "will", "call", "all", "of", "the", "callbacks", "that", "cause", "the", "config", "to", "be", "applied", "." ]

[ "function", "rebuildInput", "(", "form", ")", "{", "form", ".", "empty", "(", ")", ";", "var", "inp", "=", "$", "(", "'<input type=\"file\" name=\"svg_file\">'", ")", ".", "appendTo", "(", "form", ")", ";", "function", "submit", "(", ")", "{", "form", ".", "submit", "(", ")", ";", "rebuildInput", "(", "form", ")", ";", "$", ".", "process_cancel", "(", "\"Uploading...\"", ",", "function", "(", ")", "{", "cancelled", "=", "true", ";", "$", "(", "'#dialog_box'", ")", ".", "hide", "(", ")", ";", "}", ")", ";", "}", "if", "(", "form", "[", "0", "]", "==", "open_svg_form", "[", "0", "]", ")", "{", "inp", ".", "change", "(", "function", "(", ")", "{", "svgEditor", ".", "openPrep", "(", "function", "(", "ok", ")", "{", "if", "(", "!", "ok", ")", "{", "rebuildInput", "(", "form", ")", ";", "return", ";", "}", "submit", "(", ")", ";", "}", ")", ";", "}", ")", ";", "}", "else", "{", "inp", ".", "change", "(", "function", "(", ")", "{", "submit", "(", ")", ";", "}", ")", ";", "}", "}" ]

[ "It", "appears", "necessary", "to", "rebuild", "this", "input", "every", "time", "a", "file", "is", "selected", "so", "the", "same", "file", "can", "be", "picked", "and", "the", "change", "event", "can", "fire", "." ]

[ "function", "max", "(", "compare", ",", "iterable", ",", "dflt", "=", "undefined", ")", "{", "let", "iterator", "=", "(", "0", ",", "_iter", ".", "iter", ")", "(", "iterable", ")", ";", "let", "first", "=", "iterator", ".", "next", "(", ")", ";", "if", "(", "first", ".", "done", ")", "return", "dflt", ";", "let", "largest", "=", "first", ".", "value", ";", "for", "(", "let", "candidate", "of", "iterator", ")", "{", "if", "(", "compare", "(", "candidate", ",", "largest", ")", ">", "0", ")", "{", "largest", "=", "candidate", ";", "}", "}", "return", "largest", ";", "}" ]

[ "Returns", "the", "largest", "element", "of", "the", "input", "iterable", "according", "to", "some", "comparison", "function", "." ]

[ "function", "(", ")", "{", "self", ".", "value", "+=", "stepValue", ";", "self", ".", "setValue", "(", "self", ".", "value", ")", ";", "self", ".", "triggerScrollEvent", "(", "self", ".", "value", ")", ";", "if", "(", "isFinishedScrolling", "(", ")", ")", "{", "clearInterval", "(", "self", ".", "pageScrollTimer", ")", ";", "}", "}" ]

[ "scroll", "by", "page", "when", "track", "is", "pressed" ]

[ "function", "SelectList", "(", "options", ")", "{", "this", ".", "options", "=", "$", ".", "extend", "(", "{", "holder", ":", "null", ",", "maxVisibleItems", ":", "10", ",", "selectOnClick", ":", "true", ",", "useHoverClass", ":", "false", ",", "useCustomScroll", ":", "false", ",", "handleResize", ":", "true", ",", "multipleSelectWithoutKey", ":", "false", ",", "alwaysPreventMouseWheel", ":", "false", ",", "indexAttribute", ":", "'data-index'", ",", "cloneClassPrefix", ":", "'jcf-option-'", ",", "containerStructure", ":", "'<span class=\"jcf-list\"><span class=\"jcf-list-content\"></span></span>'", ",", "containerSelector", ":", "'.jcf-list-content'", ",", "captionClass", ":", "'jcf-optgroup-caption'", ",", "disabledClass", ":", "'jcf-disabled'", ",", "optionClass", ":", "'jcf-option'", ",", "groupClass", ":", "'jcf-optgroup'", ",", "hoverClass", ":", "'jcf-hover'", ",", "selectedClass", ":", "'jcf-selected'", ",", "scrollClass", ":", "'jcf-scroll-active'", "}", ",", "options", ")", ";", "this", ".", "init", "(", ")", ";", "}" ]

[ "options", "list", "module" ]

[ "function", "isSerializedHelper", "(", "obj", ")", "{", "if", "(", "typeReflections", ".", "isPrimitive", "(", "obj", ")", ")", "{", "return", "true", ";", "}", "if", "(", "hasUpdateSymbol", "(", "obj", ")", ")", "{", "return", "false", ";", "}", "return", "typeReflections", ".", "isBuiltIn", "(", "obj", ")", "&&", "!", "typeReflections", ".", "isPlainObject", "(", "obj", ")", "&&", "!", "Array", ".", "isArray", "(", "obj", ")", ";", "}" ]

[ "is", "the", "value", "itself", "its", "serialized", "value" ]

[ "function", "(", "obj", ")", "{", "var", "hasOwnKey", "=", "obj", "[", "canSymbol", ".", "for", "(", "\"can.hasOwnKey\"", ")", "]", ";", "if", "(", "hasOwnKey", ")", "{", "return", "hasOwnKey", ".", "bind", "(", "obj", ")", ";", "}", "else", "{", "var", "map", "=", "makeMap", "(", "shapeReflections", ".", "getOwnEnumerableKeys", "(", "obj", ")", ")", ";", "return", "function", "(", "key", ")", "{", "return", "map", ".", "get", "(", "key", ")", ";", "}", ";", "}", "}" ]

[ "creates", "an", "optimized", "hasOwnKey", "lookup", ".", "If", "the", "object", "has", "hasOwnKey", "then", "we", "just", "use", "that", ".", "Otherwise", "try", "to", "put", "all", "keys", "in", "a", "map", "." ]

[ "function", "addPatch", "(", "patches", ",", "patch", ")", "{", "var", "lastPatch", "=", "patches", "[", "patches", ".", "length", "-", "1", "]", ";", "if", "(", "lastPatch", ")", "{", "if", "(", "lastPatch", ".", "deleteCount", "===", "lastPatch", ".", "insert", ".", "length", "&&", "(", "patch", ".", "index", "-", "lastPatch", ".", "index", "===", "lastPatch", ".", "deleteCount", ")", ")", "{", "lastPatch", ".", "insert", ".", "push", ".", "apply", "(", "lastPatch", ".", "insert", ",", "patch", ".", "insert", ")", ";", "lastPatch", ".", "deleteCount", "+=", "patch", ".", "deleteCount", ";", "return", ";", "}", "}", "patches", ".", "push", "(", "patch", ")", ";", "}" ]

[ "combines", "patches", "if", "it", "makes", "sense" ]

[ "function", "setComparator", "(", ")", "{", "if", "(", "by", ".", "substring", "(", "0", ",", "3", ")", "==", "'asc'", ")", "{", "var", "i", "=", "by", ".", "substring", "(", "3", ")", ";", "comp", "=", "function", "(", "a", ",", "b", ")", "{", "return", "a", "[", "i", "]", "-", "b", "[", "i", "]", ";", "}", ";", "}", "else", "{", "comp", "=", "function", "(", "a", ",", "b", ")", "{", "return", "b", "[", "by", "]", "-", "a", "[", "by", "]", ";", "}", ";", "}", "$", "(", "'a.sel'", ")", ".", "attr", "(", "'href'", ",", "'#'", ")", ".", "removeClass", "(", "'sel'", ")", ";", "$", "(", "'a.by'", "+", "by", ")", ".", "removeAttr", "(", "'href'", ")", ".", "addClass", "(", "'sel'", ")", ";", "}" ]

[ "Set", "comp", "which", "is", "a", "comparator", "function", "used", "for", "sorting", "and", "inserting", "comments", "into", "the", "list", "." ]

[ "function", "initComparator", "(", ")", "{", "by", "=", "'rating'", ";", "if", "(", "document", ".", "cookie", ".", "length", ">", "0", ")", "{", "var", "start", "=", "document", ".", "cookie", ".", "indexOf", "(", "'sortBy='", ")", ";", "if", "(", "start", "!=", "-", "1", ")", "{", "start", "=", "start", "+", "7", ";", "var", "end", "=", "document", ".", "cookie", ".", "indexOf", "(", "\";\"", ",", "start", ")", ";", "if", "(", "end", "==", "-", "1", ")", "{", "end", "=", "document", ".", "cookie", ".", "length", ";", "by", "=", "unescape", "(", "document", ".", "cookie", ".", "substring", "(", "start", ",", "end", ")", ")", ";", "}", "}", "}", "setComparator", "(", ")", ";", "}" ]

[ "Create", "a", "comp", "function", ".", "If", "the", "user", "has", "preferences", "stored", "in", "the", "sortBy", "cookie", "use", "those", "otherwise", "use", "the", "default", "." ]

[ "function", "show", "(", "id", ")", "{", "$", "(", "'#ao'", "+", "id", ")", ".", "hide", "(", ")", ";", "$", "(", "'#ah'", "+", "id", ")", ".", "show", "(", ")", ";", "var", "context", "=", "$", ".", "extend", "(", "{", "id", ":", "id", "}", ",", "opts", ")", ";", "var", "popup", "=", "$", "(", "renderTemplate", "(", "popupTemplate", ",", "context", ")", ")", ".", "hide", "(", ")", ";", "popup", ".", "find", "(", "'textarea[name=\"proposal\"]'", ")", ".", "hide", "(", ")", ";", "popup", ".", "find", "(", "'a.by'", "+", "by", ")", ".", "addClass", "(", "'sel'", ")", ";", "var", "form", "=", "popup", ".", "find", "(", "'#cf'", "+", "id", ")", ";", "form", ".", "submit", "(", "function", "(", "event", ")", "{", "event", ".", "preventDefault", "(", ")", ";", "addComment", "(", "form", ")", ";", "}", ")", ";", "$", "(", "'#s'", "+", "id", ")", ".", "after", "(", "popup", ")", ";", "popup", ".", "slideDown", "(", "'fast'", ",", "function", "(", ")", "{", "getComments", "(", "id", ")", ";", "}", ")", ";", "}" ]

[ "Show", "a", "comment", "div", "." ]

[ "function", "hide", "(", "id", ")", "{", "$", "(", "'#ah'", "+", "id", ")", ".", "hide", "(", ")", ";", "$", "(", "'#ao'", "+", "id", ")", ".", "show", "(", ")", ";", "var", "div", "=", "$", "(", "'#sc'", "+", "id", ")", ";", "div", ".", "slideUp", "(", "'fast'", ",", "function", "(", ")", "{", "div", ".", "remove", "(", ")", ";", "}", ")", ";", "}" ]

[ "Hide", "a", "comment", "div", "." ]

[ "function", "getComments", "(", "id", ")", "{", "$", ".", "ajax", "(", "{", "type", ":", "'GET'", ",", "url", ":", "opts", ".", "getCommentsURL", ",", "data", ":", "{", "node", ":", "id", "}", ",", "success", ":", "function", "(", "data", ",", "textStatus", ",", "request", ")", "{", "var", "ul", "=", "$", "(", "'#cl'", "+", "id", ")", ";", "var", "speed", "=", "100", ";", "$", "(", "'#cf'", "+", "id", ")", ".", "find", "(", "'textarea[name=\"proposal\"]'", ")", ".", "data", "(", "'source'", ",", "data", ".", "source", ")", ";", "if", "(", "data", ".", "comments", ".", "length", "===", "0", ")", "{", "ul", ".", "html", "(", "'<li>No comments yet.</li>'", ")", ";", "ul", ".", "data", "(", "'empty'", ",", "true", ")", ";", "}", "else", "{", "var", "comments", "=", "sortComments", "(", "data", ".", "comments", ")", ";", "speed", "=", "data", ".", "comments", ".", "length", "*", "100", ";", "appendComments", "(", "comments", ",", "ul", ")", ";", "ul", ".", "data", "(", "'empty'", ",", "false", ")", ";", "}", "$", "(", "'#cn'", "+", "id", ")", ".", "slideUp", "(", "speed", "+", "200", ")", ";", "ul", ".", "slideDown", "(", "speed", ")", ";", "}", ",", "error", ":", "function", "(", "request", ",", "textStatus", ",", "error", ")", "{", "showError", "(", "'Oops, there was a problem retrieving the comments.'", ")", ";", "}", ",", "dataType", ":", "'json'", "}", ")", ";", "}" ]

[ "Perform", "an", "ajax", "request", "to", "get", "comments", "for", "a", "node", "and", "insert", "the", "comments", "into", "the", "comments", "tree", "." ]

[ "function", "addComment", "(", "form", ")", "{", "var", "node_id", "=", "form", ".", "find", "(", "'input[name=\"node\"]'", ")", ".", "val", "(", ")", ";", "var", "parent_id", "=", "form", ".", "find", "(", "'input[name=\"parent\"]'", ")", ".", "val", "(", ")", ";", "var", "text", "=", "form", ".", "find", "(", "'textarea[name=\"comment\"]'", ")", ".", "val", "(", ")", ";", "var", "proposal", "=", "form", ".", "find", "(", "'textarea[name=\"proposal\"]'", ")", ".", "val", "(", ")", ";", "if", "(", "text", "==", "''", ")", "{", "showError", "(", "'Please enter a comment.'", ")", ";", "return", ";", "}", "form", ".", "find", "(", "'textarea,input'", ")", ".", "attr", "(", "'disabled'", ",", "'disabled'", ")", ";", "$", ".", "ajax", "(", "{", "type", ":", "\"POST\"", ",", "url", ":", "opts", ".", "addCommentURL", ",", "dataType", ":", "'json'", ",", "data", ":", "{", "node", ":", "node_id", ",", "parent", ":", "parent_id", ",", "text", ":", "text", ",", "proposal", ":", "proposal", "}", ",", "success", ":", "function", "(", "data", ",", "textStatus", ",", "error", ")", "{", "if", "(", "node_id", ")", "{", "hideProposeChange", "(", "node_id", ")", ";", "}", "form", ".", "find", "(", "'textarea'", ")", ".", "val", "(", "''", ")", ".", "add", "(", "form", ".", "find", "(", "'input'", ")", ")", ".", "removeAttr", "(", "'disabled'", ")", ";", "var", "ul", "=", "$", "(", "'#cl'", "+", "(", "node_id", "||", "parent_id", ")", ")", ";", "if", "(", "ul", ".", "data", "(", "'empty'", ")", ")", "{", "$", "(", "ul", ")", ".", "empty", "(", ")", ";", "ul", ".", "data", "(", "'empty'", ",", "false", ")", ";", "}", "insertComment", "(", "data", ".", "comment", ")", ";", "var", "ao", "=", "$", "(", "'#ao'", "+", "node_id", ")", ";", "ao", ".", "find", "(", "'img'", ")", ".", "attr", "(", "{", "'src'", ":", "opts", ".", "commentBrightImage", "}", ")", ";", "if", "(", "node_id", ")", "{", "$", "(", "'#ca'", "+", "node_id", ")", ".", "slideUp", "(", ")", ";", "}", "}", ",", "error", ":", "function", "(", "request", ",", "textStatus", ",", "error", ")", "{", "form", ".", "find", "(", "'textarea,input'", ")", ".", "removeAttr", "(", "'disabled'", ")", ";", "showError", "(", "'Oops, there was a problem adding the comment.'", ")", ";", "}", "}", ")", ";", "}" ]

[ "Add", "a", "comment", "via", "ajax", "and", "insert", "the", "comment", "into", "the", "comment", "tree", "." ]

[ "function", "appendComments", "(", "comments", ",", "ul", ")", "{", "$", ".", "each", "(", "comments", ",", "function", "(", ")", "{", "var", "div", "=", "createCommentDiv", "(", "this", ")", ";", "ul", ".", "append", "(", "$", "(", "document", ".", "createElement", "(", "'li'", ")", ")", ".", "html", "(", "div", ")", ")", ";", "appendComments", "(", "this", ".", "children", ",", "div", ".", "find", "(", "'ul.comment-children'", ")", ")", ";", "this", ".", "children", "=", "null", ";", "div", ".", "data", "(", "'comment'", ",", "this", ")", ";", "}", ")", ";", "}" ]

[ "Recursively", "append", "comments", "to", "the", "main", "comment", "list", "and", "children", "lists", "creating", "the", "comment", "tree", "." ]

[ "function", "insertComment", "(", "comment", ")", "{", "var", "div", "=", "createCommentDiv", "(", "comment", ")", ";", "comment", ".", "children", "=", "null", ";", "div", ".", "data", "(", "'comment'", ",", "comment", ")", ";", "var", "ul", "=", "$", "(", "'#cl'", "+", "(", "comment", ".", "node", "||", "comment", ".", "parent", ")", ")", ";", "var", "siblings", "=", "getChildren", "(", "ul", ")", ";", "var", "li", "=", "$", "(", "document", ".", "createElement", "(", "'li'", ")", ")", ";", "li", ".", "hide", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "siblings", ".", "length", ";", "i", "++", ")", "{", "if", "(", "comp", "(", "comment", ",", "siblings", "[", "i", "]", ")", "<=", "0", ")", "{", "$", "(", "'#cd'", "+", "siblings", "[", "i", "]", ".", "id", ")", ".", "parent", "(", ")", ".", "before", "(", "li", ".", "html", "(", "div", ")", ")", ";", "li", ".", "slideDown", "(", "'fast'", ")", ";", "return", ";", "}", "}", "ul", ".", "append", "(", "li", ".", "html", "(", "div", ")", ")", ";", "li", ".", "slideDown", "(", "'fast'", ")", ";", "}" ]

[ "After", "adding", "a", "new", "comment", "it", "must", "be", "inserted", "in", "the", "correct", "location", "in", "the", "comment", "tree", "." ]

[ "function", "handleReSort", "(", "link", ")", "{", "var", "classes", "=", "link", ".", "attr", "(", "'class'", ")", ".", "split", "(", "/", "\\s+", "/", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "classes", ".", "length", ";", "i", "++", ")", "{", "if", "(", "classes", "[", "i", "]", "!=", "'sort-option'", ")", "{", "by", "=", "classes", "[", "i", "]", ".", "substring", "(", "2", ")", ";", "}", "}", "setComparator", "(", ")", ";", "var", "expiration", "=", "new", "Date", "(", ")", ";", "expiration", ".", "setDate", "(", "expiration", ".", "getDate", "(", ")", "+", "365", ")", ";", "document", ".", "cookie", "=", "'sortBy='", "+", "escape", "(", "by", ")", "+", "';expires='", "+", "expiration", ".", "toUTCString", "(", ")", ";", "$", "(", "'ul.comment-ul'", ")", ".", "each", "(", "function", "(", "index", ",", "ul", ")", "{", "var", "comments", "=", "getChildren", "(", "$", "(", "ul", ")", ",", "true", ")", ";", "comments", "=", "sortComments", "(", "comments", ")", ";", "appendComments", "(", "comments", ",", "$", "(", "ul", ")", ".", "empty", "(", ")", ")", ";", "}", ")", ";", "}" ]

[ "Handle", "when", "the", "user", "clicks", "on", "a", "sort", "by", "link", "." ]

[ "function", "handleVote", "(", "link", ")", "{", "if", "(", "!", "opts", ".", "voting", ")", "{", "showError", "(", "\"You'll need to login to vote.\"", ")", ";", "return", ";", "}", "var", "id", "=", "link", ".", "attr", "(", "'id'", ")", ";", "if", "(", "!", "id", ")", "{", "return", ";", "}", "var", "value", "=", "0", ";", "if", "(", "id", ".", "charAt", "(", "1", ")", "!=", "'u'", ")", "{", "value", "=", "id", ".", "charAt", "(", "0", ")", "==", "'u'", "?", "1", ":", "-", "1", ";", "}", "var", "d", "=", "{", "comment_id", ":", "id", ".", "substring", "(", "2", ")", ",", "value", ":", "value", "}", ";", "link", ".", "hide", "(", ")", ";", "$", "(", "'#'", "+", "id", ".", "charAt", "(", "0", ")", "+", "(", "id", ".", "charAt", "(", "1", ")", "==", "'u'", "?", "'v'", ":", "'u'", ")", "+", "d", ".", "comment_id", ")", ".", "show", "(", ")", ";", "var", "div", "=", "$", "(", "'div#cd'", "+", "d", ".", "comment_id", ")", ";", "var", "data", "=", "div", ".", "data", "(", "'comment'", ")", ";", "if", "(", "(", "d", ".", "value", "!==", "0", ")", "&&", "(", "data", ".", "vote", "===", "d", ".", "value", "*", "-", "1", ")", ")", "{", "$", "(", "'#'", "+", "(", "d", ".", "value", "==", "1", "?", "'d'", ":", "'u'", ")", "+", "'u'", "+", "d", ".", "comment_id", ")", ".", "hide", "(", ")", ";", "$", "(", "'#'", "+", "(", "d", ".", "value", "==", "1", "?", "'d'", ":", "'u'", ")", "+", "'v'", "+", "d", ".", "comment_id", ")", ".", "show", "(", ")", ";", "}", "data", ".", "rating", "+=", "(", "data", ".", "vote", "===", "0", ")", "?", "d", ".", "value", ":", "(", "d", ".", "value", "-", "data", ".", "vote", ")", ";", "data", ".", "vote", "=", "d", ".", "value", ";", "div", ".", "data", "(", "'comment'", ",", "data", ")", ";", "div", ".", "find", "(", "'.rating:first'", ")", ".", "text", "(", "data", ".", "rating", "+", "' point'", "+", "(", "data", ".", "rating", "==", "1", "?", "''", ":", "'s'", ")", ")", ";", "$", ".", "ajax", "(", "{", "type", ":", "\"POST\"", ",", "url", ":", "opts", ".", "processVoteURL", ",", "data", ":", "d", ",", "error", ":", "function", "(", "request", ",", "textStatus", ",", "error", ")", "{", "showError", "(", "'Oops, there was a problem casting that vote.'", ")", ";", "}", "}", ")", ";", "}" ]

[ "Function", "to", "process", "a", "vote", "when", "a", "user", "clicks", "an", "arrow", "." ]

[ "function", "openReply", "(", "id", ")", "{", "$", "(", "'#rl'", "+", "id", ")", ".", "hide", "(", ")", ";", "$", "(", "'#cr'", "+", "id", ")", ".", "show", "(", ")", ";", "var", "div", "=", "$", "(", "renderTemplate", "(", "replyTemplate", ",", "{", "id", ":", "id", "}", ")", ")", ".", "hide", "(", ")", ";", "$", "(", "'#cl'", "+", "id", ")", ".", "prepend", "(", "div", ")", ".", "find", "(", "'#rf'", "+", "id", ")", ".", "submit", "(", "function", "(", "event", ")", "{", "event", ".", "preventDefault", "(", ")", ";", "addComment", "(", "$", "(", "'#rf'", "+", "id", ")", ")", ";", "closeReply", "(", "id", ")", ";", "}", ")", ".", "find", "(", "'input[type=button]'", ")", ".", "click", "(", "function", "(", ")", "{", "closeReply", "(", "id", ")", ";", "}", ")", ";", "div", ".", "slideDown", "(", "'fast'", ",", "function", "(", ")", "{", "$", "(", "'#rf'", "+", "id", ")", ".", "find", "(", "'textarea'", ")", ".", "focus", "(", ")", ";", "}", ")", ";", "}" ]

[ "Open", "a", "reply", "form", "used", "to", "reply", "to", "an", "existing", "comment", "." ]

[ "function", "sortComments", "(", "comments", ")", "{", "comments", ".", "sort", "(", "comp", ")", ";", "$", ".", "each", "(", "comments", ",", "function", "(", ")", "{", "this", ".", "children", "=", "sortComments", "(", "this", ".", "children", ")", ";", "}", ")", ";", "return", "comments", ";", "}" ]

[ "Recursively", "sort", "a", "tree", "of", "comments", "using", "the", "comp", "comparator", "." ]

[ "function", "getChildren", "(", "ul", ",", "recursive", ")", "{", "var", "children", "=", "[", "]", ";", "ul", ".", "children", "(", ")", ".", "children", "(", "\"[id^='cd']\"", ")", ".", "each", "(", "function", "(", ")", "{", "var", "comment", "=", "$", "(", "this", ")", ".", "data", "(", "'comment'", ")", ";", "if", "(", "recursive", ")", "comment", ".", "children", "=", "getChildren", "(", "$", "(", "this", ")", ".", "find", "(", "'#cl'", "+", "comment", ".", "id", ")", ",", "true", ")", ";", "children", ".", "push", "(", "comment", ")", ";", "}", ")", ";", "return", "children", ";", "}" ]

[ "Get", "the", "children", "comments", "from", "a", "ul", ".", "If", "recursive", "is", "true", "recursively", "include", "childrens", "children", "." ]

[ "function", "createCommentDiv", "(", "comment", ")", "{", "if", "(", "!", "comment", ".", "displayed", "&&", "!", "opts", ".", "moderator", ")", "{", "return", "$", "(", "'<div class=\"moderate\">Thank you! Your comment will show up '", "+", "'once it is has been approved by a moderator.</div>'", ")", ";", "}", "comment", ".", "pretty_rating", "=", "comment", ".", "rating", "+", "' point'", "+", "(", "comment", ".", "rating", "==", "1", "?", "''", ":", "'s'", ")", ";", "comment", ".", "css_class", "=", "comment", ".", "displayed", "?", "''", ":", "' moderate'", ";", "var", "context", "=", "$", ".", "extend", "(", "{", "}", ",", "opts", ",", "comment", ")", ";", "var", "div", "=", "$", "(", "renderTemplate", "(", "commentTemplate", ",", "context", ")", ")", ";", "if", "(", "comment", ".", "vote", ")", "{", "var", "direction", "=", "(", "comment", ".", "vote", "==", "1", ")", "?", "'u'", ":", "'d'", ";", "div", ".", "find", "(", "'#'", "+", "direction", "+", "'v'", "+", "comment", ".", "id", ")", ".", "hide", "(", ")", ";", "div", ".", "find", "(", "'#'", "+", "direction", "+", "'u'", "+", "comment", ".", "id", ")", ".", "show", "(", ")", ";", "}", "if", "(", "opts", ".", "moderator", "||", "comment", ".", "text", "!=", "'[deleted]'", ")", "{", "div", ".", "find", "(", "'a.reply'", ")", ".", "show", "(", ")", ";", "if", "(", "comment", ".", "proposal_diff", ")", "div", ".", "find", "(", "'#sp'", "+", "comment", ".", "id", ")", ".", "show", "(", ")", ";", "if", "(", "opts", ".", "moderator", "&&", "!", "comment", ".", "displayed", ")", "div", ".", "find", "(", "'#cm'", "+", "comment", ".", "id", ")", ".", "show", "(", ")", ";", "if", "(", "opts", ".", "moderator", "||", "(", "opts", ".", "username", "==", "comment", ".", "username", ")", ")", "div", ".", "find", "(", "'#dc'", "+", "comment", ".", "id", ")", ".", "show", "(", ")", ";", "}", "return", "div", ";", "}" ]

[ "Create", "a", "div", "to", "display", "a", "comment", "in", "." ]

[ "function", "showError", "(", "message", ")", "{", "$", "(", "document", ".", "createElement", "(", "'div'", ")", ")", ".", "attr", "(", "{", "'class'", ":", "'popup-error'", "}", ")", ".", "append", "(", "$", "(", "document", ".", "createElement", "(", "'div'", ")", ")", ".", "attr", "(", "{", "'class'", ":", "'error-message'", "}", ")", ".", "text", "(", "message", ")", ")", ".", "appendTo", "(", "'body'", ")", ".", "fadeIn", "(", "\"slow\"", ")", ".", "delay", "(", "2000", ")", ".", "fadeOut", "(", "\"slow\"", ")", ";", "}" ]

[ "Flash", "an", "error", "message", "briefly", "." ]

[ "function", "(", "object", ",", "otherterms", ")", "{", "var", "filenames", "=", "this", ".", "_index", ".", "filenames", ";", "var", "docnames", "=", "this", ".", "_index", ".", "docnames", ";", "var", "objects", "=", "this", ".", "_index", ".", "objects", ";", "var", "objnames", "=", "this", ".", "_index", ".", "objnames", ";", "var", "titles", "=", "this", ".", "_index", ".", "titles", ";", "var", "i", ";", "var", "results", "=", "[", "]", ";", "for", "(", "var", "prefix", "in", "objects", ")", "{", "for", "(", "var", "name", "in", "objects", "[", "prefix", "]", ")", "{", "var", "fullname", "=", "(", "prefix", "?", "prefix", "+", "'.'", ":", "''", ")", "+", "name", ";", "if", "(", "fullname", ".", "toLowerCase", "(", ")", ".", "indexOf", "(", "object", ")", ">", "-", "1", ")", "{", "var", "score", "=", "0", ";", "var", "parts", "=", "fullname", ".", "split", "(", "'.'", ")", ";", "if", "(", "fullname", "==", "object", "||", "parts", "[", "parts", ".", "length", "-", "1", "]", "==", "object", ")", "{", "score", "+=", "Scorer", ".", "objNameMatch", ";", "}", "else", "if", "(", "parts", "[", "parts", ".", "length", "-", "1", "]", ".", "indexOf", "(", "object", ")", ">", "-", "1", ")", "{", "score", "+=", "Scorer", ".", "objPartialMatch", ";", "}", "var", "match", "=", "objects", "[", "prefix", "]", "[", "name", "]", ";", "var", "objname", "=", "objnames", "[", "match", "[", "1", "]", "]", "[", "2", "]", ";", "var", "title", "=", "titles", "[", "match", "[", "0", "]", "]", ";", "if", "(", "otherterms", ".", "length", ">", "0", ")", "{", "var", "haystack", "=", "(", "prefix", "+", "' '", "+", "name", "+", "' '", "+", "objname", "+", "' '", "+", "title", ")", ".", "toLowerCase", "(", ")", ";", "var", "allfound", "=", "true", ";", "for", "(", "i", "=", "0", ";", "i", "<", "otherterms", ".", "length", ";", "i", "++", ")", "{", "if", "(", "haystack", ".", "indexOf", "(", "otherterms", "[", "i", "]", ")", "==", "-", "1", ")", "{", "allfound", "=", "false", ";", "break", ";", "}", "}", "if", "(", "!", "allfound", ")", "{", "continue", ";", "}", "}", "var", "descr", "=", "objname", "+", "_", "(", "', in '", ")", "+", "title", ";", "var", "anchor", "=", "match", "[", "3", "]", ";", "if", "(", "anchor", "===", "''", ")", "anchor", "=", "fullname", ";", "else", "if", "(", "anchor", "==", "'-'", ")", "anchor", "=", "objnames", "[", "match", "[", "1", "]", "]", "[", "1", "]", "+", "'-'", "+", "fullname", ";", "if", "(", "Scorer", ".", "objPrio", ".", "hasOwnProperty", "(", "match", "[", "2", "]", ")", ")", "{", "score", "+=", "Scorer", ".", "objPrio", "[", "match", "[", "2", "]", "]", ";", "}", "else", "{", "score", "+=", "Scorer", ".", "objPrioDefault", ";", "}", "results", ".", "push", "(", "[", "docnames", "[", "match", "[", "0", "]", "]", ",", "fullname", ",", "'#'", "+", "anchor", ",", "descr", ",", "score", ",", "filenames", "[", "match", "[", "0", "]", "]", "]", ")", ";", "}", "}", "}", "return", "results", ";", "}" ]

[ "search", "for", "object", "names" ]

[ "function", "(", "searchterms", ",", "excluded", ",", "terms", ",", "titleterms", ")", "{", "var", "docnames", "=", "this", ".", "_index", ".", "docnames", ";", "var", "filenames", "=", "this", ".", "_index", ".", "filenames", ";", "var", "titles", "=", "this", ".", "_index", ".", "titles", ";", "var", "i", ",", "j", ",", "file", ";", "var", "fileMap", "=", "{", "}", ";", "var", "scoreMap", "=", "{", "}", ";", "var", "results", "=", "[", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "searchterms", ".", "length", ";", "i", "++", ")", "{", "var", "word", "=", "searchterms", "[", "i", "]", ";", "var", "files", "=", "[", "]", ";", "var", "_o", "=", "[", "{", "files", ":", "terms", "[", "word", "]", ",", "score", ":", "Scorer", ".", "term", "}", ",", "{", "files", ":", "titleterms", "[", "word", "]", ",", "score", ":", "Scorer", ".", "title", "}", "]", ";", "if", "(", "$u", ".", "every", "(", "_o", ",", "function", "(", "o", ")", "{", "return", "o", ".", "files", "===", "undefined", ";", "}", ")", ")", "{", "break", ";", "}", "$u", ".", "each", "(", "_o", ",", "function", "(", "o", ")", "{", "var", "_files", "=", "o", ".", "files", ";", "if", "(", "_files", "===", "undefined", ")", "return", "if", "(", "_files", ".", "length", "===", "undefined", ")", "_files", "=", "[", "_files", "]", ";", "files", "=", "files", ".", "concat", "(", "_files", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "_files", ".", "length", ";", "j", "++", ")", "{", "file", "=", "_files", "[", "j", "]", ";", "if", "(", "!", "(", "file", "in", "scoreMap", ")", ")", "scoreMap", "[", "file", "]", "=", "{", "}", "scoreMap", "[", "file", "]", "[", "word", "]", "=", "o", ".", "score", ";", "}", "}", ")", ";", "for", "(", "j", "=", "0", ";", "j", "<", "files", ".", "length", ";", "j", "++", ")", "{", "file", "=", "files", "[", "j", "]", ";", "if", "(", "file", "in", "fileMap", ")", "fileMap", "[", "file", "]", ".", "push", "(", "word", ")", ";", "else", "fileMap", "[", "file", "]", "=", "[", "word", "]", ";", "}", "}", "for", "(", "file", "in", "fileMap", ")", "{", "var", "valid", "=", "true", ";", "if", "(", "fileMap", "[", "file", "]", ".", "length", "!=", "searchterms", ".", "length", ")", "continue", ";", "for", "(", "i", "=", "0", ";", "i", "<", "excluded", ".", "length", ";", "i", "++", ")", "{", "if", "(", "terms", "[", "excluded", "[", "i", "]", "]", "==", "file", "||", "titleterms", "[", "excluded", "[", "i", "]", "]", "==", "file", "||", "$u", ".", "contains", "(", "terms", "[", "excluded", "[", "i", "]", "]", "||", "[", "]", ",", "file", ")", "||", "$u", ".", "contains", "(", "titleterms", "[", "excluded", "[", "i", "]", "]", "||", "[", "]", ",", "file", ")", ")", "{", "valid", "=", "false", ";", "break", ";", "}", "}", "if", "(", "valid", ")", "{", "var", "score", "=", "$u", ".", "max", "(", "$u", ".", "map", "(", "fileMap", "[", "file", "]", ",", "function", "(", "w", ")", "{", "return", "scoreMap", "[", "file", "]", "[", "w", "]", "}", ")", ")", ";", "results", ".", "push", "(", "[", "docnames", "[", "file", "]", ",", "titles", "[", "file", "]", ",", "''", ",", "null", ",", "score", ",", "filenames", "[", "file", "]", "]", ")", ";", "}", "}", "return", "results", ";", "}" ]

[ "search", "for", "full", "-", "text", "terms", "in", "the", "index" ]

[ "function", "clean", "(", "args", ")", "{", "return", "Array", ".", "prototype", ".", "filter", ".", "call", "(", "args", ",", "v", "=>", "v", "!==", "INVALIDATE", ")", ";", "}" ]

[ "Return", "an", "array", "containing", "elements", "from", "supplied", "arguments", "object", "that", "are", "not", "control", "symbols", "." ]

[ "function", "json", "(", "program", ",", "callback", ")", "{", "var", "formatterRedux", "=", "formatter", "(", "jsonRedux", "(", ")", ")", "parse", "(", "program", ".", "stdin", ",", "program", ".", "stderr", ",", "printer", "(", "formatterRedux", ",", "program", ".", "stdout", ",", "program", ".", "stderr", ")", ",", "callback", ")", "}" ]

[ "Moved", "exports", ".", "json", "to", "its", "own", "file", "." ]

[ "function", "getPythonExecutable", "(", "options", ",", "platform", ")", "{", "if", "(", "options", ".", "virtualenv", ")", "{", "var", "isWin", "=", "/", "^win", "/", ".", "test", "(", "platform", ")", ";", "var", "pythonExec", "=", "isWin", "?", "path", ".", "join", "(", "options", ".", "virtualenv", ",", "'Scripts'", ",", "'python.exe'", ")", ":", "path", ".", "join", "(", "options", ".", "virtualenv", ",", "'bin'", ",", "'python'", ")", ";", "delete", "options", ".", "virtualenv", ";", "return", "pythonExec", ";", "}", "else", "{", "return", "'python'", ";", "}", "}" ]

[ "Get", "the", "path", "to", "the", "python", "executable", "using", "the", "options", ".", "virtualenv", "parameter", ".", "Will", "remove", "the", "virtualenv", "parameter", "from", "the", "options", "object", "if", "present" ]

[ "function", "getPythonCode", "(", "options", ")", "{", "var", "pythonCode", "=", "[", "]", ",", "internalPylint", "=", "!", "options", ".", "externalPylint", ",", "pylintPath", "=", "path", ".", "join", "(", "__dirname", ",", "'lib'", ")", ",", "initHook", "=", "options", ".", "initHook", ";", "delete", "options", ".", "initHook", ";", "if", "(", "initHook", ")", "{", "pythonCode", ".", "push", "(", "initHook", ")", ";", "}", "if", "(", "internalPylint", ")", "{", "pythonCode", ".", "push", "(", "'import sys'", ",", "'sys.path.insert(0, r\"'", "+", "pylintPath", "+", "'\")'", ")", ";", "}", "pythonCode", ".", "push", "(", "'import pylint'", ",", "'pylint.run_pylint()'", ")", ";", "delete", "options", ".", "externalPylint", ";", "return", "pythonCode", ".", "join", "(", "'; '", ")", ";", "}" ]

[ "Get", "the", "python", "code", "that", "will", "import", "and", "execute", "pylint", "Uses", "the", "options", ".", "externalPylint", "parameter", "to", "determine", "whether", "to", "use", "the", "pylint", "included", "with", "the", "plugin", "or", "an", "external", "one", ".", "externalPylint", "is", "deleted", "from", "the", "options", "object", "." ]

[ "function", "(", "options", ")", "{", "var", "pylintArgs", "=", "[", "]", ";", "var", "enable", "=", "options", ".", "enable", ";", "delete", "options", ".", "enable", ";", "if", "(", "enable", ")", "{", "pylintArgs", ".", "push", "(", "'--enable='", "+", "enable", ")", ";", "}", "var", "disable", "=", "options", ".", "disable", ";", "delete", "options", ".", "disable", ";", "if", "(", "disable", ")", "{", "pylintArgs", ".", "push", "(", "'--disable='", "+", "disable", ")", ";", "}", "var", "messageTemplate", "=", "options", ".", "messageTemplate", ";", "delete", "options", ".", "messageTemplate", ";", "if", "(", "messageTemplate", ")", "{", "var", "aliases", "=", "{", "'short'", ":", "\"line {line}: {msg} ({symbol})\"", ",", "'msvs'", ":", "\"{path}({line}): [{msg_id}({symbol}){obj}] {msg}\"", ",", "'parseable'", ":", "\"{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}\"", ",", "}", ";", "if", "(", "aliases", "[", "messageTemplate", "]", "!==", "undefined", ")", "{", "pylintArgs", ".", "push", "(", "'--msg-template=\"'", "+", "aliases", "[", "messageTemplate", "]", "+", "'\"'", ")", ";", "}", "else", "{", "pylintArgs", ".", "push", "(", "'--msg-template=\"'", "+", "messageTemplate", "+", "'\"'", ")", ";", "}", "}", "var", "outputFormat", "=", "options", ".", "outputFormat", ";", "delete", "options", ".", "outputFormat", ";", "if", "(", "outputFormat", ")", "{", "pylintArgs", ".", "push", "(", "'--output-format='", "+", "outputFormat", ")", ";", "}", "var", "report", "=", "options", ".", "report", ";", "delete", "options", ".", "report", ";", "if", "(", "options", ".", "reports", ")", "{", "report", "=", "options", ".", "reports", ";", "delete", "options", ".", "reports", ";", "}", "if", "(", "report", ")", "{", "pylintArgs", ".", "push", "(", "'--reports=y'", ")", ";", "}", "else", "{", "pylintArgs", ".", "push", "(", "'--reports=n'", ")", ";", "}", "var", "rcfile", "=", "options", ".", "rcfile", ";", "delete", "options", ".", "rcfile", ";", "if", "(", "rcfile", ")", "{", "pylintArgs", ".", "push", "(", "'--rcfile='", "+", "rcfile", ")", ";", "}", "var", "score", "=", "options", ".", "score", ";", "delete", "options", ".", "score", ";", "if", "(", "score", ")", "{", "pylintArgs", ".", "push", "(", "'--score=y'", ")", ";", "}", "else", "{", "pylintArgs", ".", "push", "(", "'--score=n'", ")", ";", "}", "var", "errorsOnly", "=", "options", ".", "errorsOnly", ";", "delete", "options", ".", "errorsOnly", ";", "if", "(", "errorsOnly", ")", "{", "pylintArgs", ".", "push", "(", "'--errors-only'", ")", ";", "}", "var", "ignore", "=", "options", ".", "ignore", ";", "delete", "options", ".", "ignore", ";", "if", "(", "ignore", ")", "{", "pylintArgs", ".", "push", "(", "'--ignore='", "+", "ignore", ")", ";", "}", "for", "(", "var", "prop", "in", "options", ")", "{", "if", "(", "options", ".", "hasOwnProperty", "(", "prop", ")", ")", "{", "grunt", ".", "fail", ".", "warn", "(", "\"Unknown option to pylint: '\"", "+", "prop", "+", "\"'\"", ")", ";", "}", "}", "return", "pylintArgs", ";", "}" ]

[ "Build", "the", "argument", "list", "sent", "to", "pylint", "from", "the", "options", "object" ]

[ "function", "normalizeDistance", "(", "distance", "=", "0", ")", "{", "if", "(", "typeof", "distance", "!==", "'object'", ")", "distance", "=", "{", "top", ":", "distance", ",", "left", ":", "distance", ",", "right", ":", "distance", ",", "bottom", ":", "distance", "}", ";", "return", "distance", ";", "}" ]

[ "Resolve", "the", "disance", "prop", "from", "either", "an", "Int", "or", "an", "Object" ]

[ "function", "mark", "(", "markName", ")", "{", "if", "(", "enabled", ")", "{", "marks", "[", "markName", "]", "=", "ts", ".", "timestamp", "(", ")", ";", "counts", "[", "markName", "]", "=", "(", "counts", "[", "markName", "]", "||", "0", ")", "+", "1", ";", "profilerEvent", "(", "markName", ")", ";", "}", "}" ]

[ "Marks", "a", "performance", "event", "." ]

[ "function", "measure", "(", "measureName", ",", "startMarkName", ",", "endMarkName", ")", "{", "if", "(", "enabled", ")", "{", "var", "end", "=", "endMarkName", "&&", "marks", "[", "endMarkName", "]", "||", "ts", ".", "timestamp", "(", ")", ";", "var", "start", "=", "startMarkName", "&&", "marks", "[", "startMarkName", "]", "||", "profilerStart", ";", "measures", "[", "measureName", "]", "=", "(", "measures", "[", "measureName", "]", "||", "0", ")", "+", "(", "end", "-", "start", ")", ";", "}", "}" ]

[ "Adds", "a", "performance", "measurement", "with", "the", "specified", "name", "." ]

[ "function", "find", "(", "array", ",", "predicate", ")", "{", "for", "(", "var", "i", "=", "0", ",", "len", "=", "array", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "var", "value", "=", "array", "[", "i", "]", ";", "if", "(", "predicate", "(", "value", ",", "i", ")", ")", "{", "return", "value", ";", "}", "}", "return", "undefined", ";", "}" ]

[ "Works", "like", "Array", ".", "prototype", ".", "find", "returning", "undefined", "if", "no", "element", "satisfying", "the", "predicate", "is", "found", "." ]

[ "function", "findMap", "(", "array", ",", "callback", ")", "{", "for", "(", "var", "i", "=", "0", ",", "len", "=", "array", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "var", "result", "=", "callback", "(", "array", "[", "i", "]", ",", "i", ")", ";", "if", "(", "result", ")", "{", "return", "result", ";", "}", "}", "Debug", ".", "fail", "(", ")", ";", "}" ]

[ "Returns", "the", "first", "truthy", "result", "of", "callback", "or", "else", "fails", ".", "This", "is", "like", "forEach", "but", "never", "returns", "undefined", "." ]

[ "function", "filter", "(", "array", ",", "f", ")", "{", "if", "(", "array", ")", "{", "var", "len", "=", "array", ".", "length", ";", "var", "i", "=", "0", ";", "while", "(", "i", "<", "len", "&&", "f", "(", "array", "[", "i", "]", ")", ")", "i", "++", ";", "if", "(", "i", "<", "len", ")", "{", "var", "result", "=", "array", ".", "slice", "(", "0", ",", "i", ")", ";", "i", "++", ";", "while", "(", "i", "<", "len", ")", "{", "var", "item", "=", "array", "[", "i", "]", ";", "if", "(", "f", "(", "item", ")", ")", "{", "result", ".", "push", "(", "item", ")", ";", "}", "i", "++", ";", "}", "return", "result", ";", "}", "}", "return", "array", ";", "}" ]

[ "Filters", "an", "array", "by", "a", "predicate", "function", ".", "Returns", "the", "same", "array", "instance", "if", "the", "predicate", "is", "true", "for", "all", "elements", "otherwise", "returns", "a", "new", "array", "instance", "containing", "the", "filtered", "subset", "." ]

[ "function", "getOwnKeys", "(", "map", ")", "{", "var", "keys", "=", "[", "]", ";", "for", "(", "var", "key", "in", "map", ")", "if", "(", "hasOwnProperty", ".", "call", "(", "map", ",", "key", ")", ")", "{", "keys", ".", "push", "(", "key", ")", ";", "}", "return", "keys", ";", "}" ]

[ "Gets", "the", "owned", "enumerable", "property", "keys", "of", "a", "map", "-", "like", "." ]

[ "function", "reduceProperties", "(", "map", ",", "callback", ",", "initial", ")", "{", "var", "result", "=", "initial", ";", "for", "(", "var", "key", "in", "map", ")", "{", "result", "=", "callback", "(", "result", ",", "map", "[", "key", "]", ",", "String", "(", "key", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Reduce", "the", "properties", "of", "a", "map", "." ]

[ "function", "equalOwnProperties", "(", "left", ",", "right", ",", "equalityComparer", ")", "{", "if", "(", "left", "===", "right", ")", "return", "true", ";", "if", "(", "!", "left", "||", "!", "right", ")", "return", "false", ";", "for", "(", "var", "key", "in", "left", ")", "if", "(", "hasOwnProperty", ".", "call", "(", "left", ",", "key", ")", ")", "{", "if", "(", "!", "hasOwnProperty", ".", "call", "(", "right", ",", "key", ")", "===", "undefined", ")", "return", "false", ";", "if", "(", "equalityComparer", "?", "!", "equalityComparer", "(", "left", "[", "key", "]", ",", "right", "[", "key", "]", ")", ":", "left", "[", "key", "]", "!==", "right", "[", "key", "]", ")", "return", "false", ";", "}", "for", "(", "var", "key", "in", "right", ")", "if", "(", "hasOwnProperty", ".", "call", "(", "right", ",", "key", ")", ")", "{", "if", "(", "!", "hasOwnProperty", ".", "call", "(", "left", ",", "key", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Performs", "a", "shallow", "equality", "comparison", "of", "the", "contents", "of", "two", "map", "-", "likes", "." ]

[ "function", "removeTrailingDirectorySeparator", "(", "path", ")", "{", "if", "(", "path", ".", "charAt", "(", "path", ".", "length", "-", "1", ")", "===", "ts", ".", "directorySeparator", ")", "{", "return", "path", ".", "substr", "(", "0", ",", "path", ".", "length", "-", "1", ")", ";", "}", "return", "path", ";", "}" ]

[ "Removes", "a", "trailing", "directory", "separator", "from", "a", "path", "." ]

[ "function", "ensureTrailingDirectorySeparator", "(", "path", ")", "{", "if", "(", "path", ".", "charAt", "(", "path", ".", "length", "-", "1", ")", "!==", "ts", ".", "directorySeparator", ")", "{", "return", "path", "+", "ts", ".", "directorySeparator", ";", "}", "return", "path", ";", "}" ]

[ "Adds", "a", "trailing", "directory", "separator", "to", "a", "path", "if", "it", "does", "not", "already", "have", "one", "." ]

[ "function", "getBasePaths", "(", "path", ",", "includes", ",", "useCaseSensitiveFileNames", ")", "{", "var", "basePaths", "=", "[", "path", "]", ";", "if", "(", "includes", ")", "{", "var", "includeBasePaths", "=", "[", "]", ";", "for", "(", "var", "_i", "=", "0", ",", "includes_1", "=", "includes", ";", "_i", "<", "includes_1", ".", "length", ";", "_i", "++", ")", "{", "var", "include", "=", "includes_1", "[", "_i", "]", ";", "var", "absolute", "=", "isRootedDiskPath", "(", "include", ")", "?", "include", ":", "normalizePath", "(", "combinePaths", "(", "path", ",", "include", ")", ")", ";", "var", "wildcardOffset", "=", "indexOfAnyCharCode", "(", "absolute", ",", "wildcardCharCodes", ")", ";", "var", "includeBasePath", "=", "wildcardOffset", "<", "0", "?", "removeTrailingDirectorySeparator", "(", "getDirectoryPath", "(", "absolute", ")", ")", ":", "absolute", ".", "substring", "(", "0", ",", "absolute", ".", "lastIndexOf", "(", "ts", ".", "directorySeparator", ",", "wildcardOffset", ")", ")", ";", "includeBasePaths", ".", "push", "(", "includeBasePath", ")", ";", "}", "includeBasePaths", ".", "sort", "(", "useCaseSensitiveFileNames", "?", "compareStrings", ":", "compareStringsCaseInsensitive", ")", ";", "include", ":", "for", "(", "var", "i", "=", "0", ";", "i", "<", "includeBasePaths", ".", "length", ";", "i", "++", ")", "{", "var", "includeBasePath", "=", "includeBasePaths", "[", "i", "]", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "basePaths", ".", "length", ";", "j", "++", ")", "{", "if", "(", "containsPath", "(", "basePaths", "[", "j", "]", ",", "includeBasePath", ",", "path", ",", "!", "useCaseSensitiveFileNames", ")", ")", "{", "continue", "include", ";", "}", "}", "basePaths", ".", "push", "(", "includeBasePath", ")", ";", "}", "}", "return", "basePaths", ";", "}" ]

[ "Computes", "the", "unique", "non", "-", "wildcard", "base", "paths", "amongst", "the", "provided", "include", "patterns", "." ]

[ "function", "isWhiteSpaceSingleLine", "(", "ch", ")", "{", "return", "ch", "===", "32", "||", "ch", "===", "9", "||", "ch", "===", "11", "||", "ch", "===", "12", "||", "ch", "===", "160", "||", "ch", "===", "133", "||", "ch", "===", "5760", "||", "ch", ">=", "8192", "&&", "ch", "<=", "8203", "||", "ch", "===", "8239", "||", "ch", "===", "8287", "||", "ch", "===", "12288", "||", "ch", "===", "65279", ";", "}" ]

[ "Does", "not", "include", "line", "breaks", ".", "For", "that", "see", "isWhiteSpaceLike", "." ]

[ "function", "isRequireCall", "(", "expression", ",", "checkArgumentIsStringLiteral", ")", "{", "var", "isRequire", "=", "expression", ".", "kind", "===", "174", "&&", "expression", ".", "expression", ".", "kind", "===", "69", "&&", "expression", ".", "expression", ".", "text", "===", "\"require\"", "&&", "expression", ".", "arguments", ".", "length", "===", "1", ";", "return", "isRequire", "&&", "(", "!", "checkArgumentIsStringLiteral", "||", "expression", ".", "arguments", "[", "0", "]", ".", "kind", "===", "9", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "node", "is", "a", "CallExpression", "to", "the", "identifier", "require", "with", "exactly", "one", "argument", ".", "This", "function", "does", "not", "test", "if", "the", "node", "is", "in", "a", "JavaScript", "file", "or", "not", "." ]

[ "function", "isDeclarationOfFunctionExpression", "(", "s", ")", "{", "if", "(", "s", ".", "valueDeclaration", "&&", "s", ".", "valueDeclaration", ".", "kind", "===", "218", ")", "{", "var", "declaration", "=", "s", ".", "valueDeclaration", ";", "return", "declaration", ".", "initializer", "&&", "declaration", ".", "initializer", ".", "kind", "===", "179", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "node", "is", "a", "variable", "declaration", "whose", "initializer", "is", "a", "function", "expression", ".", "This", "function", "does", "not", "test", "if", "the", "node", "is", "in", "a", "JavaScript", "file", "or", "not", "." ]

[ "function", "cloneNode", "(", "node", ",", "location", ",", "flags", ",", "parent", ")", "{", "var", "clone", "=", "location", "!==", "undefined", "?", "ts", ".", "createNode", "(", "node", ".", "kind", ",", "location", ".", "pos", ",", "location", ".", "end", ")", ":", "createSynthesizedNode", "(", "node", ".", "kind", ")", ";", "for", "(", "var", "key", "in", "node", ")", "{", "if", "(", "clone", ".", "hasOwnProperty", "(", "key", ")", "||", "!", "node", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "continue", ";", "}", "clone", "[", "key", "]", "=", "node", "[", "key", "]", ";", "}", "if", "(", "flags", "!==", "undefined", ")", "{", "clone", ".", "flags", "=", "flags", ";", "}", "if", "(", "parent", "!==", "undefined", ")", "{", "clone", ".", "parent", "=", "parent", ";", "}", "return", "clone", ";", "}" ]

[ "Creates", "a", "shallow", "memberwise", "clone", "of", "a", "node", ".", "The", "kind", "pos", "end", "flags", "and", "parent", "properties", "are", "excluded", "by", "default", "and", "can", "be", "provided", "via", "the", "location", "flags", "and", "parent", "parameters", "." ]

[ "function", "cloneEntityName", "(", "node", ",", "parent", ")", "{", "var", "clone", "=", "cloneNode", "(", "node", ",", "node", ",", "node", ".", "flags", ",", "parent", ")", ";", "if", "(", "isQualifiedName", "(", "clone", ")", ")", "{", "var", "left", "=", "clone", ".", "left", ",", "right", "=", "clone", ".", "right", ";", "clone", ".", "left", "=", "cloneEntityName", "(", "left", ",", "clone", ")", ";", "clone", ".", "right", "=", "cloneNode", "(", "right", ",", "right", ",", "right", ".", "flags", ",", "parent", ")", ";", "}", "return", "clone", ";", "}" ]

[ "Creates", "a", "deep", "clone", "of", "an", "EntityName", "with", "new", "parent", "pointers", "." ]

[ "function", "getExternalModuleNameFromPath", "(", "host", ",", "fileName", ")", "{", "var", "getCanonicalFileName", "=", "function", "(", "f", ")", "{", "return", "host", ".", "getCanonicalFileName", "(", "f", ")", ";", "}", ";", "var", "dir", "=", "ts", ".", "toPath", "(", "host", ".", "getCommonSourceDirectory", "(", ")", ",", "host", ".", "getCurrentDirectory", "(", ")", ",", "getCanonicalFileName", ")", ";", "var", "filePath", "=", "ts", ".", "getNormalizedAbsolutePath", "(", "fileName", ",", "host", ".", "getCurrentDirectory", "(", ")", ")", ";", "var", "relativePath", "=", "ts", ".", "getRelativePathToDirectoryOrUrl", "(", "dir", ",", "filePath", ",", "dir", ",", "getCanonicalFileName", ",", "false", ")", ";", "return", "ts", ".", "removeFileExtension", "(", "relativePath", ")", ";", "}" ]

[ "Resolves", "a", "local", "path", "to", "a", "path", "which", "is", "absolute", "to", "the", "base", "of", "the", "emit" ]

[ "function", "emitDetachedComments", "(", "text", ",", "lineMap", ",", "writer", ",", "writeComment", ",", "node", ",", "newLine", ",", "removeComments", ")", "{", "var", "leadingComments", ";", "var", "currentDetachedCommentInfo", ";", "if", "(", "removeComments", ")", "{", "if", "(", "node", ".", "pos", "===", "0", ")", "{", "leadingComments", "=", "ts", ".", "filter", "(", "ts", ".", "getLeadingCommentRanges", "(", "text", ",", "node", ".", "pos", ")", ",", "isPinnedComment", ")", ";", "}", "}", "else", "{", "leadingComments", "=", "ts", ".", "getLeadingCommentRanges", "(", "text", ",", "node", ".", "pos", ")", ";", "}", "if", "(", "leadingComments", ")", "{", "var", "detachedComments", "=", "[", "]", ";", "var", "lastComment", "=", "void", "0", ";", "for", "(", "var", "_i", "=", "0", ",", "leadingComments_1", "=", "leadingComments", ";", "_i", "<", "leadingComments_1", ".", "length", ";", "_i", "++", ")", "{", "var", "comment", "=", "leadingComments_1", "[", "_i", "]", ";", "if", "(", "lastComment", ")", "{", "var", "lastCommentLine", "=", "getLineOfLocalPositionFromLineMap", "(", "lineMap", ",", "lastComment", ".", "end", ")", ";", "var", "commentLine", "=", "getLineOfLocalPositionFromLineMap", "(", "lineMap", ",", "comment", ".", "pos", ")", ";", "if", "(", "commentLine", ">=", "lastCommentLine", "+", "2", ")", "{", "break", ";", "}", "}", "detachedComments", ".", "push", "(", "comment", ")", ";", "lastComment", "=", "comment", ";", "}", "if", "(", "detachedComments", ".", "length", ")", "{", "var", "lastCommentLine", "=", "getLineOfLocalPositionFromLineMap", "(", "lineMap", ",", "ts", ".", "lastOrUndefined", "(", "detachedComments", ")", ".", "end", ")", ";", "var", "nodeLine", "=", "getLineOfLocalPositionFromLineMap", "(", "lineMap", ",", "ts", ".", "skipTrivia", "(", "text", ",", "node", ".", "pos", ")", ")", ";", "if", "(", "nodeLine", ">=", "lastCommentLine", "+", "2", ")", "{", "emitNewLineBeforeLeadingComments", "(", "lineMap", ",", "writer", ",", "node", ",", "leadingComments", ")", ";", "emitComments", "(", "text", ",", "lineMap", ",", "writer", ",", "detachedComments", ",", "true", ",", "newLine", ",", "writeComment", ")", ";", "currentDetachedCommentInfo", "=", "{", "nodePos", ":", "node", ".", "pos", ",", "detachedCommentEndPos", ":", "ts", ".", "lastOrUndefined", "(", "detachedComments", ")", ".", "end", "}", ";", "}", "}", "}", "return", "currentDetachedCommentInfo", ";", "function", "isPinnedComment", "(", "comment", ")", "{", "return", "text", ".", "charCodeAt", "(", "comment", ".", "pos", "+", "1", ")", "===", "42", "&&", "text", ".", "charCodeAt", "(", "comment", ".", "pos", "+", "2", ")", "===", "33", ";", "}", "}" ]

[ "Detached", "comment", "is", "a", "comment", "at", "the", "top", "of", "file", "or", "function", "body", "that", "is", "separated", "from", "the", "next", "statement", "by", "space", "." ]

[ "function", "tryExtractTypeScriptExtension", "(", "fileName", ")", "{", "return", "ts", ".", "find", "(", "ts", ".", "supportedTypescriptExtensionsForExtractExtension", ",", "function", "(", "extension", ")", "{", "return", "ts", ".", "fileExtensionIs", "(", "fileName", ",", "extension", ")", ";", "}", ")", ";", "}" ]

[ "Return", ".", "ts", ".", "d", ".", "ts", "or", ".", "tsx", "if", "that", "is", "the", "extension", "." ]

[ "function", "convertToBase64", "(", "input", ")", "{", "var", "result", "=", "\"\"", ";", "var", "charCodes", "=", "getExpandedCharCodes", "(", "input", ")", ";", "var", "i", "=", "0", ";", "var", "length", "=", "charCodes", ".", "length", ";", "var", "byte1", ",", "byte2", ",", "byte3", ",", "byte4", ";", "while", "(", "i", "<", "length", ")", "{", "byte1", "=", "charCodes", "[", "i", "]", ">>", "2", ";", "byte2", "=", "(", "charCodes", "[", "i", "]", "&", "3", ")", "<<", "4", "|", "charCodes", "[", "i", "+", "1", "]", ">>", "4", ";", "byte3", "=", "(", "charCodes", "[", "i", "+", "1", "]", "&", "15", ")", "<<", "2", "|", "charCodes", "[", "i", "+", "2", "]", ">>", "6", ";", "byte4", "=", "charCodes", "[", "i", "+", "2", "]", "&", "63", ";", "if", "(", "i", "+", "1", ">=", "length", ")", "{", "byte3", "=", "byte4", "=", "64", ";", "}", "else", "if", "(", "i", "+", "2", ">=", "length", ")", "{", "byte4", "=", "64", ";", "}", "result", "+=", "base64Digits", ".", "charAt", "(", "byte1", ")", "+", "base64Digits", ".", "charAt", "(", "byte2", ")", "+", "base64Digits", ".", "charAt", "(", "byte3", ")", "+", "base64Digits", ".", "charAt", "(", "byte4", ")", ";", "i", "+=", "3", ";", "}", "return", "result", ";", "}" ]

[ "Converts", "a", "string", "to", "a", "base", "-", "64", "encoded", "ASCII", "string", "." ]

[ "function", "collapseTextChangeRangesAcrossMultipleVersions", "(", "changes", ")", "{", "if", "(", "changes", ".", "length", "===", "0", ")", "{", "return", "ts", ".", "unchangedTextChangeRange", ";", "}", "if", "(", "changes", ".", "length", "===", "1", ")", "{", "return", "changes", "[", "0", "]", ";", "}", "var", "change0", "=", "changes", "[", "0", "]", ";", "var", "oldStartN", "=", "change0", ".", "span", ".", "start", ";", "var", "oldEndN", "=", "textSpanEnd", "(", "change0", ".", "span", ")", ";", "var", "newEndN", "=", "oldStartN", "+", "change0", ".", "newLength", ";", "for", "(", "var", "i", "=", "1", ";", "i", "<", "changes", ".", "length", ";", "i", "++", ")", "{", "var", "nextChange", "=", "changes", "[", "i", "]", ";", "var", "oldStart1", "=", "oldStartN", ";", "var", "oldEnd1", "=", "oldEndN", ";", "var", "newEnd1", "=", "newEndN", ";", "var", "oldStart2", "=", "nextChange", ".", "span", ".", "start", ";", "var", "oldEnd2", "=", "textSpanEnd", "(", "nextChange", ".", "span", ")", ";", "var", "newEnd2", "=", "oldStart2", "+", "nextChange", ".", "newLength", ";", "oldStartN", "=", "Math", ".", "min", "(", "oldStart1", ",", "oldStart2", ")", ";", "oldEndN", "=", "Math", ".", "max", "(", "oldEnd1", ",", "oldEnd1", "+", "(", "oldEnd2", "-", "newEnd1", ")", ")", ";", "newEndN", "=", "Math", ".", "max", "(", "newEnd2", ",", "newEnd2", "+", "(", "newEnd1", "-", "oldEnd2", ")", ")", ";", "}", "return", "createTextChangeRange", "(", "createTextSpanFromBounds", "(", "oldStartN", ",", "oldEndN", ")", ",", "newEndN", "-", "oldStartN", ")", ";", "}" ]

[ "Called", "to", "merge", "all", "the", "changes", "that", "occurred", "across", "several", "versions", "of", "a", "script", "snapshot", "into", "a", "single", "change", ".", "i", ".", "e", ".", "if", "a", "user", "keeps", "making", "successive", "edits", "to", "a", "script", "we", "will", "have", "a", "text", "change", "from", "V1", "to", "V2", "V2", "to", "V3", "...", "Vn", "." ]

[ "function", "isIdentifier", "(", ")", "{", "if", "(", "token", "(", ")", "===", "69", ")", "{", "return", "true", ";", "}", "if", "(", "token", "(", ")", "===", "114", "&&", "inYieldContext", "(", ")", ")", "{", "return", "false", ";", "}", "if", "(", "token", "(", ")", "===", "119", "&&", "inAwaitContext", "(", ")", ")", "{", "return", "false", ";", "}", "return", "token", "(", ")", ">", "105", ";", "}" ]

[ "Ignore", "strict", "mode", "flag", "because", "we", "will", "report", "an", "error", "in", "type", "checker", "instead", "." ]

[ "function", "isListElement", "(", "parsingContext", ",", "inErrorRecovery", ")", "{", "var", "node", "=", "currentNode", "(", "parsingContext", ")", ";", "if", "(", "node", ")", "{", "return", "true", ";", "}", "switch", "(", "parsingContext", ")", "{", "case", "0", ":", "case", "1", ":", "case", "3", ":", "return", "!", "(", "token", "(", ")", "===", "23", "&&", "inErrorRecovery", ")", "&&", "isStartOfStatement", "(", ")", ";", "case", "2", ":", "return", "token", "(", ")", "===", "71", "||", "token", "(", ")", "===", "77", ";", "case", "4", ":", "return", "lookAhead", "(", "isTypeMemberStart", ")", ";", "case", "5", ":", "return", "lookAhead", "(", "isClassMemberStart", ")", "||", "(", "token", "(", ")", "===", "23", "&&", "!", "inErrorRecovery", ")", ";", "case", "6", ":", "return", "token", "(", ")", "===", "19", "||", "isLiteralPropertyName", "(", ")", ";", "case", "12", ":", "return", "token", "(", ")", "===", "19", "||", "token", "(", ")", "===", "37", "||", "isLiteralPropertyName", "(", ")", ";", "case", "9", ":", "return", "token", "(", ")", "===", "19", "||", "isLiteralPropertyName", "(", ")", ";", "case", "7", ":", "if", "(", "token", "(", ")", "===", "15", ")", "{", "return", "lookAhead", "(", "isValidHeritageClauseObjectLiteral", ")", ";", "}", "if", "(", "!", "inErrorRecovery", ")", "{", "return", "isStartOfLeftHandSideExpression", "(", ")", "&&", "!", "isHeritageClauseExtendsOrImplementsKeyword", "(", ")", ";", "}", "else", "{", "return", "isIdentifier", "(", ")", "&&", "!", "isHeritageClauseExtendsOrImplementsKeyword", "(", ")", ";", "}", "case", "8", ":", "return", "isIdentifierOrPattern", "(", ")", ";", "case", "10", ":", "return", "token", "(", ")", "===", "24", "||", "token", "(", ")", "===", "22", "||", "isIdentifierOrPattern", "(", ")", ";", "case", "17", ":", "return", "isIdentifier", "(", ")", ";", "case", "11", ":", "case", "15", ":", "return", "token", "(", ")", "===", "24", "||", "token", "(", ")", "===", "22", "||", "isStartOfExpression", "(", ")", ";", "case", "16", ":", "return", "isStartOfParameter", "(", ")", ";", "case", "18", ":", "case", "19", ":", "return", "token", "(", ")", "===", "24", "||", "isStartOfType", "(", ")", ";", "case", "20", ":", "return", "isHeritageClause", "(", ")", ";", "case", "21", ":", "return", "ts", ".", "tokenIsIdentifierOrKeyword", "(", "token", "(", ")", ")", ";", "case", "13", ":", "return", "ts", ".", "tokenIsIdentifierOrKeyword", "(", "token", "(", ")", ")", "||", "token", "(", ")", "===", "15", ";", "case", "14", ":", "return", "true", ";", "case", "22", ":", "case", "23", ":", "case", "25", ":", "return", "JSDocParser", ".", "isJSDocType", "(", ")", ";", "case", "24", ":", "return", "isSimplePropertyName", "(", ")", ";", "}", "ts", ".", "Debug", ".", "fail", "(", "\"Non-exhaustive case in 'isListElement'.\"", ")", ";", "}" ]

[ "True", "if", "positioned", "at", "the", "start", "of", "a", "list", "element" ]

[ "function", "isInSomeParsingContext", "(", ")", "{", "for", "(", "var", "kind", "=", "0", ";", "kind", "<", "26", ";", "kind", "++", ")", "{", "if", "(", "parsingContext", "&", "(", "1", "<<", "kind", ")", ")", "{", "if", "(", "isListElement", "(", "kind", ",", "true", ")", "||", "isListTerminator", "(", "kind", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]

[ "True", "if", "positioned", "at", "element", "or", "terminator", "of", "the", "current", "list", "or", "any", "enclosing", "list" ]

[ "function", "parseList", "(", "kind", ",", "parseElement", ")", "{", "var", "saveParsingContext", "=", "parsingContext", ";", "parsingContext", "|=", "1", "<<", "kind", ";", "var", "result", "=", "[", "]", ";", "result", ".", "pos", "=", "getNodePos", "(", ")", ";", "while", "(", "!", "isListTerminator", "(", "kind", ")", ")", "{", "if", "(", "isListElement", "(", "kind", ",", "false", ")", ")", "{", "var", "element", "=", "parseListElement", "(", "kind", ",", "parseElement", ")", ";", "result", ".", "push", "(", "element", ")", ";", "continue", ";", "}", "if", "(", "abortParsingListOrMoveToNextToken", "(", "kind", ")", ")", "{", "break", ";", "}", "}", "result", ".", "end", "=", "getNodeEnd", "(", ")", ";", "parsingContext", "=", "saveParsingContext", ";", "return", "result", ";", "}" ]

[ "Parses", "a", "list", "of", "elements" ]

[ "function", "parseDelimitedList", "(", "kind", ",", "parseElement", ",", "considerSemicolonAsDelimiter", ")", "{", "var", "saveParsingContext", "=", "parsingContext", ";", "parsingContext", "|=", "1", "<<", "kind", ";", "var", "result", "=", "[", "]", ";", "result", ".", "pos", "=", "getNodePos", "(", ")", ";", "var", "commaStart", "=", "-", "1", ";", "while", "(", "true", ")", "{", "if", "(", "isListElement", "(", "kind", ",", "false", ")", ")", "{", "result", ".", "push", "(", "parseListElement", "(", "kind", ",", "parseElement", ")", ")", ";", "commaStart", "=", "scanner", ".", "getTokenPos", "(", ")", ";", "if", "(", "parseOptional", "(", "24", ")", ")", "{", "continue", ";", "}", "commaStart", "=", "-", "1", ";", "if", "(", "isListTerminator", "(", "kind", ")", ")", "{", "break", ";", "}", "parseExpected", "(", "24", ")", ";", "if", "(", "considerSemicolonAsDelimiter", "&&", "token", "(", ")", "===", "23", "&&", "!", "scanner", ".", "hasPrecedingLineBreak", "(", ")", ")", "{", "nextToken", "(", ")", ";", "}", "continue", ";", "}", "if", "(", "isListTerminator", "(", "kind", ")", ")", "{", "break", ";", "}", "if", "(", "abortParsingListOrMoveToNextToken", "(", "kind", ")", ")", "{", "break", ";", "}", "}", "if", "(", "commaStart", ">=", "0", ")", "{", "result", ".", "hasTrailingComma", "=", "true", ";", "}", "result", ".", "end", "=", "getNodeEnd", "(", ")", ";", "parsingContext", "=", "saveParsingContext", ";", "return", "result", ";", "}" ]

[ "Parses", "a", "comma", "-", "delimited", "list", "of", "elements" ]

[ "function", "parseUnaryExpressionOrHigher", "(", ")", "{", "if", "(", "isUpdateExpression", "(", ")", ")", "{", "var", "incrementExpression", "=", "parseIncrementExpression", "(", ")", ";", "return", "token", "(", ")", "===", "38", "?", "parseBinaryExpressionRest", "(", "getBinaryOperatorPrecedence", "(", ")", ",", "incrementExpression", ")", ":", "incrementExpression", ";", "}", "var", "unaryOperator", "=", "token", "(", ")", ";", "var", "simpleUnaryExpression", "=", "parseSimpleUnaryExpression", "(", ")", ";", "if", "(", "token", "(", ")", "===", "38", ")", "{", "var", "start", "=", "ts", ".", "skipTrivia", "(", "sourceText", ",", "simpleUnaryExpression", ".", "pos", ")", ";", "if", "(", "simpleUnaryExpression", ".", "kind", "===", "177", ")", "{", "parseErrorAtPosition", "(", "start", ",", "simpleUnaryExpression", ".", "end", "-", "start", ",", "ts", ".", "Diagnostics", ".", "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses", ")", ";", "}", "else", "{", "parseErrorAtPosition", "(", "start", ",", "simpleUnaryExpression", ".", "end", "-", "start", ",", "ts", ".", "Diagnostics", ".", "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses", ",", "ts", ".", "tokenToString", "(", "unaryOperator", ")", ")", ";", "}", "}", "return", "simpleUnaryExpression", ";", "}" ]

[ "Parse", "ES7", "exponential", "expression", "and", "await", "expression" ]

[ "function", "parseIncrementExpression", "(", ")", "{", "if", "(", "token", "(", ")", "===", "41", "||", "token", "(", ")", "===", "42", ")", "{", "var", "node", "=", "createNode", "(", "185", ")", ";", "node", ".", "operator", "=", "token", "(", ")", ";", "nextToken", "(", ")", ";", "node", ".", "operand", "=", "parseLeftHandSideExpressionOrHigher", "(", ")", ";", "return", "finishNode", "(", "node", ")", ";", "}", "else", "if", "(", "sourceFile", ".", "languageVariant", "===", "1", "&&", "token", "(", ")", "===", "25", "&&", "lookAhead", "(", "nextTokenIsIdentifierOrKeyword", ")", ")", "{", "return", "parseJsxElementOrSelfClosingElement", "(", "true", ")", ";", "}", "var", "expression", "=", "parseLeftHandSideExpressionOrHigher", "(", ")", ";", "ts", ".", "Debug", ".", "assert", "(", "ts", ".", "isLeftHandSideExpression", "(", "expression", ")", ")", ";", "if", "(", "(", "token", "(", ")", "===", "41", "||", "token", "(", ")", "===", "42", ")", "&&", "!", "scanner", ".", "hasPrecedingLineBreak", "(", ")", ")", "{", "var", "node", "=", "createNode", "(", "186", ",", "expression", ".", "pos", ")", ";", "node", ".", "operand", "=", "expression", ";", "node", ".", "operator", "=", "token", "(", ")", ";", "nextToken", "(", ")", ";", "return", "finishNode", "(", "node", ")", ";", "}", "return", "expression", ";", "}" ]

[ "Parse", "ES7", "IncrementExpression", ".", "IncrementExpression", "is", "used", "instead", "of", "ES6", "s", "PostFixExpression", "." ]

[ "function", "parseEnumMember", "(", ")", "{", "var", "node", "=", "createNode", "(", "255", ",", "scanner", ".", "getStartPos", "(", ")", ")", ";", "node", ".", "name", "=", "parsePropertyName", "(", ")", ";", "node", ".", "initializer", "=", "allowInAnd", "(", "parseNonParameterInitializer", ")", ";", "return", "finishNode", "(", "node", ")", ";", "}" ]

[ "In", "an", "ambient", "declaration", "the", "grammar", "only", "allows", "integer", "literals", "as", "initializers", ".", "In", "a", "non", "-", "ambient", "declaration", "the", "grammar", "allows", "uninitialized", "members", "only", "in", "a", "ConstantEnumMemberSection", "which", "starts", "at", "the", "beginning", "of", "an", "enum", "declaration", "or", "any", "time", "an", "integer", "literal", "initializer", "is", "encountered", "." ]

[ "function", "tryFile", "(", "fileName", ",", "failedLookupLocation", ",", "onlyRecordFailures", ",", "state", ")", "{", "if", "(", "!", "onlyRecordFailures", "&&", "state", ".", "host", ".", "fileExists", "(", "fileName", ")", ")", "{", "if", "(", "state", ".", "traceEnabled", ")", "{", "ts", ".", "trace", "(", "state", ".", "host", ",", "ts", ".", "Diagnostics", ".", "File_0_exist_use_it_as_a_name_resolution_result", ",", "fileName", ")", ";", "}", "return", "fileName", ";", "}", "else", "{", "if", "(", "state", ".", "traceEnabled", ")", "{", "ts", ".", "trace", "(", "state", ".", "host", ",", "ts", ".", "Diagnostics", ".", "File_0_does_not_exist", ",", "fileName", ")", ";", "}", "failedLookupLocation", ".", "push", "(", "fileName", ")", ";", "return", "undefined", ";", "}", "}" ]

[ "Return", "the", "file", "if", "it", "exists", "." ]

[ "function", "tryAddingExtensions", "(", "candidate", ",", "extensions", ",", "failedLookupLocation", ",", "onlyRecordFailures", ",", "state", ")", "{", "if", "(", "!", "onlyRecordFailures", ")", "{", "var", "directory", "=", "ts", ".", "getDirectoryPath", "(", "candidate", ")", ";", "if", "(", "directory", ")", "{", "onlyRecordFailures", "=", "!", "directoryProbablyExists", "(", "directory", ",", "state", ".", "host", ")", ";", "}", "}", "return", "ts", ".", "forEach", "(", "extensions", ",", "function", "(", "ext", ")", "{", "return", "!", "(", "state", ".", "skipTsx", "&&", "ts", ".", "isJsxOrTsxExtension", "(", "ext", ")", ")", "&&", "tryFile", "(", "candidate", "+", "ext", ",", "failedLookupLocation", ",", "onlyRecordFailures", ",", "state", ")", ";", "}", ")", ";", "}" ]

[ "Try", "to", "return", "an", "existing", "file", "that", "adds", "one", "of", "the", "extensions", "to", "candidate", "." ]

[ "function", "getDeclarationName", "(", "node", ")", "{", "if", "(", "node", ".", "name", ")", "{", "if", "(", "ts", ".", "isAmbientModule", "(", "node", ")", ")", "{", "return", "ts", ".", "isGlobalScopeAugmentation", "(", "node", ")", "?", "\"__global\"", ":", "\"\\\"\"", "+", "\\\"", "+", "node", ".", "name", ".", "text", ";", "}", "\"\\\"\"", "\\\"", "}", "if", "(", "node", ".", "name", ".", "kind", "===", "140", ")", "{", "var", "nameExpression", "=", "node", ".", "name", ".", "expression", ";", "if", "(", "ts", ".", "isStringOrNumericLiteral", "(", "nameExpression", ".", "kind", ")", ")", "{", "return", "nameExpression", ".", "text", ";", "}", "ts", ".", "Debug", ".", "assert", "(", "ts", ".", "isWellKnownSymbolSyntactically", "(", "nameExpression", ")", ")", ";", "return", "ts", ".", "getPropertyNameForKnownSymbolName", "(", "nameExpression", ".", "name", ".", "text", ")", ";", "}", "}" ]

[ "Should", "not", "be", "called", "on", "a", "declaration", "with", "a", "computed", "property", "name", "unless", "it", "is", "a", "well", "known", "Symbol", "." ]

[ "function", "declareSymbol", "(", "symbolTable", ",", "parent", ",", "node", ",", "includes", ",", "excludes", ")", "{", "ts", ".", "Debug", ".", "assert", "(", "!", "ts", ".", "hasDynamicName", "(", "node", ")", ")", ";", "var", "isDefaultExport", "=", "node", ".", "flags", "&", "512", ";", "var", "name", "=", "isDefaultExport", "&&", "parent", "?", "\"default\"", ":", "getDeclarationName", "(", "node", ")", ";", "var", "symbol", ";", "if", "(", "name", "===", "undefined", ")", "{", "symbol", "=", "createSymbol", "(", "0", ",", "\"__missing\"", ")", ";", "}", "else", "{", "symbol", "=", "symbolTable", "[", "name", "]", "||", "(", "symbolTable", "[", "name", "]", "=", "createSymbol", "(", "0", ",", "name", ")", ")", ";", "if", "(", "name", "&&", "(", "includes", "&", "788448", ")", ")", "{", "classifiableNames", "[", "name", "]", "=", "name", ";", "}", "if", "(", "symbol", ".", "flags", "&", "excludes", ")", "{", "if", "(", "symbol", ".", "isReplaceableByMethod", ")", "{", "symbol", "=", "symbolTable", "[", "name", "]", "=", "createSymbol", "(", "0", ",", "name", ")", ";", "}", "else", "{", "if", "(", "node", ".", "name", ")", "{", "node", ".", "name", ".", "parent", "=", "node", ";", "}", "var", "message_1", "=", "symbol", ".", "flags", "&", "2", "?", "ts", ".", "Diagnostics", ".", "Cannot_redeclare_block_scoped_variable_0", ":", "ts", ".", "Diagnostics", ".", "Duplicate_identifier_0", ";", "ts", ".", "forEach", "(", "symbol", ".", "declarations", ",", "function", "(", "declaration", ")", "{", "if", "(", "declaration", ".", "flags", "&", "512", ")", "{", "message_1", "=", "ts", ".", "Diagnostics", ".", "A_module_cannot_have_multiple_default_exports", ";", "}", "}", ")", ";", "ts", ".", "forEach", "(", "symbol", ".", "declarations", ",", "function", "(", "declaration", ")", "{", "file", ".", "bindDiagnostics", ".", "push", "(", "ts", ".", "createDiagnosticForNode", "(", "declaration", ".", "name", "||", "declaration", ",", "message_1", ",", "getDisplayName", "(", "declaration", ")", ")", ")", ";", "}", ")", ";", "file", ".", "bindDiagnostics", ".", "push", "(", "ts", ".", "createDiagnosticForNode", "(", "node", ".", "name", "||", "node", ",", "message_1", ",", "getDisplayName", "(", "node", ")", ")", ")", ";", "symbol", "=", "createSymbol", "(", "0", ",", "name", ")", ";", "}", "}", "}", "addDeclarationToSymbol", "(", "symbol", ",", "node", ",", "includes", ")", ";", "symbol", ".", "parent", "=", "parent", ";", "return", "symbol", ";", "}" ]

[ "Declares", "a", "Symbol", "for", "the", "node", "and", "adds", "it", "to", "symbols", ".", "Reports", "errors", "for", "conflicting", "identifier", "names", "." ]

[ "function", "bindContainer", "(", "node", ",", "containerFlags", ")", "{", "var", "saveContainer", "=", "container", ";", "var", "savedBlockScopeContainer", "=", "blockScopeContainer", ";", "if", "(", "containerFlags", "&", "1", ")", "{", "container", "=", "blockScopeContainer", "=", "node", ";", "if", "(", "containerFlags", "&", "32", ")", "{", "container", ".", "locals", "=", "ts", ".", "createMap", "(", ")", ";", "}", "addToContainerChain", "(", "container", ")", ";", "}", "else", "if", "(", "containerFlags", "&", "2", ")", "{", "blockScopeContainer", "=", "node", ";", "blockScopeContainer", ".", "locals", "=", "undefined", ";", "}", "if", "(", "containerFlags", "&", "4", ")", "{", "var", "saveCurrentFlow", "=", "currentFlow", ";", "var", "saveBreakTarget", "=", "currentBreakTarget", ";", "var", "saveContinueTarget", "=", "currentContinueTarget", ";", "var", "saveReturnTarget", "=", "currentReturnTarget", ";", "var", "saveActiveLabels", "=", "activeLabels", ";", "var", "saveHasExplicitReturn", "=", "hasExplicitReturn", ";", "var", "isIIFE", "=", "containerFlags", "&", "16", "&&", "!", "!", "ts", ".", "getImmediatelyInvokedFunctionExpression", "(", "node", ")", ";", "if", "(", "isIIFE", ")", "{", "currentReturnTarget", "=", "createBranchLabel", "(", ")", ";", "}", "else", "{", "currentFlow", "=", "{", "flags", ":", "2", "}", ";", "if", "(", "containerFlags", "&", "16", ")", "{", "currentFlow", ".", "container", "=", "node", ";", "}", "currentReturnTarget", "=", "undefined", ";", "}", "currentBreakTarget", "=", "undefined", ";", "currentContinueTarget", "=", "undefined", ";", "activeLabels", "=", "undefined", ";", "hasExplicitReturn", "=", "false", ";", "bindChildren", "(", "node", ")", ";", "node", ".", "flags", "&=", "~", "4030464", ";", "if", "(", "!", "(", "currentFlow", ".", "flags", "&", "1", ")", "&&", "containerFlags", "&", "8", "&&", "ts", ".", "nodeIsPresent", "(", "node", ".", "body", ")", ")", "{", "node", ".", "flags", "|=", "32768", ";", "if", "(", "hasExplicitReturn", ")", "node", ".", "flags", "|=", "65536", ";", "}", "if", "(", "node", ".", "kind", "===", "256", ")", "{", "node", ".", "flags", "|=", "emitFlags", ";", "}", "if", "(", "isIIFE", ")", "{", "addAntecedent", "(", "currentReturnTarget", ",", "currentFlow", ")", ";", "currentFlow", "=", "finishFlowLabel", "(", "currentReturnTarget", ")", ";", "}", "else", "{", "currentFlow", "=", "saveCurrentFlow", ";", "}", "currentBreakTarget", "=", "saveBreakTarget", ";", "currentContinueTarget", "=", "saveContinueTarget", ";", "currentReturnTarget", "=", "saveReturnTarget", ";", "activeLabels", "=", "saveActiveLabels", ";", "hasExplicitReturn", "=", "saveHasExplicitReturn", ";", "}", "else", "if", "(", "containerFlags", "&", "64", ")", "{", "seenThisKeyword", "=", "false", ";", "bindChildren", "(", "node", ")", ";", "node", ".", "flags", "=", "seenThisKeyword", "?", "node", ".", "flags", "|", "16384", ":", "node", ".", "flags", "&", "~", "16384", ";", "}", "else", "{", "bindChildren", "(", "node", ")", ";", "}", "container", "=", "saveContainer", ";", "blockScopeContainer", "=", "savedBlockScopeContainer", ";", "}" ]

[ "All", "container", "nodes", "are", "kept", "on", "a", "linked", "list", "in", "declaration", "order", ".", "This", "list", "is", "used", "by", "the", "getLocalNameOfContainer", "function", "in", "the", "type", "checker", "to", "validate", "that", "the", "local", "name", "used", "for", "a", "container", "is", "unique", "." ]

[ "function", "checkStrictModeIdentifier", "(", "node", ")", "{", "if", "(", "inStrictMode", "&&", "node", ".", "originalKeywordKind", ">=", "106", "&&", "node", ".", "originalKeywordKind", "<=", "114", "&&", "!", "ts", ".", "isIdentifierName", "(", "node", ")", "&&", "!", "ts", ".", "isInAmbientContext", "(", "node", ")", ")", "{", "if", "(", "!", "file", ".", "parseDiagnostics", ".", "length", ")", "{", "file", ".", "bindDiagnostics", ".", "push", "(", "ts", ".", "createDiagnosticForNode", "(", "node", ",", "getStrictModeIdentifierMessage", "(", "node", ")", ",", "ts", ".", "declarationNameToString", "(", "node", ")", ")", ")", ";", "}", "}", "}" ]

[ "The", "binder", "visits", "every", "node", "in", "the", "syntax", "tree", "so", "it", "is", "a", "convenient", "place", "to", "perform", "a", "single", "localized", "check", "for", "reserved", "words", "used", "as", "identifiers", "in", "strict", "mode", "code", "." ]

[ "function", "getSymbolsOfParameterPropertyDeclaration", "(", "parameter", ",", "parameterName", ")", "{", "var", "constructorDeclaration", "=", "parameter", ".", "parent", ";", "var", "classDeclaration", "=", "parameter", ".", "parent", ".", "parent", ";", "var", "parameterSymbol", "=", "getSymbol", "(", "constructorDeclaration", ".", "locals", ",", "parameterName", ",", "107455", ")", ";", "var", "propertySymbol", "=", "getSymbol", "(", "classDeclaration", ".", "symbol", ".", "members", ",", "parameterName", ",", "107455", ")", ";", "if", "(", "parameterSymbol", "&&", "propertySymbol", ")", "{", "return", "[", "parameterSymbol", ",", "propertySymbol", "]", ";", "}", "ts", ".", "Debug", ".", "fail", "(", "\"There should exist two symbols, one as property declaration and one as parameter declaration\"", ")", ";", "}" ]

[ "Get", "symbols", "that", "represent", "parameter", "-", "property", "-", "declaration", "as", "parameter", "and", "as", "property", "declaration" ]

[ "function", "getEntityNameForExtendingInterface", "(", "node", ")", "{", "switch", "(", "node", ".", "kind", ")", "{", "case", "69", ":", "case", "172", ":", "return", "node", ".", "parent", "?", "getEntityNameForExtendingInterface", "(", "node", ".", "parent", ")", ":", "undefined", ";", "case", "194", ":", "ts", ".", "Debug", ".", "assert", "(", "ts", ".", "isEntityNameExpression", "(", "node", ".", "expression", ")", ")", ";", "return", "node", ".", "expression", ";", "default", ":", "return", "undefined", ";", "}", "}" ]

[ "Climbs", "up", "parents", "to", "an", "ExpressionWithTypeArguments", "and", "returns", "its", "expression", "but", "returns", "undefined", "if", "that", "expression", "is", "not", "an", "EntityNameExpression", "." ]

[ "function", "getSymbolOfPartOfRightHandSideOfImportEquals", "(", "entityName", ",", "importDeclaration", ",", "dontResolveAlias", ")", "{", "if", "(", "entityName", ".", "kind", "===", "69", "&&", "ts", ".", "isRightSideOfQualifiedNameOrPropertyAccess", "(", "entityName", ")", ")", "{", "entityName", "=", "entityName", ".", "parent", ";", "}", "if", "(", "entityName", ".", "kind", "===", "69", "||", "entityName", ".", "parent", ".", "kind", "===", "139", ")", "{", "return", "resolveEntityName", "(", "entityName", ",", "1920", ",", "false", ",", "dontResolveAlias", ")", ";", "}", "else", "{", "ts", ".", "Debug", ".", "assert", "(", "entityName", ".", "parent", ".", "kind", "===", "229", ")", ";", "return", "resolveEntityName", "(", "entityName", ",", "107455", "|", "793064", "|", "1920", ",", "false", ",", "dontResolveAlias", ")", ";", "}", "}" ]

[ "This", "function", "is", "only", "for", "imports", "with", "entity", "names" ]

[ "function", "extendExportSymbols", "(", "target", ",", "source", ",", "lookupTable", ",", "exportNode", ")", "{", "for", "(", "var", "id", "in", "source", ")", "{", "if", "(", "id", "!==", "\"default\"", "&&", "!", "target", "[", "id", "]", ")", "{", "target", "[", "id", "]", "=", "source", "[", "id", "]", ";", "if", "(", "lookupTable", "&&", "exportNode", ")", "{", "lookupTable", "[", "id", "]", "=", "{", "specifierText", ":", "ts", ".", "getTextOfNode", "(", "exportNode", ".", "moduleSpecifier", ")", "}", ";", "}", "}", "else", "if", "(", "lookupTable", "&&", "exportNode", "&&", "id", "!==", "\"default\"", "&&", "target", "[", "id", "]", "&&", "resolveSymbol", "(", "target", "[", "id", "]", ")", "!==", "resolveSymbol", "(", "source", "[", "id", "]", ")", ")", "{", "if", "(", "!", "lookupTable", "[", "id", "]", ".", "exportsWithDuplicate", ")", "{", "lookupTable", "[", "id", "]", ".", "exportsWithDuplicate", "=", "[", "exportNode", "]", ";", "}", "else", "{", "lookupTable", "[", "id", "]", ".", "exportsWithDuplicate", ".", "push", "(", "exportNode", ")", ";", "}", "}", "}", "}" ]

[ "Extends", "one", "symbol", "table", "with", "another", "while", "collecting", "information", "on", "name", "collisions", "for", "error", "message", "generation", "into", "the", "lookupTable", "argument", "Not", "passing", "lookupTable", "and", "exportNode", "disables", "this", "collection", "and", "just", "extends", "the", "tables" ]