Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "eval_css", "(", "locator", ",", "inDocument", ")", "{", "var", "results", "=", "[", "]", ";", "try", "{", "window", ".", "Sizzle", "(", "locator", ",", "inDocument", ",", "results", ")", ";", "}", "catch", "(", "ignored", ")", "{", "// Presumably poor formatting", "}", "return", "results", ";", "}" ]

[ "Returns", "the", "full", "resultset", "of", "a", "CSS", "selector", "evaluation", "." ]

[ "function", "are_equal", "(", "a1", ",", "a2", ")", "{", "if", "(", "typeof", "(", "a1", ")", "!=", "typeof", "(", "a2", ")", ")", "return", "false", ";", "switch", "(", "typeof", "(", "a1", ")", ")", "{", "case", "'object'", ":", "// arrays", "if", "(", "a1", ".", "length", ")", "{", "if", "(", "a1", ".", "length", "!=", "a2", ".", "length", ")", "return", "false", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "a1", ".", "length", ";", "++", "i", ")", "{", "if", "(", "!", "are_equal", "(", "a1", "[", "i", "]", ",", "a2", "[", "i", "]", ")", ")", "return", "false", "}", "}", "// associative arrays", "else", "{", "var", "keys", "=", "{", "}", ";", "for", "(", "var", "key", "in", "a1", ")", "{", "keys", "[", "key", "]", "=", "true", ";", "}", "for", "(", "var", "key", "in", "a2", ")", "{", "keys", "[", "key", "]", "=", "true", ";", "}", "for", "(", "var", "key", "in", "keys", ")", "{", "if", "(", "!", "are_equal", "(", "a1", "[", "key", "]", ",", "a2", "[", "key", "]", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "default", ":", "return", "a1", "==", "a2", ";", "}", "}" ]

[ "Returns", "true", "if", "two", "arrays", "are", "identical", "and", "false", "otherwise", "." ]

[ "function", "clone", "(", "orig", ")", "{", "var", "copy", ";", "switch", "(", "typeof", "(", "orig", ")", ")", "{", "case", "'object'", ":", "copy", "=", "(", "orig", ".", "length", ")", "?", "[", "]", ":", "{", "}", ";", "for", "(", "var", "attr", "in", "orig", ")", "{", "copy", "[", "attr", "]", "=", "clone", "(", "orig", "[", "attr", "]", ")", ";", "}", "break", ";", "default", ":", "copy", "=", "orig", ";", "break", ";", "}", "return", "copy", ";", "}" ]

[ "Create", "a", "clone", "of", "an", "object", "and", "return", "it", ".", "This", "is", "a", "deep", "copy", "of", "everything", "but", "functions", "whose", "references", "are", "copied", ".", "You", "shouldn", "t", "expect", "a", "deep", "copy", "of", "functions", "anyway", "." ]

[ "function", "parse_kwargs", "(", "kwargs", ")", "{", "var", "args", "=", "new", "Object", "(", ")", ";", "var", "pairs", "=", "kwargs", ".", "split", "(", "/", ",", "/", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "pairs", ".", "length", ";", ")", "{", "if", "(", "i", ">", "0", "&&", "pairs", "[", "i", "]", ".", "indexOf", "(", "'='", ")", "==", "-", "1", ")", "{", "// the value string contained a comma. Glue the parts back together.", "pairs", "[", "i", "-", "1", "]", "+=", "','", "+", "pairs", ".", "splice", "(", "i", ",", "1", ")", "[", "0", "]", ";", "}", "else", "{", "++", "i", ";", "}", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "pairs", ".", "length", ";", "++", "i", ")", "{", "var", "splits", "=", "pairs", "[", "i", "]", ".", "split", "(", "/", "=", "/", ")", ";", "if", "(", "splits", ".", "length", "==", "1", ")", "{", "continue", ";", "}", "var", "key", "=", "splits", ".", "shift", "(", ")", ";", "var", "value", "=", "splits", ".", "join", "(", "'='", ")", ";", "args", "[", "key", ".", "trim", "(", ")", "]", "=", "value", ".", "trim", "(", ")", ";", "}", "return", "args", ";", "}" ]

[ "Parses", "a", "python", "-", "style", "keyword", "arguments", "string", "and", "returns", "the", "pairs", "in", "a", "new", "object", "." ]

[ "function", "to_kwargs", "(", "args", ",", "sortedKeys", ")", "{", "var", "s", "=", "''", ";", "if", "(", "!", "sortedKeys", ")", "{", "var", "sortedKeys", "=", "keys", "(", "args", ")", ".", "sort", "(", ")", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "sortedKeys", ".", "length", ";", "++", "i", ")", "{", "var", "k", "=", "sortedKeys", "[", "i", "]", ";", "if", "(", "args", "[", "k", "]", "!=", "undefined", ")", "{", "if", "(", "s", ")", "{", "s", "+=", "', '", ";", "}", "s", "+=", "k", "+", "'='", "+", "args", "[", "k", "]", ";", "}", "}", "return", "s", ";", "}" ]

[ "Creates", "a", "python", "-", "style", "keyword", "arguments", "string", "from", "an", "object", "." ]

[ "function", "is_ancestor", "(", "node", ",", "target", ")", "{", "while", "(", "target", ".", "parentNode", ")", "{", "target", "=", "target", ".", "parentNode", ";", "if", "(", "node", "==", "target", ")", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "a", "node", "is", "an", "ancestor", "node", "of", "a", "target", "node", "and", "false", "otherwise", "." ]

[ "function", "(", ")", "{", "if", "(", "this", ".", "options", ".", "step", ")", "{", "this", ".", "options", ".", "step", ".", "call", "(", "this", ".", "elem", ",", "this", ".", "now", ",", "this", ")", ";", "}", "(", "jQuery", ".", "fx", ".", "step", "[", "this", ".", "prop", "]", "||", "jQuery", ".", "fx", ".", "step", ".", "_default", ")", "(", "this", ")", ";", "// Set display property to block for height/width animations", "if", "(", "(", "this", ".", "prop", "===", "\"height\"", "||", "this", ".", "prop", "===", "\"width\"", ")", "&&", "this", ".", "elem", ".", "style", ")", "{", "this", ".", "elem", ".", "style", ".", "display", "=", "\"block\"", ";", "}", "}" ]

[ "Simple", "function", "for", "setting", "a", "style", "value" ]

[ "function", "locationBar_clear", "(", ")", "{", "this", ".", "focus", "(", "{", "type", ":", "\"shortcut\"", "}", ")", ";", "this", ".", "_controller", ".", "keypress", "(", "this", ".", "urlbar", ",", "\"VK_DELETE\"", ",", "{", "}", ")", ";", "this", ".", "_controller", ".", "waitForEval", "(", "\"subject.value == ''\"", ",", "TIMEOUT", ",", "100", ",", "this", ".", "urlbar", ".", "getNode", "(", ")", ")", ";", "}" ]

[ "Clear", "the", "location", "bar" ]

[ "function", "locationBar_focus", "(", "event", ")", "{", "switch", "(", "event", ".", "type", ")", "{", "case", "\"click\"", ":", "this", ".", "_controller", ".", "click", "(", "this", ".", "urlbar", ")", ";", "break", ";", "case", "\"shortcut\"", ":", "var", "cmdKey", "=", "utils", ".", "getEntity", "(", "this", ".", "getDtds", "(", ")", ",", "\"openCmd.commandkey\"", ")", ";", "this", ".", "_controller", ".", "keypress", "(", "null", ",", "cmdKey", ",", "{", "accelKey", ":", "true", "}", ")", ";", "break", ";", "default", ":", "throw", "new", "Error", "(", "arguments", ".", "callee", ".", "name", "+", "\": Unkown event type - \"", "+", "event", ".", "type", ")", ";", "}", "// Wait until the location bar has been focused", "this", ".", "_controller", ".", "waitForEval", "(", "\"subject.getAttribute('focused') == 'true'\"", ",", "TIMEOUT", ",", "100", ",", "this", ".", "urlbar", ".", "getNode", "(", ")", ")", ";", "}" ]

[ "Focus", "the", "location", "bar" ]

[ "function", "locationBar_getNotificationElement", "(", "aType", ",", "aLookupString", ")", "{", "var", "lookup", "=", "'/id(\"'", "+", "aType", "+", "'\")'", ";", "lookup", "=", "aLookupString", "?", "lookup", "+", "aLookupString", ":", "lookup", ";", "// Get the notification and fetch the child element if wanted", "return", "this", ".", "getElement", "(", "{", "type", ":", "\"notification_element\"", ",", "subtype", ":", "lookup", "}", ")", ";", "}" ]

[ "Retrieves", "the", "specified", "element", "of", "the", "door", "hanger", "notification", "bar" ]

[ "function", "locationBar_toggleAutocompletePopup", "(", ")", "{", "var", "dropdown", "=", "this", ".", "getElement", "(", "{", "type", ":", "\"historyDropMarker\"", "}", ")", ";", "var", "stateOpen", "=", "this", ".", "autoCompleteResults", ".", "isOpened", ";", "this", ".", "_controller", ".", "click", "(", "dropdown", ")", ";", "this", ".", "_controller", ".", "waitForEval", "(", "\"subject.isOpened == \"", "+", "stateOpen", ",", "TIMEOUT", ",", "100", ",", "this", ".", "autoCompleteResults", ")", ";", "}" ]

[ "Toggles", "between", "the", "open", "and", "closed", "state", "of", "the", "auto", "-", "complete", "popup" ]

[ "function", "preferencesDialog_close", "(", "saveChanges", ")", "{", "saveChanges", "=", "(", "saveChanges", "==", "undefined", ")", "?", "false", ":", "saveChanges", ";", "if", "(", "mozmill", ".", "isWindows", ")", "{", "var", "button", "=", "this", ".", "getElement", "(", "{", "type", ":", "\"button\"", ",", "subtype", ":", "(", "saveChanges", "?", "\"accept\"", ":", "\"cancel\"", ")", "}", ")", ";", "this", ".", "_controller", ".", "click", "(", "button", ")", ";", "}", "else", "{", "this", ".", "_controller", ".", "keypress", "(", "null", ",", "'w'", ",", "{", "accelKey", ":", "true", "}", ")", ";", "}", "}" ]

[ "Close", "the", "preferences", "dialog" ]

[ "function", "preferences_getPref", "(", "prefName", ",", "defaultValue", ",", "defaultBranch", ",", "interfaceType", ")", "{", "try", "{", "branch", "=", "defaultBranch", "?", "this", ".", "defaultPrefBranch", ":", "this", ".", "prefBranch", ";", "// If interfaceType has been set, handle it differently", "if", "(", "interfaceType", "!=", "undefined", ")", "{", "return", "branch", ".", "getComplexValue", "(", "prefName", ",", "interfaceType", ")", ";", "}", "switch", "(", "typeof", "defaultValue", ")", "{", "case", "(", "'boolean'", ")", ":", "return", "branch", ".", "getBoolPref", "(", "prefName", ")", ";", "case", "(", "'string'", ")", ":", "return", "branch", ".", "getCharPref", "(", "prefName", ")", ";", "case", "(", "'number'", ")", ":", "return", "branch", ".", "getIntPref", "(", "prefName", ")", ";", "default", ":", "return", "undefined", ";", "}", "}", "catch", "(", "e", ")", "{", "return", "defaultValue", ";", "}", "}" ]

[ "Retrieve", "the", "value", "of", "an", "individual", "preference", "." ]

[ "function", "preferences_setPref", "(", "prefName", ",", "value", ",", "interfaceType", ")", "{", "try", "{", "switch", "(", "typeof", "value", ")", "{", "case", "(", "'boolean'", ")", ":", "this", ".", "prefBranch", ".", "setBoolPref", "(", "prefName", ",", "value", ")", ";", "break", ";", "case", "(", "'string'", ")", ":", "this", ".", "prefBranch", ".", "setCharPref", "(", "prefName", ",", "value", ")", ";", "break", ";", "case", "(", "'number'", ")", ":", "this", ".", "prefBranch", ".", "setIntPref", "(", "prefName", ",", "value", ")", ";", "break", ";", "default", ":", "this", ".", "prefBranch", ".", "setComplexValue", "(", "prefName", ",", "interfaceType", ",", "value", ")", ";", "}", "}", "catch", "(", "e", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Set", "the", "value", "of", "an", "individual", "preference", "." ]

[ "function", "openPreferencesDialog", "(", "controller", ",", "callback", ",", "launcher", ")", "{", "if", "(", "!", "controller", ")", "throw", "new", "Error", "(", "\"No controller given for Preferences Dialog\"", ")", ";", "if", "(", "typeof", "callback", "!=", "\"function\"", ")", "throw", "new", "Error", "(", "\"No callback given for Preferences Dialog\"", ")", ";", "if", "(", "mozmill", ".", "isWindows", ")", "{", "// Preference dialog is modal on windows, set up our callback", "var", "prefModal", "=", "new", "modalDialog", ".", "modalDialog", "(", "controller", ".", "window", ")", ";", "prefModal", ".", "start", "(", "callback", ")", ";", "}", "// Launch the preference dialog", "if", "(", "launcher", ")", "{", "launcher", "(", ")", ";", "}", "else", "{", "mozmill", ".", "getPreferencesController", "(", ")", ";", "}", "if", "(", "mozmill", ".", "isWindows", ")", "{", "prefModal", ".", "waitForDialog", "(", ")", ";", "}", "else", "{", "// Get the window type of the preferences window depending on the application", "var", "prefWindowType", "=", "null", ";", "switch", "(", "mozmill", ".", "Application", ")", "{", "case", "\"Thunderbird\"", ":", "prefWindowType", "=", "\"Mail:Preferences\"", ";", "break", ";", "default", ":", "prefWindowType", "=", "\"Browser:Preferences\"", ";", "}", "utils", ".", "handleWindow", "(", "\"type\"", ",", "prefWindowType", ",", "callback", ")", ";", "}", "}" ]

[ "Open", "the", "preferences", "dialog", "and", "call", "the", "given", "handler" ]

[ "async", "function", "map", "(", "array", ",", "fn", ",", "self", "=", "undefined", ")", "{", "const", "v", "=", "await", "Promise", ".", "resolve", "(", "array", ")", ";", "if", "(", "!", "Array", ".", "isArray", "(", "v", ")", ")", "{", "throw", "TypeError", "(", "'not an array'", ")", ";", "}", "const", "arr", "=", "/** @type {!Array} */", "(", "v", ")", ";", "const", "n", "=", "arr", ".", "length", ";", "const", "values", "=", "new", "Array", "(", "n", ")", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "i", "in", "arr", ")", "{", "values", "[", "i", "]", "=", "await", "Promise", ".", "resolve", "(", "fn", ".", "call", "(", "self", ",", "arr", "[", "i", "]", ",", "i", ",", "arr", ")", ")", ";", "}", "}", "return", "values", ";", "}" ]

[ "Calls", "a", "function", "for", "each", "element", "in", "an", "array", "and", "inserts", "the", "result", "into", "a", "new", "array", "which", "is", "used", "as", "the", "fulfillment", "value", "of", "the", "promise", "returned", "by", "this", "function", "." ]

[ "async", "function", "filter", "(", "array", ",", "fn", ",", "self", "=", "undefined", ")", "{", "const", "v", "=", "await", "Promise", ".", "resolve", "(", "array", ")", ";", "if", "(", "!", "Array", ".", "isArray", "(", "v", ")", ")", "{", "throw", "TypeError", "(", "'not an array'", ")", ";", "}", "const", "arr", "=", "/** @type {!Array} */", "(", "v", ")", ";", "const", "n", "=", "arr", ".", "length", ";", "const", "values", "=", "[", "]", ";", "let", "valuesLength", "=", "0", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "if", "(", "i", "in", "arr", ")", "{", "let", "value", "=", "arr", "[", "i", "]", ";", "let", "include", "=", "await", "fn", ".", "call", "(", "self", ",", "value", ",", "i", ",", "arr", ")", ";", "if", "(", "include", ")", "{", "values", "[", "valuesLength", "++", "]", "=", "value", ";", "}", "}", "}", "return", "values", ";", "}" ]

[ "Calls", "a", "function", "for", "each", "element", "in", "an", "array", "and", "if", "the", "function", "returns", "true", "adds", "the", "element", "to", "a", "new", "array", "." ]

[ "function", "xbDebugApplyFunction", "(", "funcname", ",", "funcref", ",", "thisref", ",", "argumentsref", ")", "{", "var", "rv", ";", "if", "(", "!", "funcref", ")", "{", "alert", "(", "'xbDebugApplyFunction: funcref is null'", ")", ";", "}", "if", "(", "typeof", "(", "funcref", ".", "apply", ")", "!=", "'undefined'", ")", "return", "funcref", ".", "apply", "(", "thisref", ",", "argumentsref", ")", ";", "var", "applyexpr", "=", "'thisref.xbDebug_orig_'", "+", "funcname", "+", "'('", ";", "var", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "argumentsref", ".", "length", ";", "i", "++", ")", "{", "applyexpr", "+=", "'argumentsref['", "+", "i", "+", "'],'", ";", "}", "if", "(", "argumentsref", ".", "length", ">", "0", ")", "{", "applyexpr", "=", "applyexpr", ".", "substring", "(", "0", ",", "applyexpr", ".", "length", "-", "1", ")", ";", "}", "applyexpr", "+=", "')'", ";", "return", "eval", "(", "applyexpr", ")", ";", "}" ]

[ "emulate", "functionref", ".", "apply", "for", "IE", "mac", "and", "IE", "win", "<", "5", ".", "5" ]

[ "function", "xpathCollectDescendants", "(", "nodelist", ",", "node", ",", "opt_tagName", ")", "{", "if", "(", "opt_tagName", "&&", "node", ".", "getElementsByTagName", ")", "{", "copyArray", "(", "nodelist", ",", "node", ".", "getElementsByTagName", "(", "opt_tagName", ")", ")", ";", "return", ";", "}", "for", "(", "var", "n", "=", "node", ".", "firstChild", ";", "n", ";", "n", "=", "n", ".", "nextSibling", ")", "{", "nodelist", ".", "push", "(", "n", ")", ";", "xpathCollectDescendants", "(", "nodelist", ",", "n", ")", ";", "}", "}" ]

[ "Local", "utility", "functions", "that", "are", "used", "by", "the", "lexer", "or", "parser", "." ]

[ "function", "privateBrowsing", "(", "controller", ")", "{", "this", ".", "_controller", "=", "controller", ";", "this", ".", "_handler", "=", "null", ";", "/**\n * Menu item in the main menu to enter/leave Private Browsing mode\n * @private\n */", "this", ".", "_pbMenuItem", "=", "new", "elementslib", ".", "Elem", "(", "this", ".", "_controller", ".", "menus", "[", "'tools-menu'", "]", ".", "privateBrowsingItem", ")", ";", "this", ".", "_pbTransitionItem", "=", "new", "elementslib", ".", "ID", "(", "this", ".", "_controller", ".", "window", ".", "document", ",", "\"Tools:PrivateBrowsing\"", ")", ";", "this", ".", "__defineGetter__", "(", "'_pbs'", ",", "function", "(", ")", "{", "delete", "this", ".", "_pbs", ";", "return", "this", ".", "_pbs", "=", "Cc", "[", "\"@mozilla.org/privatebrowsing;1\"", "]", ".", "getService", "(", "Ci", ".", "nsIPrivateBrowsingService", ")", ";", "}", ")", ";", "}" ]

[ "Create", "a", "new", "privateBrowsing", "instance", "." ]

[ "function", "privateBrowsing_start", "(", "useShortcut", ")", "{", "var", "dialog", "=", "null", ";", "if", "(", "this", ".", "enabled", ")", "return", ";", "if", "(", "this", ".", "showPrompt", ")", "{", "dialog", "=", "new", "modalDialog", ".", "modalDialog", "(", "this", ".", "_controller", ".", "window", ")", ";", "dialog", ".", "start", "(", "this", ".", "_handler", ")", ";", "}", "if", "(", "useShortcut", ")", "{", "var", "cmdKey", "=", "utils", ".", "getEntity", "(", "this", ".", "getDtds", "(", ")", ",", "\"privateBrowsingCmd.commandkey\"", ")", ";", "this", ".", "_controller", ".", "keypress", "(", "null", ",", "cmdKey", ",", "{", "accelKey", ":", "true", ",", "shiftKey", ":", "true", "}", ")", ";", "}", "else", "{", "this", ".", "_controller", ".", "click", "(", "this", ".", "_pbMenuItem", ")", ";", "}", "if", "(", "dialog", ")", "{", "dialog", ".", "waitForDialog", "(", ")", ";", "}", "this", ".", "waitForTransistionComplete", "(", "true", ")", ";", "}" ]

[ "Start", "the", "Private", "Browsing", "mode" ]

[ "function", "privateBrowsing_stop", "(", "useShortcut", ")", "{", "if", "(", "!", "this", ".", "enabled", ")", "return", ";", "if", "(", "useShortcut", ")", "{", "var", "privateBrowsingCmdKey", "=", "utils", ".", "getEntity", "(", "this", ".", "getDtds", "(", ")", ",", "\"privateBrowsingCmd.commandkey\"", ")", ";", "this", ".", "_controller", ".", "keypress", "(", "null", ",", "privateBrowsingCmdKey", ",", "{", "accelKey", ":", "true", ",", "shiftKey", ":", "true", "}", ")", ";", "}", "else", "{", "this", ".", "_controller", ".", "click", "(", "this", ".", "_pbMenuItem", ")", ";", "}", "this", ".", "waitForTransistionComplete", "(", "false", ")", ";", "}" ]

[ "Stop", "the", "Private", "Browsing", "mode" ]

[ "function", "privateBrowsing_waitForTransitionComplete", "(", "state", ")", "{", "// We have to wait until the transition has been finished", "this", ".", "_controller", ".", "waitForEval", "(", "\"subject.hasAttribute('disabled') == false\"", ",", "gTimeout", ",", "100", ",", "this", ".", "_pbTransitionItem", ".", "getNode", "(", ")", ")", ";", "this", ".", "_controller", ".", "waitForEval", "(", "\"subject.privateBrowsing.enabled == subject.state\"", ",", "gTimeout", ",", "100", ",", "{", "privateBrowsing", ":", "this", ",", "state", ":", "state", "}", ")", ";", "}" ]

[ "Waits", "until", "the", "transistion", "into", "or", "out", "of", "the", "Private", "Browsing", "mode", "happened" ]

[ "function", "create", "(", "controller", ",", "boxes", ")", "{", "var", "doc", "=", "controller", ".", "window", ".", "document", ";", "var", "maxWidth", "=", "doc", ".", "documentElement", ".", "boxObject", ".", "width", ";", "var", "maxHeight", "=", "doc", ".", "documentElement", ".", "boxObject", ".", "height", ";", "var", "rect", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ",", "j", "=", "boxes", ".", "length", ";", "i", "<", "j", ";", "++", "i", ")", "{", "rect", "=", "boxes", "[", "i", "]", ";", "if", "(", "rect", "[", "0", "]", "+", "rect", "[", "2", "]", ">", "maxWidth", ")", "maxWidth", "=", "rect", "[", "0", "]", "+", "rect", "[", "2", "]", ";", "if", "(", "rect", "[", "1", "]", "+", "rect", "[", "3", "]", ">", "maxHeight", ")", "maxHeight", "=", "rect", "[", "1", "]", "+", "rect", "[", "3", "]", ";", "}", "var", "canvas", "=", "doc", ".", "createElementNS", "(", "\"http://www.w3.org/1999/xhtml\"", ",", "\"canvas\"", ")", ";", "var", "width", "=", "doc", ".", "documentElement", ".", "boxObject", ".", "width", ";", "var", "height", "=", "doc", ".", "documentElement", ".", "boxObject", ".", "height", ";", "canvas", ".", "width", "=", "maxWidth", ";", "canvas", ".", "height", "=", "maxHeight", ";", "var", "ctx", "=", "canvas", ".", "getContext", "(", "\"2d\"", ")", ";", "ctx", ".", "clearRect", "(", "0", ",", "0", ",", "canvas", ".", "width", ",", "canvas", ".", "height", ")", ";", "ctx", ".", "save", "(", ")", ";", "ctx", ".", "drawWindow", "(", "controller", ".", "window", ",", "0", ",", "0", ",", "width", ",", "height", ",", "\"rgb(0,0,0)\"", ")", ";", "ctx", ".", "restore", "(", ")", ";", "ctx", ".", "save", "(", ")", ";", "ctx", ".", "fillStyle", "=", "\"rgba(255,0,0,0.4)\"", ";", "for", "(", "var", "i", "=", "0", ",", "j", "=", "boxes", ".", "length", ";", "i", "<", "j", ";", "++", "i", ")", "{", "rect", "=", "boxes", "[", "i", "]", ";", "ctx", ".", "fillRect", "(", "rect", "[", "0", "]", ",", "rect", "[", "1", "]", ",", "rect", "[", "2", "]", ",", "rect", "[", "3", "]", ")", ";", "}", "ctx", ".", "restore", "(", ")", ";", "_saveCanvas", "(", "canvas", ")", ";", "}" ]

[ "This", "function", "creates", "a", "screenshot", "of", "the", "window", "provided", "in", "the", "given", "controller", "and", "highlights", "elements", "from", "the", "coordinates", "provided", "in", "the", "given", "boxes", "-", "array", "." ]

[ "function", "_saveCanvas", "(", "canvas", ")", "{", "// Use the path given on the command line and saved under", "// persisted.screenshotPath, if available. If not, use the path to the", "// temporary folder as a fallback.", "var", "file", "=", "null", ";", "if", "(", "\"screenshotPath\"", "in", "persisted", ")", "{", "file", "=", "Cc", "[", "\"@mozilla.org/file/local;1\"", "]", ".", "createInstance", "(", "Ci", ".", "nsILocalFile", ")", ";", "file", ".", "initWithPath", "(", "persisted", ".", "screenshotPath", ")", ";", "}", "else", "{", "file", "=", "Cc", "[", "\"@mozilla.org/file/directory_service;1\"", "]", ".", "getService", "(", "Ci", ".", "nsIProperties", ")", ".", "get", "(", "\"TmpD\"", ",", "Ci", ".", "nsIFile", ")", ";", "}", "var", "fileName", "=", "utils", ".", "appInfo", ".", "name", "+", "\"-\"", "+", "utils", ".", "appInfo", ".", "locale", "+", "\".\"", "+", "utils", ".", "appInfo", ".", "version", "+", "\".\"", "+", "utils", ".", "appInfo", ".", "buildID", "+", "\".\"", "+", "utils", ".", "appInfo", ".", "os", "+", "\".png\"", ";", "file", ".", "append", "(", "fileName", ")", ";", "// if a file already exists, don't overwrite it and create a new name", "file", ".", "createUnique", "(", "Ci", ".", "nsIFile", ".", "NORMAL_FILE_TYPE", ",", "parseInt", "(", "\"0666\"", ",", "8", ")", ")", ";", "// create a data url from the canvas and then create URIs of the source", "// and targets", "var", "io", "=", "Cc", "[", "\"@mozilla.org/network/io-service;1\"", "]", ".", "getService", "(", "Ci", ".", "nsIIOService", ")", ";", "var", "source", "=", "io", ".", "newURI", "(", "canvas", ".", "toDataURL", "(", "\"image/png\"", ",", "\"\"", ")", ",", "\"UTF8\"", ",", "null", ")", ";", "var", "target", "=", "io", ".", "newFileURI", "(", "file", ")", "// prepare to save the canvas data", "var", "wbPersist", "=", "Cc", "[", "\"@mozilla.org/embedding/browser/nsWebBrowserPersist;1\"", "]", ".", "createInstance", "(", "Ci", ".", "nsIWebBrowserPersist", ")", ";", "wbPersist", ".", "persistFlags", "=", "Ci", ".", "nsIWebBrowserPersist", ".", "PERSIST_FLAGS_REPLACE_EXISTING_FILES", ";", "wbPersist", ".", "persistFlags", "|=", "Ci", ".", "nsIWebBrowserPersist", ".", "PERSIST_FLAGS_AUTODETECT_APPLY_CONVERSION", ";", "// save the canvas data to the file", "wbPersist", ".", "saveURI", "(", "source", ",", "null", ",", "null", ",", "null", ",", "null", ",", "file", ")", ";", "}" ]

[ "Saves", "a", "given", "Canvas", "object", "to", "a", "file", ".", "The", "path", "to", "save", "the", "file", "under", "should", "be", "given", "on", "the", "command", "line", ".", "If", "not", "it", "will", "be", "saved", "in", "the", "temporary", "folder", "of", "the", "system", "." ]

[ "function", "(", "requestedId", ")", "{", "var", "requestedDeps", "=", "this", ".", "getNotYetLoadedTransitiveDepIds_", "(", "requestedId", ")", ";", "return", "goog", ".", "array", ".", "some", "(", "failedIds", ",", "function", "(", "id", ")", "{", "return", "goog", ".", "array", ".", "contains", "(", "requestedDeps", ",", "id", ")", ";", "}", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "requestedId", "has", "dependencies", "on", "the", "modules", "that", "just", "failed", "to", "load", "." ]

[ "function", "(", "element", ",", "options", ")", "{", "return", "Element", ".", "findChildren", "(", "element", ",", "options", ".", "only", ",", "options", ".", "tree", "?", "true", ":", "false", ",", "options", ".", "tag", ")", ";", "}" ]

[ "return", "all", "suitable", "-", "for", "-", "sortable", "elements", "in", "a", "guaranteed", "order" ]

[ "function", "positiveSize", "(", "e", ")", "{", "var", "rect", "=", "bot", ".", "dom", ".", "getClientRect", "(", "e", ")", ";", "if", "(", "rect", ".", "height", ">", "0", "&&", "rect", ".", "width", ">", "0", ")", "{", "return", "true", ";", "}", "// A vertical or horizontal SVG Path element will report zero width or", "// height but is \"shown\" if it has a positive stroke-width.", "if", "(", "bot", ".", "dom", ".", "isElement", "(", "e", ",", "'PATH'", ")", "&&", "(", "rect", ".", "height", ">", "0", "||", "rect", ".", "width", ">", "0", ")", ")", "{", "var", "strokeWidth", "=", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "e", ",", "'stroke-width'", ")", ";", "return", "!", "!", "strokeWidth", "&&", "(", "parseInt", "(", "strokeWidth", ",", "10", ")", ">", "0", ")", ";", "}", "// Zero-sized elements should still be considered to have positive size", "// if they have a child element or text node with positive size, unless", "// the element has an 'overflow' style of 'hidden'.", "return", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "e", ",", "'overflow'", ")", "!=", "'hidden'", "&&", "goog", ".", "array", ".", "some", "(", "e", ".", "childNodes", ",", "function", "(", "n", ")", "{", "return", "n", ".", "nodeType", "==", "goog", ".", "dom", ".", "NodeType", ".", "TEXT", "||", "(", "bot", ".", "dom", ".", "isElement", "(", "n", ")", "&&", "positiveSize", "(", "n", ")", ")", ";", "}", ")", ";", "}" ]

[ "Any", "element", "without", "positive", "size", "dimensions", "is", "not", "shown", "." ]

[ "function", "hiddenByOverflow", "(", "e", ")", "{", "return", "bot", ".", "dom", ".", "getOverflowState", "(", "e", ")", "==", "bot", ".", "dom", ".", "OverflowState", ".", "HIDDEN", "&&", "goog", ".", "array", ".", "every", "(", "e", ".", "childNodes", ",", "function", "(", "n", ")", "{", "return", "!", "bot", ".", "dom", ".", "isElement", "(", "n", ")", "||", "hiddenByOverflow", "(", "n", ")", "||", "!", "positiveSize", "(", "n", ")", ";", "}", ")", ";", "}" ]

[ "Elements", "that", "are", "hidden", "by", "overflow", "are", "not", "shown", "." ]

[ "function", "getOverflowParent", "(", "e", ")", "{", "var", "position", "=", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "e", ",", "'position'", ")", ";", "if", "(", "position", "==", "'fixed'", ")", "{", "treatAsFixedPosition", "=", "true", ";", "// Fixed-position element may only overflow the viewport.", "return", "e", "==", "htmlElem", "?", "null", ":", "htmlElem", ";", "}", "else", "{", "var", "parent", "=", "bot", ".", "dom", ".", "getParentElement", "(", "e", ")", ";", "while", "(", "parent", "&&", "!", "canBeOverflowed", "(", "parent", ")", ")", "{", "parent", "=", "bot", ".", "dom", ".", "getParentElement", "(", "parent", ")", ";", "}", "return", "parent", ";", "}", "function", "canBeOverflowed", "(", "container", ")", "{", "// The HTML element can always be overflowed.", "if", "(", "container", "==", "htmlElem", ")", "{", "return", "true", ";", "}", "// An element cannot overflow an element with an inline or contents display style.", "var", "containerDisplay", "=", "/** @type {string} */", "(", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "container", ",", "'display'", ")", ")", ";", "if", "(", "goog", ".", "string", ".", "startsWith", "(", "containerDisplay", ",", "'inline'", ")", "||", "(", "containerDisplay", "==", "'contents'", ")", ")", "{", "return", "false", ";", "}", "// An absolute-positioned element cannot overflow a static-positioned one.", "if", "(", "position", "==", "'absolute'", "&&", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "container", ",", "'position'", ")", "==", "'static'", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "}" ]

[ "Return", "the", "closest", "ancestor", "that", "the", "given", "element", "may", "overflow", "." ]

[ "function", "getOverflowStyles", "(", "e", ")", "{", "// When the <html> element has an overflow style of 'visible', it assumes", "// the overflow style of the body, and the body is really overflow:visible.", "var", "overflowElem", "=", "e", ";", "if", "(", "htmlOverflowStyle", "==", "'visible'", ")", "{", "// Note: bodyElem will be null/undefined in SVG documents.", "if", "(", "e", "==", "htmlElem", "&&", "bodyElem", ")", "{", "overflowElem", "=", "bodyElem", ";", "}", "else", "if", "(", "e", "==", "bodyElem", ")", "{", "return", "{", "x", ":", "'visible'", ",", "y", ":", "'visible'", "}", ";", "}", "}", "var", "overflow", "=", "{", "x", ":", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "overflowElem", ",", "'overflow-x'", ")", ",", "y", ":", "bot", ".", "dom", ".", "getEffectiveStyle", "(", "overflowElem", ",", "'overflow-y'", ")", "}", ";", "// The <html> element cannot have a genuine 'visible' overflow style,", "// because the viewport can't expand; 'visible' is really 'auto'.", "if", "(", "e", "==", "htmlElem", ")", "{", "overflow", ".", "x", "=", "overflow", ".", "x", "==", "'visible'", "?", "'auto'", ":", "overflow", ".", "x", ";", "overflow", ".", "y", "=", "overflow", ".", "y", "==", "'visible'", "?", "'auto'", ":", "overflow", ".", "y", ";", "}", "return", "overflow", ";", "}" ]

[ "Return", "the", "x", "and", "y", "overflow", "styles", "for", "the", "given", "element", "." ]

[ "function", "getScroll", "(", "e", ")", "{", "if", "(", "e", "==", "htmlElem", ")", "{", "return", "new", "goog", ".", "dom", ".", "DomHelper", "(", "ownerDoc", ")", ".", "getDocumentScroll", "(", ")", ";", "}", "else", "{", "return", "new", "goog", ".", "math", ".", "Coordinate", "(", "e", ".", "scrollLeft", ",", "e", ".", "scrollTop", ")", ";", "}", "}" ]

[ "Returns", "the", "scroll", "offset", "of", "the", "given", "element", "." ]

[ "function", "(", ")", "{", "var", "obj", "=", "{", "}", ";", "for", "(", "var", "type", "in", "this", ".", "prefs_", ")", "{", "if", "(", "this", ".", "prefs_", ".", "hasOwnProperty", "(", "type", ")", ")", "{", "obj", "[", "type", "]", "=", "this", ".", "prefs_", "[", "type", "]", ".", "name", ";", "}", "}", "return", "obj", ";", "}" ]

[ "Converts", "this", "instance", "to", "its", "JSON", "representation", "." ]

[ "function", "unwrapNode", "(", "aNode", ")", "{", "var", "node", "=", "aNode", ";", "if", "(", "node", ")", "{", "// unwrap is not available on older branches (3.5 and 3.6) - Bug 533596", "if", "(", "\"unwrap\"", "in", "XPCNativeWrapper", ")", "{", "node", "=", "XPCNativeWrapper", ".", "unwrap", "(", "node", ")", ";", "}", "else", "if", "(", "\"wrappedJSObject\"", "in", "node", ")", "{", "node", "=", "node", ".", "wrappedJSObject", ";", "}", "}", "return", "node", ";", "}" ]

[ "Unwraps", "a", "node", "which", "is", "wrapped", "into", "a", "XPCNativeWrapper", "or", "XrayWrapper" ]

[ "function", "DOMWalker_walk", "(", "ids", ",", "root", ",", "waitFunction", ")", "{", "if", "(", "typeof", "waitFunction", "==", "'function'", ")", "this", ".", "_controller", ".", "waitFor", "(", "waitFunction", "(", ")", ")", ";", "if", "(", "!", "root", ")", "root", "=", "this", ".", "_controller", ".", "window", ".", "document", ".", "documentElement", ";", "var", "resultsArray", "=", "this", ".", "_walk", "(", "root", ")", ";", "if", "(", "typeof", "this", ".", "_callbackResults", "==", "'function'", ")", "this", ".", "_callbackResults", "(", "this", ".", "_controller", ",", "resultsArray", ")", ";", "if", "(", "ids", ")", "this", ".", "_prepareTargetWindows", "(", "ids", ")", ";", "}" ]

[ "The", "main", "DOMWalker", "function", "." ]

[ "function", "DOMWalker_getNode", "(", "idSet", ")", "{", "var", "doc", "=", "this", ".", "_controller", ".", "window", ".", "document", ";", "// QuerySelector seems to be unusuale for id's in this case:", "// https://developer.mozilla.org/En/Code_snippets/QuerySelector", "switch", "(", "idSet", ".", "getBy", ")", "{", "case", "DOMWalker", ".", "GET_BY_ID", ":", "return", "doc", ".", "getElementById", "(", "idSet", "[", "idSet", ".", "getBy", "]", ")", ";", "case", "DOMWalker", ".", "GET_BY_SELECTOR", ":", "return", "doc", ".", "querySelector", "(", "idSet", "[", "idSet", ".", "getBy", "]", ")", ";", "default", ":", "throw", "new", "Error", "(", "\"Not supported getBy-attribute: \"", "+", "idSet", ".", "getBy", ")", ";", "}", "}" ]

[ "Retrieves", "and", "returns", "a", "wanted", "node", "based", "on", "the", "provided", "identification", "set", "." ]

[ "function", "DOMWalker_prepareTargetWindows", "(", "ids", ")", "{", "var", "doc", "=", "this", ".", "_controller", ".", "window", ".", "document", ";", "// Go through all the provided ids", "for", "(", "var", "i", "=", "0", ";", "i", "<", "ids", ".", "length", ";", "i", "++", ")", "{", "var", "node", "=", "this", ".", "_getNode", "(", "ids", "[", "i", "]", ")", ";", "// Go further only, if the needed element exists", "if", "(", "node", ")", "{", "var", "idSet", "=", "ids", "[", "i", "]", ";", "// Decide if what we want to open is a new normal/modal window or if it", "// will be opened in the current window.", "switch", "(", "idSet", ".", "target", ")", "{", "case", "DOMWalker", ".", "WINDOW_CURRENT", ":", "this", ".", "_processNode", "(", "node", ",", "idSet", ")", ";", "break", ";", "case", "DOMWalker", ".", "WINDOW_MODAL", ":", "// Modal windows have to be able to access that informations", "var", "modalInfos", "=", "{", "ids", ":", "idSet", ".", "subContent", ",", "callbackFilter", ":", "this", ".", "_callbackFilter", ",", "callbackNodeTest", ":", "this", ".", "_callbackNodeTest", ",", "callbackResults", ":", "this", ".", "_callbackResults", ",", "waitFunction", ":", "idSet", ".", "waitFunction", "}", "persisted", ".", "modalInfos", "=", "modalInfos", ";", "var", "md", "=", "new", "modalDialog", ".", "modalDialog", "(", "this", ".", "_controller", ".", "window", ")", ";", "md", ".", "start", "(", "this", ".", "_modalWindowHelper", ")", ";", "this", ".", "_processNode", "(", "node", ",", "idSet", ")", ";", "md", ".", "waitForDialog", "(", ")", ";", "break", ";", "case", "DOMWalker", ".", "WINDOW_NEW", ":", "this", ".", "_processNode", "(", "node", ",", "idSet", ")", ";", "// Get the new non-modal window controller", "var", "controller", "=", "utils", ".", "handleWindow", "(", "'title'", ",", "idSet", ".", "title", ",", "false", ",", "true", ")", ";", "// Start a new DOMWalker instance", "let", "domWalker", "=", "new", "DOMWalker", "(", "controller", ",", "this", ".", "_callbackFilter", ",", "this", ".", "_callbackNodeTest", ",", "this", ".", "_callbackResults", ")", ";", "domWalker", ".", "walk", "(", "idSet", ".", "subContent", ",", "controller", ".", "window", ".", "document", ".", "documentElement", ",", "idSet", ".", "waitFunction", ")", ";", "// Close the window", "controller", ".", "window", ".", "close", "(", ")", ";", "break", ";", "default", ":", "throw", "new", "Error", "(", "\"Node does not exist: \"", "+", "ids", "[", "i", "]", "[", "ids", "[", "i", "]", ".", "getBy", "]", ")", ";", "}", "}", "}", "}" ]

[ "Main", "entry", "point", "to", "open", "new", "elements", "like", "windows", "tabpanels", "prefpanes", "dialogs" ]

[ "function", "DOMWalker__walk", "(", "root", ")", "{", "if", "(", "!", "root", ".", "childNodes", ")", "throw", "new", "Error", "(", "\"root.childNodes does not exist\"", ")", ";", "var", "collectedResults", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "root", ".", "childNodes", ".", "length", ";", "i", "++", ")", "{", "var", "nodeStatus", "=", "this", ".", "_callbackFilter", "(", "root", ".", "childNodes", "[", "i", "]", ")", ";", "var", "nodeTestResults", "=", "[", "]", ";", "switch", "(", "nodeStatus", ")", "{", "case", "DOMWalker", ".", "FILTER_ACCEPT", ":", "nodeTestResults", "=", "this", ".", "_callbackNodeTest", "(", "root", ".", "childNodes", "[", "i", "]", ")", ";", "collectedResults", "=", "collectedResults", ".", "concat", "(", "nodeTestResults", ")", ";", "// no break here as we have to perform the _walk below too", "case", "DOMWalker", ".", "FILTER_SKIP", ":", "nodeTestResults", "=", "this", ".", "_walk", "(", "root", ".", "childNodes", "[", "i", "]", ")", ";", "break", ";", "default", ":", "break", ";", "}", "collectedResults", "=", "collectedResults", ".", "concat", "(", "nodeTestResults", ")", ";", "}", "return", "collectedResults", ";", "}" ]

[ "DOMWalker_walk", "goes", "recursively", "through", "the", "DOM", "starting", "with", "a", "provided", "root", "-", "node", "." ]

[ "function", "DOMWalker_modalWindowHelper", "(", "controller", ")", "{", "let", "domWalker", "=", "new", "DOMWalker", "(", "controller", ",", "persisted", ".", "modalInfos", ".", "callbackFilter", ",", "persisted", ".", "modalInfos", ".", "callbackNodeTest", ",", "persisted", ".", "modalInfos", ".", "callbackResults", ")", ";", "domWalker", ".", "walk", "(", "persisted", ".", "modalInfos", ".", "ids", ",", "controller", ".", "window", ".", "document", ".", "documentElement", ",", "persisted", ".", "modalInfos", ".", "waitFunction", ")", ";", "delete", "persisted", ".", "modalInfos", ";", "controller", ".", "window", ".", "close", "(", ")", ";", "}" ]

[ "Callback", "function", "to", "handle", "new", "windows" ]

[ "function", "nodeCollector_filter", "(", "aCallback", ",", "aThisObject", ")", "{", "if", "(", "!", "aCallback", ")", "throw", "new", "Error", "(", "arguments", ".", "callee", ".", "name", "+", "\": No callback specified\"", ")", ";", "this", ".", "nodes", "=", "Array", ".", "filter", "(", "this", ".", "nodes", ",", "aCallback", ",", "aThisObject", ")", ";", "return", "this", ";", "}" ]

[ "Filter", "nodes", "given", "by", "the", "specified", "callback", "function" ]

[ "function", "nodeCollector_filterByDOMProperty", "(", "aProperty", ",", "aValue", ")", "{", "return", "this", ".", "filter", "(", "function", "(", "node", ")", "{", "if", "(", "aProperty", "&&", "aValue", ")", "return", "node", ".", "getAttribute", "(", "aProperty", ")", "==", "aValue", ";", "else", "if", "(", "aProperty", ")", "return", "node", ".", "hasAttribute", "(", "aProperty", ")", ";", "else", "return", "true", ";", "}", ")", ";", "}" ]

[ "Filter", "nodes", "by", "DOM", "property", "and", "its", "value" ]

[ "function", "nodeCollector_filterByJSProperty", "(", "aProperty", ",", "aValue", ")", "{", "return", "this", ".", "filter", "(", "function", "(", "node", ")", "{", "if", "(", "aProperty", "&&", "aValue", ")", "return", "node", ".", "aProperty", "==", "aValue", ";", "else", "if", "(", "aProperty", ")", "return", "node", ".", "aProperty", "!==", "undefined", ";", "else", "return", "true", ";", "}", ")", ";", "}" ]

[ "Filter", "nodes", "by", "JS", "property", "and", "its", "value" ]

[ "function", "nodeCollector_queryAnonymousNodes", "(", "aAttribute", ",", "aValue", ")", "{", "var", "node", "=", "this", ".", "_document", ".", "getAnonymousElementByAttribute", "(", "this", ".", "_root", ",", "aAttribute", ",", "aValue", ")", ";", "this", ".", "nodes", "=", "node", "?", "[", "node", "]", ":", "[", "]", ";", "return", "this", ";", "}" ]

[ "Find", "anonymouse", "nodes", "with", "the", "specified", "attribute", "and", "value" ]

[ "function", "stopWithHelp", "(", "...", "msgs", ")", "{", "utils", ".", "header", "(", ")", "utils", ".", "error", "(", "...", "msgs", ")", "commands", ".", "help", ".", "forCommand", "(", "commands", ".", "build", ")", "utils", ".", "die", "(", ")", "}" ]

[ "Prints", "the", "error", "message", "and", "help", "for", "this", "command", "then", "stops", "the", "process", "." ]

[ "function", "buildToStdout", "(", "compileOptions", ")", "{", "return", "compile", "(", "compileOptions", ")", ".", "then", "(", "result", "=>", "process", ".", "stdout", ".", "write", "(", "result", ".", "css", ")", ")", "}" ]

[ "Compiles", "CSS", "file", "and", "writes", "it", "to", "stdout", "." ]

[ "function", "buildToFile", "(", "compileOptions", ",", "startTime", ")", "{", "utils", ".", "header", "(", ")", "utils", ".", "log", "(", ")", "utils", ".", "log", "(", "emoji", ".", "go", ",", "'Building...'", ",", "chalk", ".", "bold", ".", "cyan", "(", "compileOptions", ".", "inputFile", ")", ")", "return", "compile", "(", "compileOptions", ")", ".", "then", "(", "result", "=>", "{", "utils", ".", "writeFile", "(", "compileOptions", ".", "outputFile", ",", "result", ".", "css", ")", "const", "prettyTime", "=", "prettyHrtime", "(", "process", ".", "hrtime", "(", "startTime", ")", ")", "utils", ".", "log", "(", ")", "utils", ".", "log", "(", "emoji", ".", "yes", ",", "'Finished in'", ",", "chalk", ".", "bold", ".", "magenta", "(", "prettyTime", ")", ")", "utils", ".", "log", "(", "emoji", ".", "pack", ",", "'Size:'", ",", "chalk", ".", "bold", ".", "magenta", "(", "bytes", "(", "result", ".", "css", ".", "length", ")", ")", ")", "utils", ".", "log", "(", "emoji", ".", "disk", ",", "'Saved to'", ",", "chalk", ".", "bold", ".", "cyan", "(", "compileOptions", ".", "outputFile", ")", ")", "utils", ".", "footer", "(", ")", "}", ")", "}" ]

[ "Compiles", "CSS", "file", "and", "writes", "it", "to", "a", "file", "." ]

[ "function", "computeControlPoint", "(", "source", ",", "target", ",", "direction", ",", "offset", ")", "{", "const", "midPoint", "=", "[", "(", "source", "[", "0", "]", "+", "target", "[", "0", "]", ")", "/", "2", ",", "(", "source", "[", "1", "]", "+", "target", "[", "1", "]", ")", "/", "2", "]", ";", "const", "dx", "=", "target", "[", "0", "]", "-", "source", "[", "0", "]", ";", "const", "dy", "=", "target", "[", "1", "]", "-", "source", "[", "1", "]", ";", "const", "normal", "=", "[", "dy", ",", "-", "dx", "]", ";", "const", "length", "=", "Math", ".", "sqrt", "(", "Math", ".", "pow", "(", "normal", "[", "0", "]", ",", "2.0", ")", "+", "Math", ".", "pow", "(", "normal", "[", "1", "]", ",", "2.0", ")", ")", ";", "const", "normalized", "=", "[", "normal", "[", "0", "]", "/", "length", ",", "normal", "[", "1", "]", "/", "length", "]", ";", "return", "[", "midPoint", "[", "0", "]", "+", "normalized", "[", "0", "]", "*", "offset", "*", "direction", ",", "midPoint", "[", "1", "]", "+", "normalized", "[", "1", "]", "*", "offset", "*", "direction", "]", ";", "}" ]

[ "A", "helper", "function", "to", "compute", "the", "control", "point", "of", "a", "quadratic", "bezier", "curve" ]

[ "function", "layoutGraph", "(", "graph", ")", "{", "// create a map for referencing node position by node id.", "const", "nodePositionMap", "=", "graph", ".", "nodes", ".", "reduce", "(", "(", "res", ",", "node", ")", "=>", "{", "res", "[", "node", ".", "id", "]", "=", "node", ".", "position", ";", "return", "res", ";", "}", ",", "{", "}", ")", ";", "// bucket edges between the same source/target node pairs.", "const", "nodePairs", "=", "graph", ".", "edges", ".", "reduce", "(", "(", "res", ",", "edge", ")", "=>", "{", "const", "nodes", "=", "[", "edge", ".", "sourceId", ",", "edge", ".", "targetId", "]", ";", "// sort the node ids to count the edges with the same pair", "// but different direction (a -> b or b -> a)", "const", "pairId", "=", "nodes", ".", "sort", "(", ")", ".", "toString", "(", ")", ";", "// push this edge into the bucket", "if", "(", "!", "res", "[", "pairId", "]", ")", "{", "res", "[", "pairId", "]", "=", "[", "edge", "]", ";", "}", "else", "{", "res", "[", "pairId", "]", ".", "push", "(", "edge", ")", ";", "}", "return", "res", ";", "}", ",", "{", "}", ")", ";", "// start to create curved edges", "const", "unitOffset", "=", "30", ";", "const", "layoutEdges", "=", "Object", ".", "keys", "(", "nodePairs", ")", ".", "reduce", "(", "(", "res", ",", "pairId", ")", "=>", "{", "const", "edges", "=", "nodePairs", "[", "pairId", "]", ";", "const", "curved", "=", "edges", ".", "length", ">", "1", ";", "// curve line is directional, pairId is a list of sorted node ids.", "const", "nodeIds", "=", "pairId", ".", "split", "(", "','", ")", ";", "const", "curveSourceId", "=", "nodeIds", "[", "0", "]", ";", "const", "curveTargetId", "=", "nodeIds", "[", "1", "]", ";", "// generate new edges with layout information", "const", "newEdges", "=", "edges", ".", "map", "(", "(", "e", ",", "idx", ")", "=>", "{", "// curve direction (1 or -1)", "const", "direction", "=", "idx", "%", "2", "?", "1", ":", "-", "1", ";", "// straight line if there's only one edge between this two nodes.", "const", "offset", "=", "curved", "?", "(", "1", "+", "Math", ".", "floor", "(", "idx", "/", "2", ")", ")", "*", "unitOffset", ":", "0", ";", "return", "{", "...", "e", ",", "source", ":", "nodePositionMap", "[", "e", ".", "sourceId", "]", ",", "target", ":", "nodePositionMap", "[", "e", ".", "targetId", "]", ",", "controlPoint", ":", "computeControlPoint", "(", "nodePositionMap", "[", "curveSourceId", "]", ",", "nodePositionMap", "[", "curveTargetId", "]", ",", "direction", ",", "offset", ")", "}", ";", "}", ")", ";", "return", "res", ".", "concat", "(", "newEdges", ")", ";", "}", ",", "[", "]", ")", ";", "return", "{", "nodes", ":", "graph", ".", "nodes", ",", "edges", ":", "layoutEdges", "}", ";", "}" ]

[ "A", "helper", "function", "to", "generate", "a", "graph", "with", "curved", "edges", "." ]

[ "function", "createCanvas", "(", "props", ")", "{", "let", "{", "container", "=", "document", ".", "body", "}", "=", "props", ";", "if", "(", "typeof", "container", "===", "'string'", ")", "{", "container", "=", "document", ".", "getElementById", "(", "container", ")", ";", "}", "if", "(", "!", "container", ")", "{", "throw", "Error", "(", "'Deck: container not found'", ")", ";", "}", "// Add DOM elements", "const", "containerStyle", "=", "window", ".", "getComputedStyle", "(", "container", ")", ";", "if", "(", "containerStyle", ".", "position", "===", "'static'", ")", "{", "container", ".", "style", ".", "position", "=", "'relative'", ";", "}", "const", "mapCanvas", "=", "document", ".", "createElement", "(", "'div'", ")", ";", "container", ".", "appendChild", "(", "mapCanvas", ")", ";", "Object", ".", "assign", "(", "mapCanvas", ".", "style", ",", "CANVAS_STYLE", ")", ";", "const", "deckCanvas", "=", "document", ".", "createElement", "(", "'canvas'", ")", ";", "container", ".", "appendChild", "(", "deckCanvas", ")", ";", "Object", ".", "assign", "(", "deckCanvas", ".", "style", ",", "CANVAS_STYLE", ")", ";", "return", "{", "container", ",", "mapCanvas", ",", "deckCanvas", "}", ";", "}" ]

[ "Create", "canvas", "elements", "for", "map", "and", "deck" ]

[ "function", "getGPUAggregationParams", "(", "{", "boundingBox", ",", "cellSize", ",", "worldOrigin", "}", ")", "{", "const", "{", "yMin", ",", "yMax", ",", "xMin", ",", "xMax", "}", "=", "boundingBox", ";", "// NOTE: this alignment will match grid cell boundaries with existing CPU implementation", "// this gurantees identical aggregation results when switching between CPU and GPU aggregation.", "// Also gurantees same cell boundaries, when overlapping between two different layers (like ScreenGrid and Contour)", "// We first move worldOrigin to [0, 0], align the lower bounding box , then move worldOrigin to its original value.", "const", "originX", "=", "alignToCell", "(", "xMin", "-", "worldOrigin", "[", "0", "]", ",", "cellSize", "[", "0", "]", ")", "+", "worldOrigin", "[", "0", "]", ";", "const", "originY", "=", "alignToCell", "(", "yMin", "-", "worldOrigin", "[", "1", "]", ",", "cellSize", "[", "1", "]", ")", "+", "worldOrigin", "[", "1", "]", ";", "// Setup transformation matrix so that every point is in +ve range", "const", "gridTransformMatrix", "=", "new", "Matrix4", "(", ")", ".", "translate", "(", "[", "-", "1", "*", "originX", ",", "-", "1", "*", "originY", ",", "0", "]", ")", ";", "// const cellSize = [gridOffset.xOffset, gridOffset.yOffset];", "const", "gridOrigin", "=", "[", "originX", ",", "originY", "]", ";", "const", "width", "=", "xMax", "-", "xMin", "+", "cellSize", "[", "0", "]", ";", "const", "height", "=", "yMax", "-", "yMin", "+", "cellSize", "[", "1", "]", ";", "const", "gridSize", "=", "[", "Math", ".", "ceil", "(", "width", "/", "cellSize", "[", "0", "]", ")", ",", "Math", ".", "ceil", "(", "height", "/", "cellSize", "[", "1", "]", ")", "]", ";", "return", "{", "gridOrigin", ",", "gridSize", ",", "width", ",", "height", ",", "gridTransformMatrix", "}", ";", "}" ]

[ "Calculate", "grid", "parameters" ]

[ "function", "resizeImage", "(", "ctx", ",", "imageData", ",", "width", ",", "height", ")", "{", "const", "{", "naturalWidth", ",", "naturalHeight", "}", "=", "imageData", ";", "if", "(", "width", "===", "naturalWidth", "&&", "height", "===", "naturalHeight", ")", "{", "return", "imageData", ";", "}", "ctx", ".", "canvas", ".", "height", "=", "height", ";", "ctx", ".", "canvas", ".", "width", "=", "width", ";", "ctx", ".", "clearRect", "(", "0", ",", "0", ",", "ctx", ".", "canvas", ".", "width", ",", "ctx", ".", "canvas", ".", "height", ")", ";", "// image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight", "ctx", ".", "drawImage", "(", "imageData", ",", "0", ",", "0", ",", "naturalWidth", ",", "naturalHeight", ",", "0", ",", "0", ",", "width", ",", "height", ")", ";", "return", "ctx", ".", "canvas", ";", "}" ]

[ "resize", "image", "to", "given", "width", "and", "height" ]

[ "function", "buildRowMapping", "(", "mapping", ",", "columns", ",", "yOffset", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "columns", ".", "length", ";", "i", "++", ")", "{", "const", "{", "icon", ",", "xOffset", "}", "=", "columns", "[", "i", "]", ";", "const", "id", "=", "getIconId", "(", "icon", ")", ";", "mapping", "[", "id", "]", "=", "Object", ".", "assign", "(", "{", "}", ",", "icon", ",", "{", "x", ":", "xOffset", ",", "y", ":", "yOffset", "}", ")", ";", "}", "}" ]

[ "traverse", "icons", "in", "a", "row", "of", "icon", "atlas", "extend", "each", "icon", "with", "left", "-", "top", "coordinates" ]

[ "function", "resizeTexture", "(", "texture", ",", "width", ",", "height", ")", "{", "const", "oldWidth", "=", "texture", ".", "width", ";", "const", "oldHeight", "=", "texture", ".", "height", ";", "const", "oldPixels", "=", "readPixelsToBuffer", "(", "texture", ",", "{", "}", ")", ";", "texture", ".", "resize", "(", "{", "width", ",", "height", "}", ")", ";", "texture", ".", "setSubImageData", "(", "{", "data", ":", "oldPixels", ",", "x", ":", "0", ",", "y", ":", "height", "-", "oldHeight", ",", "width", ":", "oldWidth", ",", "height", ":", "oldHeight", ",", "parameters", ":", "DEFAULT_TEXTURE_PARAMETERS", "}", ")", ";", "texture", ".", "generateMipmap", "(", ")", ";", "oldPixels", ".", "delete", "(", ")", ";", "return", "texture", ";", "}" ]

[ "resize", "texture", "without", "losing", "original", "data" ]

[ "function", "_pointsToGridHashing", "(", "points", "=", "[", "]", ",", "cellSize", ",", "getPosition", ")", "{", "// find the geometric center of sample points", "let", "latMin", "=", "Infinity", ";", "let", "latMax", "=", "-", "Infinity", ";", "let", "pLat", ";", "for", "(", "const", "pt", "of", "points", ")", "{", "pLat", "=", "getPosition", "(", "pt", ")", "[", "1", "]", ";", "if", "(", "Number", ".", "isFinite", "(", "pLat", ")", ")", "{", "latMin", "=", "pLat", "<", "latMin", "?", "pLat", ":", "latMin", ";", "latMax", "=", "pLat", ">", "latMax", "?", "pLat", ":", "latMax", ";", "}", "}", "const", "centerLat", "=", "(", "latMin", "+", "latMax", ")", "/", "2", ";", "const", "gridOffset", "=", "_calculateGridLatLonOffset", "(", "cellSize", ",", "centerLat", ")", ";", "if", "(", "gridOffset", ".", "xOffset", "<=", "0", "||", "gridOffset", ".", "yOffset", "<=", "0", ")", "{", "return", "{", "gridHash", ":", "{", "}", ",", "gridOffset", "}", ";", "}", "// calculate count per cell", "const", "gridHash", "=", "{", "}", ";", "for", "(", "const", "pt", "of", "points", ")", "{", "const", "[", "lng", ",", "lat", "]", "=", "getPosition", "(", "pt", ")", ";", "if", "(", "Number", ".", "isFinite", "(", "lat", ")", "&&", "Number", ".", "isFinite", "(", "lng", ")", ")", "{", "const", "latIdx", "=", "Math", ".", "floor", "(", "(", "lat", "+", "90", ")", "/", "gridOffset", ".", "yOffset", ")", ";", "const", "lonIdx", "=", "Math", ".", "floor", "(", "(", "lng", "+", "180", ")", "/", "gridOffset", ".", "xOffset", ")", ";", "const", "key", "=", "`", "${", "latIdx", "}", "${", "lonIdx", "}", "`", ";", "gridHash", "[", "key", "]", "=", "gridHash", "[", "key", "]", "||", "{", "count", ":", "0", ",", "points", ":", "[", "]", "}", ";", "gridHash", "[", "key", "]", ".", "count", "+=", "1", ";", "gridHash", "[", "key", "]", ".", "points", ".", "push", "(", "pt", ")", ";", "}", "}", "return", "{", "gridHash", ",", "gridOffset", "}", ";", "}" ]

[ "Project", "points", "into", "each", "cell", "return", "a", "hash", "table", "of", "cells" ]

[ "function", "diffDataProps", "(", "props", ",", "oldProps", ")", "{", "if", "(", "oldProps", "===", "null", ")", "{", "return", "'oldProps is null, initial diff'", ";", "}", "// Support optional app defined comparison of data", "const", "{", "dataComparator", "}", "=", "props", ";", "if", "(", "dataComparator", ")", "{", "if", "(", "!", "dataComparator", "(", "props", ".", "data", ",", "oldProps", ".", "data", ")", ")", "{", "return", "'Data comparator detected a change'", ";", "}", "// Otherwise, do a shallow equal on props", "}", "else", "if", "(", "props", ".", "data", "!==", "oldProps", ".", "data", ")", "{", "return", "'A new data container was supplied'", ";", "}", "return", "null", ";", "}" ]

[ "The", "comparison", "of", "the", "data", "prop", "requires", "special", "handling", "the", "dataComparator", "should", "be", "used", "if", "supplied" ]

[ "function", "diffUpdateTriggers", "(", "props", ",", "oldProps", ")", "{", "if", "(", "oldProps", "===", "null", ")", "{", "return", "'oldProps is null, initial diff'", ";", "}", "// If the 'all' updateTrigger fires, ignore testing others", "if", "(", "'all'", "in", "props", ".", "updateTriggers", ")", "{", "const", "diffReason", "=", "diffUpdateTrigger", "(", "props", ",", "oldProps", ",", "'all'", ")", ";", "if", "(", "diffReason", ")", "{", "return", "{", "all", ":", "true", "}", ";", "}", "}", "const", "triggerChanged", "=", "{", "}", ";", "let", "reason", "=", "false", ";", "// If the 'all' updateTrigger didn't fire, need to check all others", "for", "(", "const", "triggerName", "in", "props", ".", "updateTriggers", ")", "{", "if", "(", "triggerName", "!==", "'all'", ")", "{", "const", "diffReason", "=", "diffUpdateTrigger", "(", "props", ",", "oldProps", ",", "triggerName", ")", ";", "if", "(", "diffReason", ")", "{", "triggerChanged", "[", "triggerName", "]", "=", "true", ";", "reason", "=", "triggerChanged", ";", "}", "}", "}", "return", "reason", ";", "}" ]

[ "Checks", "if", "any", "update", "triggers", "have", "changed", "also", "calls", "callback", "to", "invalidate", "attributes", "accordingly", "." ]

[ "function", "getPropsPrototypeAndTypes", "(", "componentClass", ")", "{", "const", "props", "=", "getOwnProperty", "(", "componentClass", ",", "'_mergedDefaultProps'", ")", ";", "if", "(", "props", ")", "{", "return", "{", "defaultProps", ":", "props", ",", "propTypes", ":", "getOwnProperty", "(", "componentClass", ",", "'_propTypes'", ")", ",", "deprecatedProps", ":", "getOwnProperty", "(", "componentClass", ",", "'_deprecatedProps'", ")", "}", ";", "}", "return", "createPropsPrototypeAndTypes", "(", "componentClass", ")", ";", "}" ]

[ "Return", "precalculated", "defaultProps", "and", "propType", "objects", "if", "available", "build", "them", "if", "needed" ]

[ "function", "createPropsPrototypeAndTypes", "(", "componentClass", ")", "{", "const", "parent", "=", "componentClass", ".", "prototype", ";", "if", "(", "!", "parent", ")", "{", "return", "{", "defaultProps", ":", "{", "}", "}", ";", "}", "const", "parentClass", "=", "Object", ".", "getPrototypeOf", "(", "componentClass", ")", ";", "const", "parentPropDefs", "=", "(", "parent", "&&", "getPropsPrototypeAndTypes", "(", "parentClass", ")", ")", "||", "null", ";", "// Parse propTypes from Component.defaultProps", "const", "componentDefaultProps", "=", "getOwnProperty", "(", "componentClass", ",", "'defaultProps'", ")", "||", "{", "}", ";", "const", "componentPropDefs", "=", "parsePropTypes", "(", "componentDefaultProps", ")", ";", "// Create a merged type object", "const", "propTypes", "=", "Object", ".", "assign", "(", "{", "}", ",", "parentPropDefs", "&&", "parentPropDefs", ".", "propTypes", ",", "componentPropDefs", ".", "propTypes", ")", ";", "// Create any necessary property descriptors and create the default prop object", "// Assign merged default props", "const", "defaultProps", "=", "createPropsPrototype", "(", "componentPropDefs", ".", "defaultProps", ",", "parentPropDefs", "&&", "parentPropDefs", ".", "defaultProps", ",", "propTypes", ",", "componentClass", ")", ";", "// Create a map for prop whose default value is a callback", "const", "deprecatedProps", "=", "Object", ".", "assign", "(", "{", "}", ",", "parentPropDefs", "&&", "parentPropDefs", ".", "deprecatedProps", ",", "componentPropDefs", ".", "deprecatedProps", ")", ";", "// Store the precalculated props", "componentClass", ".", "_mergedDefaultProps", "=", "defaultProps", ";", "componentClass", ".", "_propTypes", "=", "propTypes", ";", "componentClass", ".", "_deprecatedProps", "=", "deprecatedProps", ";", "return", "{", "propTypes", ",", "defaultProps", ",", "deprecatedProps", "}", ";", "}" ]

[ "Build", "defaultProps", "and", "propType", "objects", "by", "walking", "component", "prototype", "chain" ]

[ "function", "createPropsPrototype", "(", "props", ",", "parentProps", ",", "propTypes", ",", "componentClass", ")", "{", "const", "defaultProps", "=", "Object", ".", "create", "(", "null", ")", ";", "Object", ".", "assign", "(", "defaultProps", ",", "parentProps", ",", "props", ")", ";", "// Avoid freezing `id` prop", "const", "id", "=", "getComponentName", "(", "componentClass", ")", ";", "delete", "props", ".", "id", ";", "// Add getters/setters for async prop properties", "Object", ".", "defineProperties", "(", "defaultProps", ",", "{", "// `id` is treated specially because layer might need to override it", "id", ":", "{", "configurable", ":", "false", ",", "writable", ":", "true", ",", "value", ":", "id", "}", "}", ")", ";", "// Add getters/setters for async prop properties", "addAsyncPropsToPropPrototype", "(", "defaultProps", ",", "propTypes", ")", ";", "return", "defaultProps", ";", "}" ]

[ "Builds", "a", "pre", "-", "merged", "default", "props", "object", "that", "component", "props", "can", "inherit", "from" ]

[ "function", "addAsyncPropsToPropPrototype", "(", "defaultProps", ",", "propTypes", ")", "{", "const", "defaultValues", "=", "{", "}", ";", "const", "descriptors", "=", "{", "// Default \"resolved\" values for async props, returned if value not yet resolved/set.", "_asyncPropDefaultValues", ":", "{", "enumerable", ":", "false", ",", "value", ":", "defaultValues", "}", ",", "// Shadowed object, just to make sure \"early indexing\" into the instance does not fail", "_asyncPropOriginalValues", ":", "{", "enumerable", ":", "false", ",", "value", ":", "{", "}", "}", "}", ";", "// Move async props into shadow values", "for", "(", "const", "propName", "in", "propTypes", ")", "{", "const", "propType", "=", "propTypes", "[", "propName", "]", ";", "const", "{", "name", ",", "value", "}", "=", "propType", ";", "// Note: async is ES7 keyword, can't destructure", "if", "(", "propType", ".", "async", ")", "{", "defaultValues", "[", "name", "]", "=", "value", ";", "descriptors", "[", "name", "]", "=", "getDescriptorForAsyncProp", "(", "name", ",", "value", ")", ";", "}", "}", "Object", ".", "defineProperties", "(", "defaultProps", ",", "descriptors", ")", ";", "}" ]

[ "Create", "descriptors", "for", "overridable", "props" ]

[ "function", "wrapInView", "(", "node", ")", "{", "if", "(", "!", "node", ")", "{", "return", "node", ";", "}", "if", "(", "typeof", "node", "===", "'function'", ")", "{", "// React.Children does not traverse functions.", "// All render callbacks must be protected under a <View>", "return", "createElement", "(", "View", ",", "{", "}", ",", "node", ")", ";", "}", "if", "(", "Array", ".", "isArray", "(", "node", ")", ")", "{", "return", "node", ".", "map", "(", "wrapInView", ")", ";", "}", "if", "(", "inheritsFrom", "(", "node", ".", "type", ",", "View", ")", ")", "{", "return", "node", ";", "}", "return", "node", ";", "}" ]

[ "recursively", "wrap", "render", "callbacks", "in", "View" ]

[ "function", "setTextStyle", "(", "ctx", ",", "fontSize", ")", "{", "ctx", ".", "font", "=", "`", "${", "fontSize", "}", "`", ";", "ctx", ".", "fillStyle", "=", "'#000'", ";", "ctx", ".", "textBaseline", "=", "'top'", ";", "ctx", ".", "textAlign", "=", "'center'", ";", "}" ]

[ "helper", "for", "textMatrixToTexture" ]

[ "function", "time", "(", "priority", ",", "label", ")", "{", "assert", "(", "Number", ".", "isFinite", "(", "priority", ")", ",", "'log priority must be a number'", ")", ";", "if", "(", "priority", "<=", "log", ".", "priority", ")", "{", "// In case the platform doesn't have console.time", "if", "(", "console", ".", "time", ")", "{", "console", ".", "time", "(", "label", ")", ";", "}", "else", "{", "console", ".", "info", "(", "label", ")", ";", "}", "}", "}" ]

[ "Logs", "a", "message", "with", "a", "time" ]

[ "function", "checkForAssertionErrors", "(", "args", ")", "{", "const", "isAssertion", "=", "args", "&&", "args", ".", "length", ">", "0", "&&", "typeof", "args", "[", "0", "]", "===", "'object'", "&&", "args", "[", "0", "]", "!==", "null", "&&", "args", "[", "0", "]", ".", "name", "===", "'AssertionError'", ";", "if", "(", "isAssertion", ")", "{", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "args", ")", ";", "args", ".", "unshift", "(", "`", "${", "args", "[", "0", "]", ".", "message", "}", "`", ")", ";", "}", "return", "args", ";", "}" ]

[ "Assertions", "don", "t", "generate", "standard", "exceptions", "and", "don", "t", "print", "nicely" ]

[ "function", "isNestedRingClosed", "(", "simplePolygon", ")", "{", "// check if first and last vertex are the same", "const", "p0", "=", "simplePolygon", "[", "0", "]", ";", "const", "p1", "=", "simplePolygon", "[", "simplePolygon", ".", "length", "-", "1", "]", ";", "return", "p0", "[", "0", "]", "===", "p1", "[", "0", "]", "&&", "p0", "[", "1", "]", "===", "p1", "[", "1", "]", "&&", "p0", "[", "2", "]", "===", "p1", "[", "2", "]", ";", "}" ]

[ "Check", "if", "a", "simple", "polygon", "is", "a", "closed", "ring" ]

[ "function", "isFlatRingClosed", "(", "positions", ",", "size", ",", "startIndex", ",", "endIndex", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "if", "(", "positions", "[", "startIndex", "+", "i", "]", "!==", "positions", "[", "endIndex", "-", "size", "+", "i", "]", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Check", "if", "a", "simple", "flat", "array", "is", "a", "closed", "ring" ]

[ "function", "copyNestedRing", "(", "target", ",", "targetStartIndex", ",", "simplePolygon", ",", "size", ")", "{", "let", "targetIndex", "=", "targetStartIndex", ";", "const", "len", "=", "simplePolygon", ".", "length", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "for", "(", "let", "j", "=", "0", ";", "j", "<", "size", ";", "j", "++", ")", "{", "target", "[", "targetIndex", "++", "]", "=", "simplePolygon", "[", "i", "]", "[", "j", "]", "||", "0", ";", "}", "}", "if", "(", "!", "isNestedRingClosed", "(", "simplePolygon", ")", ")", "{", "for", "(", "let", "j", "=", "0", ";", "j", "<", "size", ";", "j", "++", ")", "{", "target", "[", "targetIndex", "++", "]", "=", "simplePolygon", "[", "0", "]", "[", "j", "]", "||", "0", ";", "}", "}", "return", "targetIndex", ";", "}" ]

[ "Copy", "a", "simple", "polygon", "coordinates", "into", "a", "flat", "array", "closes", "the", "ring", "if", "needed", "." ]

[ "function", "copyFlatRing", "(", "target", ",", "targetStartIndex", ",", "positions", ",", "size", ",", "srcStartIndex", "=", "0", ",", "srcEndIndex", ")", "{", "srcEndIndex", "=", "srcEndIndex", "||", "positions", ".", "length", ";", "const", "srcLength", "=", "srcEndIndex", "-", "srcStartIndex", ";", "if", "(", "srcLength", "<=", "0", ")", "{", "return", "targetStartIndex", ";", "}", "let", "targetIndex", "=", "targetStartIndex", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "srcLength", ";", "i", "++", ")", "{", "target", "[", "targetIndex", "++", "]", "=", "positions", "[", "srcStartIndex", "+", "i", "]", ";", "}", "if", "(", "!", "isFlatRingClosed", "(", "positions", ",", "size", ",", "srcStartIndex", ",", "srcEndIndex", ")", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "target", "[", "targetIndex", "++", "]", "=", "positions", "[", "srcStartIndex", "+", "i", "]", ";", "}", "}", "return", "targetIndex", ";", "}" ]

[ "Copy", "a", "simple", "flat", "array", "into", "another", "flat", "array", "closes", "the", "ring", "if", "needed", "." ]

[ "function", "getFlatVertexCount", "(", "positions", ",", "size", ",", "startIndex", "=", "0", ",", "endIndex", ")", "{", "endIndex", "=", "endIndex", "||", "positions", ".", "length", ";", "if", "(", "startIndex", ">=", "endIndex", ")", "{", "return", "0", ";", "}", "return", "(", "(", "isFlatRingClosed", "(", "positions", ",", "size", ",", "startIndex", ",", "endIndex", ")", "?", "0", ":", "1", ")", "+", "(", "endIndex", "-", "startIndex", ")", "/", "size", ")", ";", "}" ]

[ "Counts", "the", "number", "of", "vertices", "in", "a", "simple", "flat", "array", "closes", "the", "polygon", "if", "needed", "." ]

[ "function", "activateWidgetExtension", "(", "app", ",", "registry", ")", "{", "registry", ".", "registerWidget", "(", "{", "name", ":", "MODULE_NAME", ",", "version", ":", "MODULE_VERSION", ",", "exports", ":", "{", "DeckGLModel", ",", "DeckGLView", "}", "}", ")", ";", "}" ]

[ "Registers", "the", "widget", "with", "the", "Jupyter", "notebook" ]

[ "function", "getNewChars", "(", "key", ",", "characterSet", ")", "{", "const", "cachedFontAtlas", "=", "cache", ".", "get", "(", "key", ")", ";", "if", "(", "!", "cachedFontAtlas", ")", "{", "return", "characterSet", ";", "}", "const", "newChars", "=", "[", "]", ";", "const", "cachedMapping", "=", "cachedFontAtlas", ".", "mapping", ";", "let", "cachedCharSet", "=", "Object", ".", "keys", "(", "cachedMapping", ")", ";", "cachedCharSet", "=", "new", "Set", "(", "cachedCharSet", ")", ";", "let", "charSet", "=", "characterSet", ";", "if", "(", "charSet", "instanceof", "Array", ")", "{", "charSet", "=", "new", "Set", "(", "charSet", ")", ";", "}", "charSet", ".", "forEach", "(", "char", "=>", "{", "if", "(", "!", "cachedCharSet", ".", "has", "(", "char", ")", ")", "{", "newChars", ".", "push", "(", "char", ")", ";", "}", "}", ")", ";", "return", "newChars", ";", "}" ]

[ "get", "all", "the", "chars", "not", "in", "cache" ]

[ "function", "handleMouseEvent", "(", "deck", ",", "type", ",", "event", ")", "{", "let", "callback", ";", "switch", "(", "type", ")", "{", "case", "'click'", ":", "// Hack: because we do not listen to pointer down, perform picking now", "deck", ".", "_lastPointerDownInfo", "=", "deck", ".", "pickObject", "(", "{", "x", ":", "event", ".", "pixel", ".", "x", ",", "y", ":", "event", ".", "pixel", ".", "y", "}", ")", ";", "callback", "=", "deck", ".", "_onEvent", ";", "break", ";", "case", "'mousemove'", ":", "callback", "=", "deck", ".", "_onPointerMove", ";", "break", ";", "case", "'mouseout'", ":", "callback", "=", "deck", ".", "_onPointerLeave", ";", "break", ";", "default", ":", "return", ";", "}", "callback", "(", "{", "type", ",", "offsetCenter", ":", "event", ".", "pixel", ",", "srcEvent", ":", "event", "}", ")", ";", "}" ]

[ "Triggers", "picking", "on", "a", "mouse", "event" ]

[ "function", "getLevelFromToken", "(", "token", ")", "{", "// leaf level token size is 16. Each 2 bit add a level", "const", "lastHex", "=", "token", ".", "substr", "(", "token", ".", "length", "-", "1", ")", ";", "// a) token = trailing-zero trimmed hex id", "// b) 64 bit hex id - 3 face bit + 60 bits for 30 levels + 1 bit lsb marker", "const", "level", "=", "2", "*", "(", "token", ".", "length", "-", "1", ")", "-", "(", "(", "lastHex", "&", "1", ")", "===", "0", ")", ";", "// c) If lsb bit of last hex digit is zero, we have one more level less of", "return", "level", ";", "}" ]

[ "Given", "a", "S2", "hex", "token", "this", "function", "returns", "cell", "level", "cells", "level", "is", "a", "number", "between", "1", "and", "30" ]

[ "function", "flattenArray", "(", "array", ",", "filter", ",", "map", ",", "result", ")", "{", "let", "index", "=", "-", "1", ";", "while", "(", "++", "index", "<", "array", ".", "length", ")", "{", "const", "value", "=", "array", "[", "index", "]", ";", "if", "(", "Array", ".", "isArray", "(", "value", ")", ")", "{", "flattenArray", "(", "value", ",", "filter", ",", "map", ",", "result", ")", ";", "}", "else", "if", "(", "filter", "(", "value", ")", ")", "{", "result", ".", "push", "(", "map", "(", "value", ")", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Deep", "flattens", "an", "array", ".", "Helper", "to", "flatten", "see", "its", "parameters" ]

[ "function", "sayHello", "(", "call", ",", "callback", ")", "{", "var", "reply", "=", "new", "messages", ".", "HelloReply", "(", ")", ";", "reply", ".", "setMessage", "(", "'Hello '", "+", "call", ".", "request", ".", "getName", "(", ")", ")", ";", "callback", "(", "null", ",", "reply", ")", ";", "}" ]

[ "Implements", "the", "SayHello", "RPC", "method", "." ]

[ "function", "NetProfiler", "(", "options", "=", "{", "}", ")", "{", "if", "(", "!", "(", "this", "instanceof", "NetProfiler", ")", ")", "return", "new", "NetProfiler", "(", "options", ")", "if", "(", "!", "options", ".", "net", ")", "{", "options", ".", "net", "=", "require", "(", "'net'", ")", "}", "this", ".", "net", "=", "options", ".", "net", "this", ".", "proxies", "=", "{", "}", "this", ".", "activeConnections", "=", "[", "]", "this", ".", "startTs", "=", "new", "Date", "(", ")", "/", "1000", "this", ".", "tickMs", "=", "options", ".", "tickMs", "||", "1000", "this", ".", "tickWhenNoneActive", "=", "options", ".", "tickWhenNoneActive", "||", "false", "this", ".", "logPath", "=", "getLogPath", "(", "options", ".", "logPath", ")", "debug", "(", "'logging to '", ",", "this", ".", "logPath", ")", "this", ".", "startProfiling", "(", ")", "}" ]

[ "Tracks", "all", "incoming", "and", "outgoing", "network", "connections", "and", "logs", "a", "timeline", "of", "network", "traffic", "to", "a", "file", "." ]

[ "function", "formErrorText", "(", "info", ",", "msg", ")", "{", "const", "hr", "=", "'----------'", "return", "addPlatformInformation", "(", "info", ")", ".", "then", "(", "(", "obj", ")", "=>", "{", "const", "formatted", "=", "[", "]", "function", "add", "(", "msg", ")", "{", "formatted", ".", "push", "(", "stripIndents", "(", "msg", ")", ")", "}", "add", "(", "`", "${", "obj", ".", "description", "}", "${", "obj", ".", "solution", "}", "`", ")", "if", "(", "msg", ")", "{", "add", "(", "`", "${", "hr", "}", "${", "msg", "}", "`", ")", "}", "add", "(", "`", "${", "hr", "}", "${", "obj", ".", "platform", "}", "`", ")", "if", "(", "obj", ".", "footer", ")", "{", "add", "(", "`", "${", "hr", "}", "${", "obj", ".", "footer", "}", "`", ")", "}", "return", "formatted", ".", "join", "(", "'\\n\\n'", ")", "}", ")", "}" ]

[ "Forms", "nice", "error", "message", "with", "error", "and", "platform", "information", "and", "if", "possible", "a", "way", "to", "solve", "it", ".", "Resolves", "with", "a", "string", "." ]

[ "function", "unknownOption", "(", "flag", ",", "type", "=", "'option'", ")", "{", "if", "(", "this", ".", "_allowUnknownOption", ")", "return", "logger", ".", "error", "(", ")", "logger", ".", "error", "(", "`", "${", "type", "}", "`", ",", "flag", ")", "logger", ".", "error", "(", ")", "this", ".", "outputHelp", "(", ")", "util", ".", "exit", "(", "1", ")", "}" ]

[ "patch", "commander", "method", "called", "when", "a", "user", "passed", "an", "unknown", "option", "we", "want", "to", "print", "help", "for", "the", "current", "command", "and", "exit", "with", "an", "error" ]

[ "function", "applyResource", "(", "resource", ",", "isMethod", ")", "{", "let", "root", ";", "let", "parent", ";", "let", "currentPath", ";", "const", "path", "=", "resource", ".", "path", ".", "replace", "(", "/", "^\\/", "/", ",", "''", ")", ".", "replace", "(", "/", "\\/$", "/", ",", "''", ")", ";", "const", "pathParts", "=", "path", ".", "split", "(", "'/'", ")", ";", "function", "applyNodeResource", "(", "node", ",", "parts", ",", "index", ")", "{", "const", "n", "=", "node", ";", "if", "(", "index", "===", "parts", ".", "length", "-", "1", ")", "{", "n", ".", "name", "=", "resource", ".", "name", ";", "if", "(", "resource", ".", "resourceId", ")", "{", "n", ".", "resourceId", "=", "resource", ".", "resourceId", ";", "if", "(", "_", ".", "every", "(", "predefinedResourceNodes", ",", "(", "iter", ")", "=>", "iter", ".", "path", "!==", "n", ".", "path", ")", ")", "{", "predefinedResourceNodes", ".", "push", "(", "node", ")", ";", "}", "}", "if", "(", "isMethod", "&&", "!", "node", ".", "hasMethod", ")", "{", "n", ".", "hasMethod", "=", "true", ";", "if", "(", "_", ".", "every", "(", "methodNodes", ",", "(", "iter", ")", "=>", "iter", ".", "path", "!==", "n", ".", "path", ")", ")", "{", "methodNodes", ".", "push", "(", "node", ")", ";", "}", "}", "}", "parent", "=", "node", ";", "}", "pathParts", ".", "forEach", "(", "(", "pathPart", ",", "index", ")", "=>", "{", "currentPath", "=", "currentPath", "?", "`", "${", "currentPath", "}", "${", "pathPart", "}", "`", ":", "pathPart", ";", "root", "=", "root", "||", "_", ".", "find", "(", "trees", ",", "(", "node", ")", "=>", "node", ".", "path", "===", "currentPath", ")", ";", "parent", "=", "parent", "||", "root", ";", "let", "node", ";", "if", "(", "parent", ")", "{", "if", "(", "parent", ".", "path", "===", "currentPath", ")", "{", "applyNodeResource", "(", "parent", ",", "pathParts", ",", "index", ")", ";", "return", ";", "}", "else", "if", "(", "parent", ".", "children", ".", "length", ">", "0", ")", "{", "node", "=", "_", ".", "find", "(", "parent", ".", "children", ",", "(", "n", ")", "=>", "n", ".", "path", "===", "currentPath", ")", ";", "if", "(", "node", ")", "{", "applyNodeResource", "(", "node", ",", "pathParts", ",", "index", ")", ";", "return", ";", "}", "}", "}", "node", "=", "{", "path", ":", "currentPath", ",", "pathPart", ",", "parent", ",", "level", ":", "index", ",", "children", ":", "[", "]", ",", "}", ";", "if", "(", "parent", ")", "{", "parent", ".", "children", ".", "push", "(", "node", ")", ";", "}", "if", "(", "!", "root", ")", "{", "root", "=", "node", ";", "trees", ".", "push", "(", "root", ")", ";", "}", "applyNodeResource", "(", "node", ",", "pathParts", ",", "index", ")", ";", "}", ")", ";", "}" ]

[ "organize", "all", "resource", "paths", "into", "N", "-", "ary", "tree" ]

[ "function", "isValidProject", "(", "project", ")", "{", "const", "isValid", "=", "VALID_TRACKING_PROJECTS", ".", "indexOf", "(", "project", ")", "!==", "-", "1", ";", "if", "(", "!", "isValid", ")", "{", "console", ".", "log", "(", "chalk", ".", "red", "(", "'Tracking Error:'", ")", ")", ";", "console", ".", "log", "(", "`", "${", "project", "}", "`", ",", "VALID_TRACKING_PROJECTS", ")", ";", "}", "return", "isValid", ";", "}" ]

[ "Validate", "tracking", "project", "for", "clean", "events" ]

[ "function", "isValidObject", "(", "key", ")", "{", "const", "isValid", "=", "VALID_TRACKING_OBJECTS", ".", "indexOf", "(", "key", ")", "!==", "-", "1", ";", "if", "(", "!", "isValid", ")", "{", "console", ".", "log", "(", "chalk", ".", "red", "(", "'Tracking Error:'", ")", ")", ";", "console", ".", "log", "(", "`", "${", "key", "}", "`", ",", "VALID_TRACKING_OBJECTS", ")", ";", "}", "return", "isValid", ";", "}" ]

[ "Validate", "tracking", "objects", "for", "clean", "events" ]

[ "function", "getPathDirectory", "(", "length", ",", "parts", ")", "{", "if", "(", "!", "parts", ")", "{", "return", "''", ";", "}", "return", "parts", ".", "slice", "(", "length", ")", ".", "filter", "(", "part", "=>", "part", "!==", "''", ")", ".", "join", "(", "path", ".", "sep", ")", ";", "}" ]

[ "Returns", "directory", "path" ]

[ "function", "parseRepoURL", "(", "inputUrl", ")", "{", "if", "(", "!", "inputUrl", ")", "{", "throw", "new", "ServerlessError", "(", "'URL is required'", ")", ";", "}", "const", "url", "=", "URL", ".", "parse", "(", "inputUrl", ".", "replace", "(", "/", "\\/$", "/", ",", "''", ")", ")", ";", "// check if url parameter is a valid url", "if", "(", "!", "url", ".", "host", ")", "{", "throw", "new", "ServerlessError", "(", "'The URL you passed is not a valid URL'", ")", ";", "}", "switch", "(", "url", ".", "hostname", ")", "{", "case", "'github.com'", ":", "{", "return", "parseGitHubURL", "(", "url", ")", ";", "}", "case", "'bitbucket.org'", ":", "{", "return", "parseBitbucketURL", "(", "url", ")", ";", "}", "case", "'gitlab.com'", ":", "{", "return", "parseGitlabURL", "(", "url", ")", ";", "}", "default", ":", "{", "const", "msg", "=", "'The URL you passed is not one of the valid providers: \"GitHub\", \"Bitbucket\", or \"GitLab\".'", ";", "throw", "new", "ServerlessError", "(", "msg", ")", ";", "}", "}", "}" ]

[ "Parse", "URL", "and", "call", "the", "appropriate", "adaptor" ]

[ "function", "set", "(", "key", ",", "value", ")", "{", "let", "config", "=", "getGlobalConfig", "(", ")", ";", "if", "(", "key", "&&", "typeof", "key", "===", "'string'", "&&", "typeof", "value", "!==", "'undefined'", ")", "{", "config", "=", "_", ".", "set", "(", "config", ",", "key", ",", "value", ")", ";", "}", "else", "if", "(", "_", ".", "isObject", "(", "key", ")", ")", "{", "config", "=", "_", ".", "merge", "(", "config", ",", "key", ")", ";", "}", "else", "if", "(", "typeof", "value", "!==", "'undefined'", ")", "{", "config", "=", "_", ".", "merge", "(", "config", ",", "value", ")", ";", "}", "// update config meta", "config", ".", "meta", "=", "config", ".", "meta", "||", "{", "}", ";", "config", ".", "meta", ".", "updated_at", "=", "Math", ".", "round", "(", "+", "new", "Date", "(", ")", "/", "1000", ")", ";", "// write to .serverlessrc file", "writeFileAtomic", ".", "sync", "(", "serverlessrcPath", ",", "JSON", ".", "stringify", "(", "config", ",", "null", ",", "2", ")", ")", ";", "return", "config", ";", "}" ]

[ "set", "global", ".", "serverlessrc", "config", "value", "." ]

[ "function", "findReferences", "(", "root", ",", "value", ")", "{", "const", "visitedObjects", "=", "[", "]", ";", "const", "resourcePaths", "=", "[", "]", ";", "const", "stack", "=", "[", "{", "propValue", ":", "root", ",", "path", ":", "''", "}", "]", ";", "while", "(", "!", "_", ".", "isEmpty", "(", "stack", ")", ")", "{", "const", "property", "=", "stack", ".", "pop", "(", ")", ";", "_", ".", "forOwn", "(", "property", ".", "propValue", ",", "(", "propValue", ",", "key", ")", "=>", "{", "let", "propKey", ";", "if", "(", "_", ".", "isArray", "(", "property", ".", "propValue", ")", ")", "{", "propKey", "=", "`", "${", "key", "}", "`", ";", "}", "else", "{", "propKey", "=", "_", ".", "isEmpty", "(", "property", ".", "path", ")", "?", "`", "${", "key", "}", "`", ":", "`", "${", "key", "}", "`", ";", "}", "if", "(", "propValue", "===", "value", ")", "{", "resourcePaths", ".", "push", "(", "`", "${", "property", ".", "path", "}", "${", "propKey", "}", "`", ")", ";", "}", "else", "if", "(", "_", ".", "isObject", "(", "propValue", ")", ")", "{", "// Prevent circular references", "if", "(", "_", ".", "includes", "(", "visitedObjects", ",", "propValue", ")", ")", "{", "return", ";", "}", "visitedObjects", ".", "push", "(", "propValue", ")", ";", "stack", ".", "push", "(", "{", "propValue", ",", "path", ":", "`", "${", "property", ".", "path", "}", "${", "propKey", "}", "`", "}", ")", ";", "}", "}", ")", ";", "}", "return", "resourcePaths", ";", "}" ]

[ "Find", "all", "objects", "with", "a", "given", "value", "within", "a", "given", "root", "object", ".", "The", "search", "is", "implemented", "non", "-", "recursive", "to", "prevent", "stackoverflows", "and", "will", "do", "a", "complete", "deep", "search", "including", "arrays", "." ]

[ "function", "param", "(", "err", ")", "{", "if", "(", "err", ")", "{", "return", "done", "(", "err", ")", ";", "}", "if", "(", "i", ">=", "keys", ".", "length", ")", "{", "return", "done", "(", ")", ";", "}", "paramIndex", "=", "0", ";", "key", "=", "keys", "[", "i", "++", "]", ";", "name", "=", "key", ".", "name", ";", "paramVal", "=", "req", ".", "params", "[", "name", "]", ";", "paramCallbacks", "=", "params", "[", "name", "]", ";", "paramCalled", "=", "called", "[", "name", "]", ";", "if", "(", "paramVal", "===", "undefined", "||", "!", "paramCallbacks", ")", "{", "return", "param", "(", ")", ";", "}", "// param previously called with same value or error occurred", "if", "(", "paramCalled", "&&", "(", "paramCalled", ".", "match", "===", "paramVal", "||", "(", "paramCalled", ".", "error", "&&", "paramCalled", ".", "error", "!==", "'route'", ")", ")", ")", "{", "// restore value", "req", ".", "params", "[", "name", "]", "=", "paramCalled", ".", "value", ";", "// next param", "return", "param", "(", "paramCalled", ".", "error", ")", ";", "}", "called", "[", "name", "]", "=", "paramCalled", "=", "{", "error", ":", "null", ",", "match", ":", "paramVal", ",", "value", ":", "paramVal", "}", ";", "paramCallback", "(", ")", ";", "}" ]

[ "process", "params", "in", "order", "param", "callbacks", "can", "be", "async" ]

[ "function", "appendMethods", "(", "list", ",", "addition", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "addition", ".", "length", ";", "i", "++", ")", "{", "var", "method", "=", "addition", "[", "i", "]", ";", "if", "(", "list", ".", "indexOf", "(", "method", ")", "===", "-", "1", ")", "{", "list", ".", "push", "(", "method", ")", ";", "}", "}", "}" ]

[ "append", "methods", "to", "a", "list", "of", "methods" ]

[ "function", "getProtohost", "(", "url", ")", "{", "if", "(", "typeof", "url", "!==", "'string'", "||", "url", ".", "length", "===", "0", "||", "url", "[", "0", "]", "===", "'/'", ")", "{", "return", "undefined", "}", "var", "searchIndex", "=", "url", ".", "indexOf", "(", "'?'", ")", "var", "pathLength", "=", "searchIndex", "!==", "-", "1", "?", "searchIndex", ":", "url", ".", "length", "var", "fqdnIndex", "=", "url", ".", "substr", "(", "0", ",", "pathLength", ")", ".", "indexOf", "(", "'://'", ")", "return", "fqdnIndex", "!==", "-", "1", "?", "url", ".", "substr", "(", "0", ",", "url", ".", "indexOf", "(", "'/'", ",", "3", "+", "fqdnIndex", ")", ")", ":", "undefined", "}" ]

[ "Get", "get", "protocol", "+", "host", "for", "a", "URL" ]

[ "function", "gettype", "(", "obj", ")", "{", "var", "type", "=", "typeof", "obj", ";", "if", "(", "type", "!==", "'object'", ")", "{", "return", "type", ";", "}", "// inspect [[Class]] for objects", "return", "toString", ".", "call", "(", "obj", ")", ".", "replace", "(", "objectRegExp", ",", "'$1'", ")", ";", "}" ]

[ "get", "type", "for", "error", "message" ]

[ "function", "sendOptionsResponse", "(", "res", ",", "options", ",", "next", ")", "{", "try", "{", "var", "body", "=", "options", ".", "join", "(", "','", ")", ";", "res", ".", "set", "(", "'Allow'", ",", "body", ")", ";", "res", ".", "send", "(", "body", ")", ";", "}", "catch", "(", "err", ")", "{", "next", "(", "err", ")", ";", "}", "}" ]

[ "send", "an", "OPTIONS", "response" ]

[ "function", "wrap", "(", "old", ",", "fn", ")", "{", "return", "function", "proxy", "(", ")", "{", "var", "args", "=", "new", "Array", "(", "arguments", ".", "length", "+", "1", ")", ";", "args", "[", "0", "]", "=", "old", ";", "for", "(", "var", "i", "=", "0", ",", "len", "=", "arguments", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "args", "[", "i", "+", "1", "]", "=", "arguments", "[", "i", "]", ";", "}", "fn", ".", "apply", "(", "this", ",", "args", ")", ";", "}", ";", "}" ]

[ "wrap", "a", "function" ]

[ "function", "tryRender", "(", "view", ",", "options", ",", "callback", ")", "{", "try", "{", "view", ".", "render", "(", "options", ",", "callback", ")", ";", "}", "catch", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "}" ]

[ "Try", "rendering", "a", "view", "." ]

[ "function", "authenticate", "(", "name", ",", "pass", ",", "fn", ")", "{", "if", "(", "!", "module", ".", "parent", ")", "console", ".", "log", "(", "'authenticating %s:%s'", ",", "name", ",", "pass", ")", ";", "var", "user", "=", "users", "[", "name", "]", ";", "// query the db for the given username", "if", "(", "!", "user", ")", "return", "fn", "(", "new", "Error", "(", "'cannot find user'", ")", ")", ";", "// apply the same algorithm to the POSTed password, applying", "// the hash against the pass / salt, if there is a match we", "// found the user", "hash", "(", "{", "password", ":", "pass", ",", "salt", ":", "user", ".", "salt", "}", ",", "function", "(", "err", ",", "pass", ",", "salt", ",", "hash", ")", "{", "if", "(", "err", ")", "return", "fn", "(", "err", ")", ";", "if", "(", "hash", "===", "user", ".", "hash", ")", "return", "fn", "(", "null", ",", "user", ")", "fn", "(", "new", "Error", "(", "'invalid password'", ")", ")", ";", "}", ")", ";", "}" ]

[ "Authenticate", "using", "our", "plain", "-", "object", "database", "of", "doom!" ]

[ "function", "sendfile", "(", "res", ",", "file", ",", "options", ",", "callback", ")", "{", "var", "done", "=", "false", ";", "var", "streaming", ";", "// request aborted", "function", "onaborted", "(", ")", "{", "if", "(", "done", ")", "return", ";", "done", "=", "true", ";", "var", "err", "=", "new", "Error", "(", "'Request aborted'", ")", ";", "err", ".", "code", "=", "'ECONNABORTED'", ";", "callback", "(", "err", ")", ";", "}", "// directory", "function", "ondirectory", "(", ")", "{", "if", "(", "done", ")", "return", ";", "done", "=", "true", ";", "var", "err", "=", "new", "Error", "(", "'EISDIR, read'", ")", ";", "err", ".", "code", "=", "'EISDIR'", ";", "callback", "(", "err", ")", ";", "}", "// errors", "function", "onerror", "(", "err", ")", "{", "if", "(", "done", ")", "return", ";", "done", "=", "true", ";", "callback", "(", "err", ")", ";", "}", "// ended", "function", "onend", "(", ")", "{", "if", "(", "done", ")", "return", ";", "done", "=", "true", ";", "callback", "(", ")", ";", "}", "// file", "function", "onfile", "(", ")", "{", "streaming", "=", "false", ";", "}", "// finished", "function", "onfinish", "(", "err", ")", "{", "if", "(", "err", "&&", "err", ".", "code", "===", "'ECONNRESET'", ")", "return", "onaborted", "(", ")", ";", "if", "(", "err", ")", "return", "onerror", "(", "err", ")", ";", "if", "(", "done", ")", "return", ";", "setImmediate", "(", "function", "(", ")", "{", "if", "(", "streaming", "!==", "false", "&&", "!", "done", ")", "{", "onaborted", "(", ")", ";", "return", ";", "}", "if", "(", "done", ")", "return", ";", "done", "=", "true", ";", "callback", "(", ")", ";", "}", ")", ";", "}", "// streaming", "function", "onstream", "(", ")", "{", "streaming", "=", "true", ";", "}", "file", ".", "on", "(", "'directory'", ",", "ondirectory", ")", ";", "file", ".", "on", "(", "'end'", ",", "onend", ")", ";", "file", ".", "on", "(", "'error'", ",", "onerror", ")", ";", "file", ".", "on", "(", "'file'", ",", "onfile", ")", ";", "file", ".", "on", "(", "'stream'", ",", "onstream", ")", ";", "onFinished", "(", "res", ",", "onfinish", ")", ";", "if", "(", "options", ".", "headers", ")", "{", "// set headers on successful transfer", "file", ".", "on", "(", "'headers'", ",", "function", "headers", "(", "res", ")", "{", "var", "obj", "=", "options", ".", "headers", ";", "var", "keys", "=", "Object", ".", "keys", "(", "obj", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "keys", ".", "length", ";", "i", "++", ")", "{", "var", "k", "=", "keys", "[", "i", "]", ";", "res", ".", "setHeader", "(", "k", ",", "obj", "[", "k", "]", ")", ";", "}", "}", ")", ";", "}", "// pipe", "file", ".", "pipe", "(", "res", ")", ";", "}" ]

[ "pipe", "the", "send", "file", "stream" ]

[ "function", "stringify", "(", "value", ",", "replacer", ",", "spaces", ",", "escape", ")", "{", "// v8 checks arguments.length for optimizing simple call", "// https://bugs.chromium.org/p/v8/issues/detail?id=4730", "var", "json", "=", "replacer", "||", "spaces", "?", "JSON", ".", "stringify", "(", "value", ",", "replacer", ",", "spaces", ")", ":", "JSON", ".", "stringify", "(", "value", ")", ";", "if", "(", "escape", ")", "{", "json", "=", "json", ".", "replace", "(", "/", "[<>&]", "/", "g", ",", "function", "(", "c", ")", "{", "switch", "(", "c", ".", "charCodeAt", "(", "0", ")", ")", "{", "case", "0x3c", ":", "return", "'\\\\u003c'", "case", "0x3e", ":", "return", "'\\\\u003e'", "case", "0x26", ":", "return", "'\\\\u0026'", "default", ":", "return", "c", "}", "}", ")", "}", "return", "json", "}" ]

[ "Stringify", "JSON", "like", "JSON", ".", "stringify", "but", "v8", "optimized", "with", "the", "ability", "to", "escape", "characters", "that", "can", "trigger", "HTML", "sniffing", "." ]

[ "function", "createError", "(", "status", ",", "message", ")", "{", "var", "err", "=", "new", "Error", "(", "message", ")", ";", "err", ".", "status", "=", "status", ";", "return", "err", ";", "}" ]

[ "Create", "HTTP", "error" ]

[ "function", "View", "(", "name", ",", "options", ")", "{", "var", "opts", "=", "options", "||", "{", "}", ";", "this", ".", "defaultEngine", "=", "opts", ".", "defaultEngine", ";", "this", ".", "ext", "=", "extname", "(", "name", ")", ";", "this", ".", "name", "=", "name", ";", "this", ".", "root", "=", "opts", ".", "root", ";", "if", "(", "!", "this", ".", "ext", "&&", "!", "this", ".", "defaultEngine", ")", "{", "throw", "new", "Error", "(", "'No default engine was specified and no extension was provided.'", ")", ";", "}", "var", "fileName", "=", "name", ";", "if", "(", "!", "this", ".", "ext", ")", "{", "// get extension from default engine name", "this", ".", "ext", "=", "this", ".", "defaultEngine", "[", "0", "]", "!==", "'.'", "?", "'.'", "+", "this", ".", "defaultEngine", ":", "this", ".", "defaultEngine", ";", "fileName", "+=", "this", ".", "ext", ";", "}", "if", "(", "!", "opts", ".", "engines", "[", "this", ".", "ext", "]", ")", "{", "// load engine", "var", "mod", "=", "this", ".", "ext", ".", "substr", "(", "1", ")", "debug", "(", "'require \"%s\"'", ",", "mod", ")", "// default engine export", "var", "fn", "=", "require", "(", "mod", ")", ".", "__express", "if", "(", "typeof", "fn", "!==", "'function'", ")", "{", "throw", "new", "Error", "(", "'Module \"'", "+", "mod", "+", "'\" does not provide a view engine.'", ")", "}", "opts", ".", "engines", "[", "this", ".", "ext", "]", "=", "fn", "}", "// store loaded engine", "this", ".", "engine", "=", "opts", ".", "engines", "[", "this", ".", "ext", "]", ";", "// lookup path", "this", ".", "path", "=", "this", ".", "lookup", "(", "fileName", ")", ";", "}" ]

[ "Initialize", "a", "new", "View", "with", "the", "given", "name", "." ]

[ "function", "GithubView", "(", "name", ",", "options", ")", "{", "this", ".", "name", "=", "name", ";", "options", "=", "options", "||", "{", "}", ";", "this", ".", "engine", "=", "options", ".", "engines", "[", "extname", "(", "name", ")", "]", ";", "// \"root\" is the app.set('views') setting, however", "// in your own implementation you could ignore this", "this", ".", "path", "=", "'/'", "+", "options", ".", "root", "+", "'/master/'", "+", "name", ";", "}" ]

[ "Custom", "view", "that", "fetches", "and", "renders", "remove", "github", "templates", ".", "You", "could", "render", "templates", "from", "a", "database", "etc", "." ]

[ "function", "count", "(", "req", ",", "res", ",", "next", ")", "{", "User", ".", "count", "(", "function", "(", "err", ",", "count", ")", "{", "if", "(", "err", ")", "return", "next", "(", "err", ")", ";", "req", ".", "count", "=", "count", ";", "next", "(", ")", ";", "}", ")", "}" ]

[ "this", "approach", "is", "cleaner", "less", "nesting", "and", "we", "have", "the", "variables", "available", "on", "the", "request", "object" ]

[ "function", "count2", "(", "req", ",", "res", ",", "next", ")", "{", "User", ".", "count", "(", "function", "(", "err", ",", "count", ")", "{", "if", "(", "err", ")", "return", "next", "(", "err", ")", ";", "res", ".", "locals", ".", "count", "=", "count", ";", "next", "(", ")", ";", "}", ")", "}" ]

[ "this", "approach", "is", "much", "like", "the", "last", "however", "we", "re", "explicitly", "exposing", "the", "locals", "within", "each", "middleware", "note", "that", "this", "may", "not", "always", "work", "well", "for", "example", "here", "we", "filter", "the", "users", "in", "the", "middleware", "which", "may", "not", "be", "ideal", "for", "our", "application", ".", "so", "in", "that", "sense", "the", "previous", "example", "is", "more", "flexible", "with", "req", ".", "users", "." ]