Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "deinit", "(", ")", "{", "_isInitialized", "=", "false", ";", "KeyBindingManager", ".", "removeBinding", "(", "collapseKey", ")", ";", "KeyBindingManager", ".", "removeBinding", "(", "expandKey", ")", ";", "KeyBindingManager", ".", "removeBinding", "(", "collapseAllKey", ")", ";", "KeyBindingManager", ".", "removeBinding", "(", "expandAllKey", ")", ";", "KeyBindingManager", ".", "removeBinding", "(", "collapseAllKeyMac", ")", ";", "KeyBindingManager", ".", "removeBinding", "(", "expandAllKeyMac", ")", ";", "//remove menus", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "removeMenuDivider", "(", "codeFoldingMenuDivider", ".", "id", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "removeMenuItem", "(", "COLLAPSE", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "removeMenuItem", "(", "EXPAND", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "removeMenuItem", "(", "COLLAPSE_ALL", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "removeMenuItem", "(", "EXPAND_ALL", ")", ";", "EditorManager", ".", "off", "(", "\".CodeFolding\"", ")", ";", "DocumentManager", ".", "off", "(", "\".CodeFolding\"", ")", ";", "ProjectManager", ".", "off", "(", "\".CodeFolding\"", ")", ";", "// Remove gutter & revert collapsed sections in all currently open editors", "Editor", ".", "forEveryEditor", "(", "function", "(", "editor", ")", "{", "CodeMirror", ".", "commands", ".", "unfoldAll", "(", "editor", ".", "_codeMirror", ")", ";", "}", ")", ";", "removeGutters", "(", ")", ";", "}" ]

[ "Remove", "code", "-", "folding", "functionality" ]

[ "function", "init", "(", ")", "{", "_isInitialized", "=", "true", ";", "foldCode", ".", "init", "(", ")", ";", "foldGutter", ".", "init", "(", ")", ";", "// Many CodeMirror modes specify which fold helper should be used for that language. For a few that", "// don't, we register helpers explicitly here. We also register a global helper for generic indent-based", "// folding, which cuts across all languages if enabled via preference.", "CodeMirror", ".", "registerGlobalHelper", "(", "\"fold\"", ",", "\"selectionFold\"", ",", "function", "(", "mode", ",", "cm", ")", "{", "return", "prefs", ".", "getSetting", "(", "\"makeSelectionsFoldable\"", ")", ";", "}", ",", "selectionFold", ")", ";", "CodeMirror", ".", "registerGlobalHelper", "(", "\"fold\"", ",", "\"indent\"", ",", "function", "(", "mode", ",", "cm", ")", "{", "return", "prefs", ".", "getSetting", "(", "\"alwaysUseIndentFold\"", ")", ";", "}", ",", "indentFold", ")", ";", "CodeMirror", ".", "registerHelper", "(", "\"fold\"", ",", "\"handlebars\"", ",", "handlebarsFold", ")", ";", "CodeMirror", ".", "registerHelper", "(", "\"fold\"", ",", "\"htmlhandlebars\"", ",", "handlebarsFold", ")", ";", "CodeMirror", ".", "registerHelper", "(", "\"fold\"", ",", "\"htmlmixed\"", ",", "handlebarsFold", ")", ";", "EditorManager", ".", "on", "(", "\"activeEditorChange.CodeFolding\"", ",", "onActiveEditorChanged", ")", ";", "DocumentManager", ".", "on", "(", "\"documentRefreshed.CodeFolding\"", ",", "function", "(", "event", ",", "doc", ")", "{", "restoreLineFolds", "(", "doc", ".", "_masterEditor", ")", ";", "}", ")", ";", "ProjectManager", ".", "on", "(", "\"beforeProjectClose.CodeFolding beforeAppClose.CodeFolding\"", ",", "saveBeforeClose", ")", ";", "//create menus", "codeFoldingMenuDivider", "=", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "addMenuDivider", "(", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "addMenuItem", "(", "COLLAPSE_ALL", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "addMenuItem", "(", "EXPAND_ALL", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "addMenuItem", "(", "COLLAPSE", ")", ";", "Menus", ".", "getMenu", "(", "Menus", ".", "AppMenuBar", ".", "VIEW_MENU", ")", ".", "addMenuItem", "(", "EXPAND", ")", ";", "//register keybindings", "KeyBindingManager", ".", "addBinding", "(", "COLLAPSE_ALL", ",", "[", "{", "key", ":", "collapseAllKey", "}", ",", "{", "key", ":", "collapseAllKeyMac", ",", "platform", ":", "\"mac\"", "}", "]", ")", ";", "KeyBindingManager", ".", "addBinding", "(", "EXPAND_ALL", ",", "[", "{", "key", ":", "expandAllKey", "}", ",", "{", "key", ":", "expandAllKeyMac", ",", "platform", ":", "\"mac\"", "}", "]", ")", ";", "KeyBindingManager", ".", "addBinding", "(", "COLLAPSE", ",", "collapseKey", ")", ";", "KeyBindingManager", ".", "addBinding", "(", "EXPAND", ",", "expandKey", ")", ";", "// Add gutters & restore saved expand/collapse state in all currently open editors", "Editor", ".", "registerGutter", "(", "GUTTER_NAME", ",", "CODE_FOLDING_GUTTER_PRIORITY", ")", ";", "Editor", ".", "forEveryEditor", "(", "function", "(", "editor", ")", "{", "enableFoldingInEditor", "(", "editor", ")", ";", "}", ")", ";", "}" ]

[ "Enable", "code", "-", "folding", "functionality" ]

[ "function", "watchPrefsForChanges", "(", ")", "{", "prefs", ".", "prefsObject", ".", "on", "(", "\"change\"", ",", "function", "(", "e", ",", "data", ")", "{", "if", "(", "data", ".", "ids", ".", "indexOf", "(", "\"enabled\"", ")", ">", "-", "1", ")", "{", "// Check if enabled state mismatches whether code-folding is actually initialized (can't assume", "// since preference change events can occur when the value hasn't really changed)", "var", "isEnabled", "=", "prefs", ".", "getSetting", "(", "\"enabled\"", ")", ";", "if", "(", "isEnabled", "&&", "!", "_isInitialized", ")", "{", "init", "(", ")", ";", "}", "else", "if", "(", "!", "isEnabled", "&&", "_isInitialized", ")", "{", "deinit", "(", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "Register", "change", "listener", "for", "the", "preferences", "file", "." ]

[ "function", "init", "(", "domainManager", ")", "{", "if", "(", "!", "domainManager", ".", "hasDomain", "(", "\"fileWatcher\"", ")", ")", "{", "domainManager", ".", "registerDomain", "(", "\"fileWatcher\"", ",", "{", "major", ":", "0", ",", "minor", ":", "1", "}", ")", ";", "}", "domainManager", ".", "registerCommand", "(", "\"fileWatcher\"", ",", "\"watchPath\"", ",", "watcherManager", ".", "watchPath", ",", "false", ",", "\"Start watching a file or directory\"", ",", "[", "{", "name", ":", "\"path\"", ",", "type", ":", "\"string\"", ",", "description", ":", "\"absolute filesystem path of the file or directory to watch\"", "}", ",", "{", "name", ":", "\"ignored\"", ",", "type", ":", "\"array\"", ",", "description", ":", "\"list of path to ignore\"", "}", "]", ")", ";", "domainManager", ".", "registerCommand", "(", "\"fileWatcher\"", ",", "\"unwatchPath\"", ",", "watcherManager", ".", "unwatchPath", ",", "false", ",", "\"Stop watching a single file or a directory and it's descendants\"", ",", "[", "{", "name", ":", "\"path\"", ",", "type", ":", "\"string\"", ",", "description", ":", "\"absolute filesystem path of the file or directory to unwatch\"", "}", "]", ")", ";", "domainManager", ".", "registerCommand", "(", "\"fileWatcher\"", ",", "\"unwatchAll\"", ",", "watcherManager", ".", "unwatchAll", ",", "false", ",", "\"Stop watching all files and directories\"", ")", ";", "domainManager", ".", "registerEvent", "(", "\"fileWatcher\"", ",", "\"change\"", ",", "[", "{", "name", ":", "\"event\"", ",", "type", ":", "\"string\"", "}", ",", "{", "name", ":", "\"parentDirPath\"", ",", "type", ":", "\"string\"", "}", ",", "{", "name", ":", "\"entryName\"", ",", "type", ":", "\"string\"", "}", ",", "{", "name", ":", "\"statsObj\"", ",", "type", ":", "\"object\"", "}", "]", ")", ";", "watcherManager", ".", "setDomainManager", "(", "domainManager", ")", ";", "watcherManager", ".", "setWatcherImpl", "(", "watcherImpl", ")", ";", "}" ]

[ "Initialize", "the", "fileWatcher", "domain", ".", "The", "fileWatcher", "domain", "handles", "watching", "and", "un", "-", "watching", "directories", "." ]

[ "function", "_write", "(", "filePath", ",", "json", ")", "{", "var", "result", "=", "$", ".", "Deferred", "(", ")", ",", "_file", "=", "FileSystem", ".", "getFileForPath", "(", "filePath", ")", ";", "if", "(", "_file", ")", "{", "var", "content", "=", "JSON", ".", "stringify", "(", "json", ")", ";", "FileUtils", ".", "writeText", "(", "_file", ",", "content", ",", "true", ")", ".", "done", "(", "function", "(", ")", "{", "result", ".", "resolve", "(", ")", ";", "}", ")", ".", "fail", "(", "function", "(", "err", ")", "{", "result", ".", "reject", "(", ")", ";", "}", ")", ";", "}", "else", "{", "result", ".", "reject", "(", ")", ";", "}", "return", "result", ".", "promise", "(", ")", ";", "}" ]

[ "Performs", "the", "write", "of", "JSON", "object", "to", "a", "file", "." ]

[ "function", "collectDuplicates", "(", "value", ")", "{", "if", "(", "value", "==", "null", "||", "typeof", "value", "!==", "'object'", ")", "{", "return", ";", "}", "const", "metadata", "=", "metadataForVal", ".", "get", "(", "value", ")", ";", "// Only consider duplicates with hashes longer than 2 (excludes [] and {}).", "if", "(", "metadata", "&&", "metadata", ".", "value", "!==", "value", "&&", "metadata", ".", "hash", ".", "length", ">", "2", ")", "{", "metadata", ".", "isDuplicate", "=", "true", ";", "return", ";", "}", "if", "(", "Array", ".", "isArray", "(", "value", ")", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "value", ".", "length", ";", "i", "++", ")", "{", "collectDuplicates", "(", "value", "[", "i", "]", ")", ";", "}", "}", "else", "{", "for", "(", "const", "k", "in", "value", ")", "{", "if", "(", "value", ".", "hasOwnProperty", "(", "k", ")", "&&", "value", "[", "k", "]", "!==", "undefined", ")", "{", "collectDuplicates", "(", "value", "[", "k", "]", ")", ";", "}", "}", "}", "}" ]

[ "Using", "top", "-", "down", "recursion", "linearly", "scan", "the", "JSON", "tree", "to", "determine", "which", "values", "should", "be", "deduplicated", "." ]

[ "function", "printJSCode", "(", "isDupedVar", ",", "depth", ",", "value", ")", "{", "if", "(", "value", "==", "null", "||", "typeof", "value", "!==", "'object'", ")", "{", "return", "JSON", ".", "stringify", "(", "value", ")", ";", "}", "// Only use variable references at depth beyond the top level.", "if", "(", "depth", "!==", "''", ")", "{", "const", "metadata", "=", "metadataForVal", ".", "get", "(", "value", ")", ";", "if", "(", "metadata", "&&", "metadata", ".", "isDuplicate", ")", "{", "if", "(", "!", "metadata", ".", "varName", ")", "{", "const", "refCode", "=", "printJSCode", "(", "true", ",", "''", ",", "value", ")", ";", "metadata", ".", "varName", "=", "'v'", "+", "varDefs", ".", "length", ";", "varDefs", ".", "push", "(", "metadata", ".", "varName", "+", "' = '", "+", "refCode", ")", ";", "}", "return", "'('", "+", "metadata", ".", "varName", "+", "'/*: any*/)'", ";", "}", "}", "let", "str", ";", "let", "isEmpty", "=", "true", ";", "const", "depth2", "=", "depth", "+", "' '", ";", "if", "(", "Array", ".", "isArray", "(", "value", ")", ")", "{", "// Empty arrays can only have one inferred flow type and then conflict if", "// used in different places, this is unsound if we would write to them but", "// this whole module is based on the idea of a read only JSON tree.", "if", "(", "isDupedVar", "&&", "value", ".", "length", "===", "0", ")", "{", "return", "'([]/*: any*/)'", ";", "}", "str", "=", "'['", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "value", ".", "length", ";", "i", "++", ")", "{", "str", "+=", "(", "isEmpty", "?", "'\\n'", ":", "',\\n'", ")", "+", "depth2", "+", "printJSCode", "(", "isDupedVar", ",", "depth2", ",", "value", "[", "i", "]", ")", ";", "isEmpty", "=", "false", ";", "}", "str", "+=", "isEmpty", "?", "']'", ":", "`", "\\n", "${", "depth", "}", "`", ";", "}", "else", "{", "str", "=", "'{'", ";", "for", "(", "const", "k", "in", "value", ")", "{", "if", "(", "value", ".", "hasOwnProperty", "(", "k", ")", "&&", "value", "[", "k", "]", "!==", "undefined", ")", "{", "str", "+=", "(", "isEmpty", "?", "'\\n'", ":", "',\\n'", ")", "+", "depth2", "+", "JSON", ".", "stringify", "(", "k", ")", "+", "': '", "+", "printJSCode", "(", "isDupedVar", ",", "depth2", ",", "value", "[", "k", "]", ")", ";", "isEmpty", "=", "false", ";", "}", "}", "str", "+=", "isEmpty", "?", "'}'", ":", "`", "\\n", "${", "depth", "}", "`", ";", "}", "return", "str", ";", "}" ]

[ "Stringify", "JS", "replacing", "duplicates", "with", "variable", "references", "." ]

[ "function", "mapModule", "(", "state", ",", "module", ")", "{", "var", "moduleMap", "=", "state", ".", "opts", ".", "map", "||", "{", "}", ";", "if", "(", "moduleMap", ".", "hasOwnProperty", "(", "module", ")", ")", "{", "return", "moduleMap", "[", "module", "]", ";", "}", "// Jest understands the haste module system, so leave modules intact.", "if", "(", "process", ".", "env", ".", "NODE_ENV", "===", "'test'", ")", "{", "return", ";", "}", "return", "'./'", "+", "path", ".", "basename", "(", "module", ")", ";", "}" ]

[ "This", "file", "is", "a", "fork", "from", "fbjs", "s", "transform", "of", "the", "same", "name", ".", "It", "has", "been", "modified", "to", "also", "apply", "to", "import", "statements", "and", "to", "account", "for", "relative", "file", "names", "in", "require", "statements", ".", "Rewrites", "module", "string", "literals", "according", "to", "the", "map", "and", "prefix", "options", ".", "This", "allows", "other", "npm", "packages", "to", "be", "published", "and", "used", "directly", "without", "being", "a", "part", "of", "the", "same", "build", "." ]

[ "function", "cache", "(", "options", ")", "{", "if", "(", "is", ".", "bool", "(", "options", ")", ")", "{", "if", "(", "options", ")", "{", "// Default cache settings of 50MB, 20 files, 100 items", "return", "sharp", ".", "cache", "(", "50", ",", "20", ",", "100", ")", ";", "}", "else", "{", "return", "sharp", ".", "cache", "(", "0", ",", "0", ",", "0", ")", ";", "}", "}", "else", "if", "(", "is", ".", "object", "(", "options", ")", ")", "{", "return", "sharp", ".", "cache", "(", "options", ".", "memory", ",", "options", ".", "files", ",", "options", ".", "items", ")", ";", "}", "else", "{", "return", "sharp", ".", "cache", "(", ")", ";", "}", "}" ]

[ "Gets", "or", "when", "options", "are", "provided", "sets", "the", "limits", "of", "_libvips", "_", "operation", "cache", ".", "Existing", "entries", "in", "the", "cache", "will", "be", "trimmed", "after", "any", "change", "in", "limits", ".", "This", "method", "always", "returns", "cache", "statistics", "useful", "for", "determining", "how", "much", "working", "memory", "is", "required", "for", "a", "particular", "task", "." ]

[ "function", "extractChannel", "(", "channel", ")", "{", "if", "(", "channel", "===", "'red'", ")", "{", "channel", "=", "0", ";", "}", "else", "if", "(", "channel", "===", "'green'", ")", "{", "channel", "=", "1", ";", "}", "else", "if", "(", "channel", "===", "'blue'", ")", "{", "channel", "=", "2", ";", "}", "if", "(", "is", ".", "integer", "(", "channel", ")", "&&", "is", ".", "inRange", "(", "channel", ",", "0", ",", "4", ")", ")", "{", "this", ".", "options", ".", "extractChannel", "=", "channel", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Cannot extract invalid channel '", "+", "channel", ")", ";", "}", "return", "this", ";", "}" ]

[ "Extract", "a", "single", "channel", "from", "a", "multi", "-", "channel", "image", "." ]

[ "function", "_write", "(", "chunk", ",", "encoding", ",", "callback", ")", "{", "/* istanbul ignore else */", "if", "(", "Array", ".", "isArray", "(", "this", ".", "options", ".", "input", ".", "buffer", ")", ")", "{", "/* istanbul ignore else */", "if", "(", "is", ".", "buffer", "(", "chunk", ")", ")", "{", "if", "(", "this", ".", "options", ".", "input", ".", "buffer", ".", "length", "===", "0", ")", "{", "const", "that", "=", "this", ";", "this", ".", "on", "(", "'finish'", ",", "function", "(", ")", "{", "that", ".", "streamInFinished", "=", "true", ";", "}", ")", ";", "}", "this", ".", "options", ".", "input", ".", "buffer", ".", "push", "(", "chunk", ")", ";", "callback", "(", ")", ";", "}", "else", "{", "callback", "(", "new", "Error", "(", "'Non-Buffer data on Writable Stream'", ")", ")", ";", "}", "}", "else", "{", "callback", "(", "new", "Error", "(", "'Unexpected data on Writable Stream'", ")", ")", ";", "}", "}" ]

[ "Handle", "incoming", "Buffer", "chunk", "on", "Writable", "Stream", "." ]

[ "function", "_flattenBufferIn", "(", ")", "{", "if", "(", "this", ".", "_isStreamInput", "(", ")", ")", "{", "this", ".", "options", ".", "input", ".", "buffer", "=", "Buffer", ".", "concat", "(", "this", ".", "options", ".", "input", ".", "buffer", ")", ";", "}", "}" ]

[ "Flattens", "the", "array", "of", "chunks", "accumulated", "in", "input", ".", "buffer", "." ]

[ "function", "clone", "(", ")", "{", "const", "that", "=", "this", ";", "// Clone existing options", "const", "clone", "=", "this", ".", "constructor", ".", "call", "(", ")", ";", "clone", ".", "options", "=", "Object", ".", "assign", "(", "{", "}", ",", "this", ".", "options", ")", ";", "// Pass 'finish' event to clone for Stream-based input", "if", "(", "this", ".", "_isStreamInput", "(", ")", ")", "{", "this", ".", "on", "(", "'finish'", ",", "function", "(", ")", "{", "// Clone inherits input data", "that", ".", "_flattenBufferIn", "(", ")", ";", "clone", ".", "options", ".", "bufferIn", "=", "that", ".", "options", ".", "bufferIn", ";", "clone", ".", "emit", "(", "'finish'", ")", ";", "}", ")", ";", "}", "return", "clone", ";", "}" ]

[ "Take", "a", "snapshot", "of", "the", "Sharp", "instance", "returning", "a", "new", "instance", ".", "Cloned", "instances", "inherit", "the", "input", "of", "their", "parent", "instance", ".", "This", "allows", "multiple", "output", "Streams", "and", "therefore", "multiple", "processing", "pipelines", "to", "share", "a", "single", "input", "Stream", "." ]

[ "function", "stats", "(", "callback", ")", "{", "const", "that", "=", "this", ";", "if", "(", "is", ".", "fn", "(", "callback", ")", ")", "{", "if", "(", "this", ".", "_isStreamInput", "(", ")", ")", "{", "this", ".", "on", "(", "'finish'", ",", "function", "(", ")", "{", "that", ".", "_flattenBufferIn", "(", ")", ";", "sharp", ".", "stats", "(", "that", ".", "options", ",", "callback", ")", ";", "}", ")", ";", "}", "else", "{", "sharp", ".", "stats", "(", "this", ".", "options", ",", "callback", ")", ";", "}", "return", "this", ";", "}", "else", "{", "if", "(", "this", ".", "_isStreamInput", "(", ")", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "that", ".", "on", "(", "'finish'", ",", "function", "(", ")", "{", "that", ".", "_flattenBufferIn", "(", ")", ";", "sharp", ".", "stats", "(", "that", ".", "options", ",", "function", "(", "err", ",", "stats", ")", "{", "if", "(", "err", ")", "{", "reject", "(", "err", ")", ";", "}", "else", "{", "resolve", "(", "stats", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}", "else", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "sharp", ".", "stats", "(", "that", ".", "options", ",", "function", "(", "err", ",", "stats", ")", "{", "if", "(", "err", ")", "{", "reject", "(", "err", ")", ";", "}", "else", "{", "resolve", "(", "stats", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}", "}", "}" ]

[ "Access", "to", "pixel", "-", "derived", "image", "statistics", "for", "every", "channel", "in", "the", "image", ".", "A", "Promise", "is", "returned", "when", "callback", "is", "not", "provided", "." ]

[ "function", "toFile", "(", "fileOut", ",", "callback", ")", "{", "if", "(", "!", "fileOut", "||", "fileOut", ".", "length", "===", "0", ")", "{", "const", "errOutputInvalid", "=", "new", "Error", "(", "'Missing output file path'", ")", ";", "if", "(", "is", ".", "fn", "(", "callback", ")", ")", "{", "callback", "(", "errOutputInvalid", ")", ";", "}", "else", "{", "return", "Promise", ".", "reject", "(", "errOutputInvalid", ")", ";", "}", "}", "else", "{", "if", "(", "this", ".", "options", ".", "input", ".", "file", "===", "fileOut", ")", "{", "const", "errOutputIsInput", "=", "new", "Error", "(", "'Cannot use same file for input and output'", ")", ";", "if", "(", "is", ".", "fn", "(", "callback", ")", ")", "{", "callback", "(", "errOutputIsInput", ")", ";", "}", "else", "{", "return", "Promise", ".", "reject", "(", "errOutputIsInput", ")", ";", "}", "}", "else", "{", "this", ".", "options", ".", "fileOut", "=", "fileOut", ";", "return", "this", ".", "_pipeline", "(", "callback", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Write", "output", "image", "data", "to", "a", "file", "." ]

[ "function", "toBuffer", "(", "options", ",", "callback", ")", "{", "if", "(", "is", ".", "object", "(", "options", ")", ")", "{", "if", "(", "is", ".", "bool", "(", "options", ".", "resolveWithObject", ")", ")", "{", "this", ".", "options", ".", "resolveWithObject", "=", "options", ".", "resolveWithObject", ";", "}", "}", "return", "this", ".", "_pipeline", "(", "is", ".", "fn", "(", "options", ")", "?", "options", ":", "callback", ")", ";", "}" ]

[ "Write", "output", "to", "a", "Buffer", ".", "JPEG", "PNG", "WebP", "TIFF", "and", "RAW", "output", "are", "supported", ".", "By", "default", "the", "format", "will", "match", "the", "input", "image", "except", "GIF", "and", "SVG", "input", "which", "become", "PNG", "output", "." ]

[ "function", "jpeg", "(", "options", ")", "{", "if", "(", "is", ".", "object", "(", "options", ")", ")", "{", "if", "(", "is", ".", "defined", "(", "options", ".", "quality", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "options", ".", "quality", ")", "&&", "is", ".", "inRange", "(", "options", ".", "quality", ",", "1", ",", "100", ")", ")", "{", "this", ".", "options", ".", "jpegQuality", "=", "options", ".", "quality", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid quality (integer, 1-100) '", "+", "options", ".", "quality", ")", ";", "}", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "progressive", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'jpegProgressive'", ",", "options", ".", "progressive", ")", ";", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "chromaSubsampling", ")", ")", "{", "if", "(", "is", ".", "string", "(", "options", ".", "chromaSubsampling", ")", "&&", "is", ".", "inArray", "(", "options", ".", "chromaSubsampling", ",", "[", "'4:2:0'", ",", "'4:4:4'", "]", ")", ")", "{", "this", ".", "options", ".", "jpegChromaSubsampling", "=", "options", ".", "chromaSubsampling", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid chromaSubsampling (4:2:0, 4:4:4) '", "+", "options", ".", "chromaSubsampling", ")", ";", "}", "}", "const", "trellisQuantisation", "=", "is", ".", "bool", "(", "options", ".", "trellisQuantization", ")", "?", "options", ".", "trellisQuantization", ":", "options", ".", "trellisQuantisation", ";", "if", "(", "is", ".", "defined", "(", "trellisQuantisation", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'jpegTrellisQuantisation'", ",", "trellisQuantisation", ")", ";", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "overshootDeringing", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'jpegOvershootDeringing'", ",", "options", ".", "overshootDeringing", ")", ";", "}", "const", "optimiseScans", "=", "is", ".", "bool", "(", "options", ".", "optimizeScans", ")", "?", "options", ".", "optimizeScans", ":", "options", ".", "optimiseScans", ";", "if", "(", "is", ".", "defined", "(", "optimiseScans", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'jpegOptimiseScans'", ",", "optimiseScans", ")", ";", "if", "(", "optimiseScans", ")", "{", "this", ".", "options", ".", "jpegProgressive", "=", "true", ";", "}", "}", "const", "optimiseCoding", "=", "is", ".", "bool", "(", "options", ".", "optimizeCoding", ")", "?", "options", ".", "optimizeCoding", ":", "options", ".", "optimiseCoding", ";", "if", "(", "is", ".", "defined", "(", "optimiseCoding", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'jpegOptimiseCoding'", ",", "optimiseCoding", ")", ";", "}", "const", "quantisationTable", "=", "is", ".", "number", "(", "options", ".", "quantizationTable", ")", "?", "options", ".", "quantizationTable", ":", "options", ".", "quantisationTable", ";", "if", "(", "is", ".", "defined", "(", "quantisationTable", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "quantisationTable", ")", "&&", "is", ".", "inRange", "(", "quantisationTable", ",", "0", ",", "8", ")", ")", "{", "this", ".", "options", ".", "jpegQuantisationTable", "=", "quantisationTable", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid quantisation table (integer, 0-8) '", "+", "quantisationTable", ")", ";", "}", "}", "}", "return", "this", ".", "_updateFormatOut", "(", "'jpeg'", ",", "options", ")", ";", "}" ]

[ "Use", "these", "JPEG", "options", "for", "output", "image", "." ]

[ "function", "png", "(", "options", ")", "{", "if", "(", "is", ".", "object", "(", "options", ")", ")", "{", "if", "(", "is", ".", "defined", "(", "options", ".", "progressive", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'pngProgressive'", ",", "options", ".", "progressive", ")", ";", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "compressionLevel", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "options", ".", "compressionLevel", ")", "&&", "is", ".", "inRange", "(", "options", ".", "compressionLevel", ",", "0", ",", "9", ")", ")", "{", "this", ".", "options", ".", "pngCompressionLevel", "=", "options", ".", "compressionLevel", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid compressionLevel (integer, 0-9) '", "+", "options", ".", "compressionLevel", ")", ";", "}", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "adaptiveFiltering", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'pngAdaptiveFiltering'", ",", "options", ".", "adaptiveFiltering", ")", ";", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "palette", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'pngPalette'", ",", "options", ".", "palette", ")", ";", "if", "(", "this", ".", "options", ".", "pngPalette", ")", "{", "if", "(", "is", ".", "defined", "(", "options", ".", "quality", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "options", ".", "quality", ")", "&&", "is", ".", "inRange", "(", "options", ".", "quality", ",", "0", ",", "100", ")", ")", "{", "this", ".", "options", ".", "pngQuality", "=", "options", ".", "quality", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'quality'", ",", "'integer between 0 and 100'", ",", "options", ".", "quality", ")", ";", "}", "}", "const", "colours", "=", "options", ".", "colours", "||", "options", ".", "colors", ";", "if", "(", "is", ".", "defined", "(", "colours", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "colours", ")", "&&", "is", ".", "inRange", "(", "colours", ",", "2", ",", "256", ")", ")", "{", "this", ".", "options", ".", "pngColours", "=", "colours", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'colours'", ",", "'integer between 2 and 256'", ",", "colours", ")", ";", "}", "}", "if", "(", "is", ".", "defined", "(", "options", ".", "dither", ")", ")", "{", "if", "(", "is", ".", "number", "(", "options", ".", "dither", ")", "&&", "is", ".", "inRange", "(", "options", ".", "dither", ",", "0", ",", "1", ")", ")", "{", "this", ".", "options", ".", "pngDither", "=", "options", ".", "dither", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'dither'", ",", "'number between 0.0 and 1.0'", ",", "options", ".", "dither", ")", ";", "}", "}", "}", "}", "}", "return", "this", ".", "_updateFormatOut", "(", "'png'", ",", "options", ")", ";", "}" ]

[ "Use", "these", "PNG", "options", "for", "output", "image", "." ]

[ "function", "webp", "(", "options", ")", "{", "if", "(", "is", ".", "object", "(", "options", ")", "&&", "is", ".", "defined", "(", "options", ".", "quality", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "options", ".", "quality", ")", "&&", "is", ".", "inRange", "(", "options", ".", "quality", ",", "1", ",", "100", ")", ")", "{", "this", ".", "options", ".", "webpQuality", "=", "options", ".", "quality", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid quality (integer, 1-100) '", "+", "options", ".", "quality", ")", ";", "}", "}", "if", "(", "is", ".", "object", "(", "options", ")", "&&", "is", ".", "defined", "(", "options", ".", "alphaQuality", ")", ")", "{", "if", "(", "is", ".", "integer", "(", "options", ".", "alphaQuality", ")", "&&", "is", ".", "inRange", "(", "options", ".", "alphaQuality", ",", "0", ",", "100", ")", ")", "{", "this", ".", "options", ".", "webpAlphaQuality", "=", "options", ".", "alphaQuality", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid webp alpha quality (integer, 0-100) '", "+", "options", ".", "alphaQuality", ")", ";", "}", "}", "if", "(", "is", ".", "object", "(", "options", ")", "&&", "is", ".", "defined", "(", "options", ".", "lossless", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'webpLossless'", ",", "options", ".", "lossless", ")", ";", "}", "if", "(", "is", ".", "object", "(", "options", ")", "&&", "is", ".", "defined", "(", "options", ".", "nearLossless", ")", ")", "{", "this", ".", "_setBooleanOption", "(", "'webpNearLossless'", ",", "options", ".", "nearLossless", ")", ";", "}", "return", "this", ".", "_updateFormatOut", "(", "'webp'", ",", "options", ")", ";", "}" ]

[ "Use", "these", "WebP", "options", "for", "output", "image", "." ]

[ "function", "toFormat", "(", "format", ",", "options", ")", "{", "if", "(", "is", ".", "object", "(", "format", ")", "&&", "is", ".", "string", "(", "format", ".", "id", ")", ")", "{", "format", "=", "format", ".", "id", ";", "}", "if", "(", "format", "===", "'jpg'", ")", "format", "=", "'jpeg'", ";", "if", "(", "!", "is", ".", "inArray", "(", "format", ",", "[", "'jpeg'", ",", "'png'", ",", "'webp'", ",", "'tiff'", ",", "'raw'", "]", ")", ")", "{", "throw", "new", "Error", "(", "'Unsupported output format '", "+", "format", ")", ";", "}", "return", "this", "[", "format", "]", "(", "options", ")", ";", "}" ]

[ "Force", "output", "to", "a", "given", "format", "." ]

[ "function", "_updateFormatOut", "(", "formatOut", ",", "options", ")", "{", "if", "(", "!", "(", "is", ".", "object", "(", "options", ")", "&&", "options", ".", "force", "===", "false", ")", ")", "{", "this", ".", "options", ".", "formatOut", "=", "formatOut", ";", "}", "return", "this", ";", "}" ]

[ "Update", "the", "output", "format", "unless", "options", ".", "force", "is", "false", "in", "which", "case", "revert", "to", "input", "format", "." ]

[ "function", "_setBooleanOption", "(", "key", ",", "val", ")", "{", "if", "(", "is", ".", "bool", "(", "val", ")", ")", "{", "this", ".", "options", "[", "key", "]", "=", "val", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid '", "+", "key", "+", "' (boolean) '", "+", "val", ")", ";", "}", "}" ]

[ "Update", "a", "Boolean", "attribute", "of", "the", "this", ".", "options", "Object", "." ]

[ "function", "tint", "(", "rgb", ")", "{", "const", "colour", "=", "color", "(", "rgb", ")", ";", "this", ".", "options", ".", "tintA", "=", "colour", ".", "a", "(", ")", ";", "this", ".", "options", ".", "tintB", "=", "colour", ".", "b", "(", ")", ";", "return", "this", ";", "}" ]

[ "Tint", "the", "image", "using", "the", "provided", "chroma", "while", "preserving", "the", "image", "luminance", ".", "An", "alpha", "channel", "may", "be", "present", "and", "will", "be", "unchanged", "by", "the", "operation", "." ]

[ "function", "toColourspace", "(", "colourspace", ")", "{", "if", "(", "!", "is", ".", "string", "(", "colourspace", ")", ")", "{", "throw", "new", "Error", "(", "'Invalid output colourspace '", "+", "colourspace", ")", ";", "}", "this", ".", "options", ".", "colourspace", "=", "colourspace", ";", "return", "this", ";", "}" ]

[ "Set", "the", "output", "colourspace", ".", "By", "default", "output", "image", "will", "be", "web", "-", "friendly", "sRGB", "with", "additional", "channels", "interpreted", "as", "alpha", "channels", "." ]

[ "function", "_setColourOption", "(", "key", ",", "val", ")", "{", "if", "(", "is", ".", "object", "(", "val", ")", "||", "is", ".", "string", "(", "val", ")", ")", "{", "const", "colour", "=", "color", "(", "val", ")", ";", "this", ".", "options", "[", "key", "]", "=", "[", "colour", ".", "red", "(", ")", ",", "colour", ".", "green", "(", ")", ",", "colour", ".", "blue", "(", ")", ",", "Math", ".", "round", "(", "colour", ".", "alpha", "(", ")", "*", "255", ")", "]", ";", "}", "}" ]

[ "Update", "a", "colour", "attribute", "of", "the", "this", ".", "options", "Object", "." ]

[ "function", "extract", "(", "options", ")", "{", "const", "suffix", "=", "this", ".", "options", ".", "width", "===", "-", "1", "&&", "this", ".", "options", ".", "height", "===", "-", "1", "?", "'Pre'", ":", "'Post'", ";", "[", "'left'", ",", "'top'", ",", "'width'", ",", "'height'", "]", ".", "forEach", "(", "function", "(", "name", ")", "{", "const", "value", "=", "options", "[", "name", "]", ";", "if", "(", "is", ".", "integer", "(", "value", ")", "&&", "value", ">=", "0", ")", "{", "this", ".", "options", "[", "name", "+", "(", "name", "===", "'left'", "||", "name", "===", "'top'", "?", "'Offset'", ":", "''", ")", "+", "suffix", "]", "=", "value", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Non-integer value for '", "+", "name", "+", "' of '", "+", "value", ")", ";", "}", "}", ",", "this", ")", ";", "// Ensure existing rotation occurs before pre-resize extraction", "if", "(", "suffix", "===", "'Pre'", "&&", "(", "(", "this", ".", "options", ".", "angle", "%", "360", ")", "!==", "0", "||", "this", ".", "options", ".", "useExifOrientation", "===", "true", ")", ")", "{", "this", ".", "options", ".", "rotateBeforePreExtract", "=", "true", ";", "}", "return", "this", ";", "}" ]

[ "Extract", "a", "region", "of", "the", "image", "." ]

[ "function", "trim", "(", "threshold", ")", "{", "if", "(", "!", "is", ".", "defined", "(", "threshold", ")", ")", "{", "this", ".", "options", ".", "trimThreshold", "=", "10", ";", "}", "else", "if", "(", "is", ".", "number", "(", "threshold", ")", "&&", "threshold", ">", "0", ")", "{", "this", ".", "options", ".", "trimThreshold", "=", "threshold", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'threshold'", ",", "'number greater than zero'", ",", "threshold", ")", ";", "}", "return", "this", ";", "}" ]

[ "Trim", "boring", "pixels", "from", "all", "edges", "that", "contain", "values", "similar", "to", "the", "top", "-", "left", "pixel", ".", "The", "info", "response", "Object", "will", "contain", "trimOffsetLeft", "and", "trimOffsetTop", "properties", "." ]

[ "function", "rotate", "(", "angle", ",", "options", ")", "{", "if", "(", "!", "is", ".", "defined", "(", "angle", ")", ")", "{", "this", ".", "options", ".", "useExifOrientation", "=", "true", ";", "}", "else", "if", "(", "is", ".", "integer", "(", "angle", ")", "&&", "!", "(", "angle", "%", "90", ")", ")", "{", "this", ".", "options", ".", "angle", "=", "angle", ";", "}", "else", "if", "(", "is", ".", "number", "(", "angle", ")", ")", "{", "this", ".", "options", ".", "rotationAngle", "=", "angle", ";", "if", "(", "is", ".", "object", "(", "options", ")", "&&", "options", ".", "background", ")", "{", "const", "backgroundColour", "=", "color", "(", "options", ".", "background", ")", ";", "this", ".", "options", ".", "rotationBackground", "=", "[", "backgroundColour", ".", "red", "(", ")", ",", "backgroundColour", ".", "green", "(", ")", ",", "backgroundColour", ".", "blue", "(", ")", ",", "Math", ".", "round", "(", "backgroundColour", ".", "alpha", "(", ")", "*", "255", ")", "]", ";", "}", "}", "else", "{", "throw", "new", "Error", "(", "'Unsupported angle: must be a number.'", ")", ";", "}", "return", "this", ";", "}" ]

[ "Rotate", "the", "output", "image", "by", "either", "an", "explicit", "angle", "or", "auto", "-", "orient", "based", "on", "the", "EXIF", "Orientation", "tag", "." ]

[ "function", "sharpen", "(", "sigma", ",", "flat", ",", "jagged", ")", "{", "if", "(", "!", "is", ".", "defined", "(", "sigma", ")", ")", "{", "// No arguments: default to mild sharpen", "this", ".", "options", ".", "sharpenSigma", "=", "-", "1", ";", "}", "else", "if", "(", "is", ".", "bool", "(", "sigma", ")", ")", "{", "// Boolean argument: apply mild sharpen?", "this", ".", "options", ".", "sharpenSigma", "=", "sigma", "?", "-", "1", ":", "0", ";", "}", "else", "if", "(", "is", ".", "number", "(", "sigma", ")", "&&", "is", ".", "inRange", "(", "sigma", ",", "0.01", ",", "10000", ")", ")", "{", "// Numeric argument: specific sigma", "this", ".", "options", ".", "sharpenSigma", "=", "sigma", ";", "// Control over flat areas", "if", "(", "is", ".", "defined", "(", "flat", ")", ")", "{", "if", "(", "is", ".", "number", "(", "flat", ")", "&&", "is", ".", "inRange", "(", "flat", ",", "0", ",", "10000", ")", ")", "{", "this", ".", "options", ".", "sharpenFlat", "=", "flat", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid sharpen level for flat areas (0.0 - 10000.0) '", "+", "flat", ")", ";", "}", "}", "// Control over jagged areas", "if", "(", "is", ".", "defined", "(", "jagged", ")", ")", "{", "if", "(", "is", ".", "number", "(", "jagged", ")", "&&", "is", ".", "inRange", "(", "jagged", ",", "0", ",", "10000", ")", ")", "{", "this", ".", "options", ".", "sharpenJagged", "=", "jagged", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid sharpen level for jagged areas (0.0 - 10000.0) '", "+", "jagged", ")", ";", "}", "}", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid sharpen sigma (0.01 - 10000) '", "+", "sigma", ")", ";", "}", "return", "this", ";", "}" ]

[ "Sharpen", "the", "image", ".", "When", "used", "without", "parameters", "performs", "a", "fast", "mild", "sharpen", "of", "the", "output", "image", ".", "When", "a", "sigma", "is", "provided", "performs", "a", "slower", "more", "accurate", "sharpen", "of", "the", "L", "channel", "in", "the", "LAB", "colour", "space", ".", "Separate", "control", "over", "the", "level", "of", "sharpening", "in", "flat", "and", "jagged", "areas", "is", "available", "." ]

[ "function", "median", "(", "size", ")", "{", "if", "(", "!", "is", ".", "defined", "(", "size", ")", ")", "{", "// No arguments: default to 3x3", "this", ".", "options", ".", "medianSize", "=", "3", ";", "}", "else", "if", "(", "is", ".", "integer", "(", "size", ")", "&&", "is", ".", "inRange", "(", "size", ",", "1", ",", "1000", ")", ")", "{", "// Numeric argument: specific sigma", "this", ".", "options", ".", "medianSize", "=", "size", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid median size '", "+", "size", ")", ";", "}", "return", "this", ";", "}" ]

[ "Apply", "median", "filter", ".", "When", "used", "without", "parameters", "the", "default", "window", "is", "3x3", "." ]

[ "function", "blur", "(", "sigma", ")", "{", "if", "(", "!", "is", ".", "defined", "(", "sigma", ")", ")", "{", "// No arguments: default to mild blur", "this", ".", "options", ".", "blurSigma", "=", "-", "1", ";", "}", "else", "if", "(", "is", ".", "bool", "(", "sigma", ")", ")", "{", "// Boolean argument: apply mild blur?", "this", ".", "options", ".", "blurSigma", "=", "sigma", "?", "-", "1", ":", "0", ";", "}", "else", "if", "(", "is", ".", "number", "(", "sigma", ")", "&&", "is", ".", "inRange", "(", "sigma", ",", "0.3", ",", "1000", ")", ")", "{", "// Numeric argument: specific sigma", "this", ".", "options", ".", "blurSigma", "=", "sigma", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid blur sigma (0.3 - 1000.0) '", "+", "sigma", ")", ";", "}", "return", "this", ";", "}" ]

[ "Blur", "the", "image", ".", "When", "used", "without", "parameters", "performs", "a", "fast", "mild", "blur", "of", "the", "output", "image", ".", "When", "a", "sigma", "is", "provided", "performs", "a", "slower", "more", "accurate", "Gaussian", "blur", "." ]

[ "function", "flatten", "(", "options", ")", "{", "this", ".", "options", ".", "flatten", "=", "is", ".", "bool", "(", "options", ")", "?", "options", ":", "true", ";", "if", "(", "is", ".", "object", "(", "options", ")", ")", "{", "this", ".", "_setColourOption", "(", "'flattenBackground'", ",", "options", ".", "background", ")", ";", "}", "return", "this", ";", "}" ]

[ "Merge", "alpha", "transparency", "channel", "if", "any", "with", "a", "background", "." ]

[ "function", "convolve", "(", "kernel", ")", "{", "if", "(", "!", "is", ".", "object", "(", "kernel", ")", "||", "!", "Array", ".", "isArray", "(", "kernel", ".", "kernel", ")", "||", "!", "is", ".", "integer", "(", "kernel", ".", "width", ")", "||", "!", "is", ".", "integer", "(", "kernel", ".", "height", ")", "||", "!", "is", ".", "inRange", "(", "kernel", ".", "width", ",", "3", ",", "1001", ")", "||", "!", "is", ".", "inRange", "(", "kernel", ".", "height", ",", "3", ",", "1001", ")", "||", "kernel", ".", "height", "*", "kernel", ".", "width", "!==", "kernel", ".", "kernel", ".", "length", ")", "{", "// must pass in a kernel", "throw", "new", "Error", "(", "'Invalid convolution kernel'", ")", ";", "}", "// Default scale is sum of kernel values", "if", "(", "!", "is", ".", "integer", "(", "kernel", ".", "scale", ")", ")", "{", "kernel", ".", "scale", "=", "kernel", ".", "kernel", ".", "reduce", "(", "function", "(", "a", ",", "b", ")", "{", "return", "a", "+", "b", ";", "}", ",", "0", ")", ";", "}", "// Clip scale to a minimum value of 1", "if", "(", "kernel", ".", "scale", "<", "1", ")", "{", "kernel", ".", "scale", "=", "1", ";", "}", "if", "(", "!", "is", ".", "integer", "(", "kernel", ".", "offset", ")", ")", "{", "kernel", ".", "offset", "=", "0", ";", "}", "this", ".", "options", ".", "convKernel", "=", "kernel", ";", "return", "this", ";", "}" ]

[ "Convolve", "the", "image", "with", "the", "specified", "kernel", "." ]

[ "function", "threshold", "(", "threshold", ",", "options", ")", "{", "if", "(", "!", "is", ".", "defined", "(", "threshold", ")", ")", "{", "this", ".", "options", ".", "threshold", "=", "128", ";", "}", "else", "if", "(", "is", ".", "bool", "(", "threshold", ")", ")", "{", "this", ".", "options", ".", "threshold", "=", "threshold", "?", "128", ":", "0", ";", "}", "else", "if", "(", "is", ".", "integer", "(", "threshold", ")", "&&", "is", ".", "inRange", "(", "threshold", ",", "0", ",", "255", ")", ")", "{", "this", ".", "options", ".", "threshold", "=", "threshold", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid threshold (0 to 255) '", "+", "threshold", ")", ";", "}", "if", "(", "!", "is", ".", "object", "(", "options", ")", "||", "options", ".", "greyscale", "===", "true", "||", "options", ".", "grayscale", "===", "true", ")", "{", "this", ".", "options", ".", "thresholdGrayscale", "=", "true", ";", "}", "else", "{", "this", ".", "options", ".", "thresholdGrayscale", "=", "false", ";", "}", "return", "this", ";", "}" ]

[ "Any", "pixel", "value", "greather", "than", "or", "equal", "to", "the", "threshold", "value", "will", "be", "set", "to", "255", "otherwise", "it", "will", "be", "set", "to", "0", "." ]

[ "function", "boolean", "(", "operand", ",", "operator", ",", "options", ")", "{", "this", ".", "options", ".", "boolean", "=", "this", ".", "_createInputDescriptor", "(", "operand", ",", "options", ")", ";", "if", "(", "is", ".", "string", "(", "operator", ")", "&&", "is", ".", "inArray", "(", "operator", ",", "[", "'and'", ",", "'or'", ",", "'eor'", "]", ")", ")", "{", "this", ".", "options", ".", "booleanOp", "=", "operator", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Invalid boolean operator '", "+", "operator", ")", ";", "}", "return", "this", ";", "}" ]

[ "Perform", "a", "bitwise", "boolean", "operation", "with", "operand", "image", "." ]

[ "function", "recomb", "(", "inputMatrix", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "inputMatrix", ")", "||", "inputMatrix", ".", "length", "!==", "3", "||", "inputMatrix", "[", "0", "]", ".", "length", "!==", "3", "||", "inputMatrix", "[", "1", "]", ".", "length", "!==", "3", "||", "inputMatrix", "[", "2", "]", ".", "length", "!==", "3", ")", "{", "// must pass in a kernel", "throw", "new", "Error", "(", "'Invalid Recomb Matrix'", ")", ";", "}", "this", ".", "options", ".", "recombMatrix", "=", "[", "inputMatrix", "[", "0", "]", "[", "0", "]", ",", "inputMatrix", "[", "0", "]", "[", "1", "]", ",", "inputMatrix", "[", "0", "]", "[", "2", "]", ",", "inputMatrix", "[", "1", "]", "[", "0", "]", ",", "inputMatrix", "[", "1", "]", "[", "1", "]", ",", "inputMatrix", "[", "1", "]", "[", "2", "]", ",", "inputMatrix", "[", "2", "]", "[", "0", "]", ",", "inputMatrix", "[", "2", "]", "[", "1", "]", ",", "inputMatrix", "[", "2", "]", "[", "2", "]", "]", ".", "map", "(", "Number", ")", ";", "return", "this", ";", "}" ]

[ "Recomb", "the", "image", "with", "the", "specified", "matrix", "." ]

[ "function", "modulate", "(", "options", ")", "{", "if", "(", "!", "is", ".", "plainObject", "(", "options", ")", ")", "{", "throw", "is", ".", "invalidParameterError", "(", "'options'", ",", "'plain object'", ",", "options", ")", ";", "}", "if", "(", "'brightness'", "in", "options", ")", "{", "if", "(", "is", ".", "number", "(", "options", ".", "brightness", ")", "&&", "options", ".", "brightness", ">=", "0", ")", "{", "this", ".", "options", ".", "brightness", "=", "options", ".", "brightness", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'brightness'", ",", "'number above zero'", ",", "options", ".", "brightness", ")", ";", "}", "}", "if", "(", "'saturation'", "in", "options", ")", "{", "if", "(", "is", ".", "number", "(", "options", ".", "saturation", ")", "&&", "options", ".", "saturation", ">=", "0", ")", "{", "this", ".", "options", ".", "saturation", "=", "options", ".", "saturation", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'saturation'", ",", "'number above zero'", ",", "options", ".", "saturation", ")", ";", "}", "}", "if", "(", "'hue'", "in", "options", ")", "{", "if", "(", "is", ".", "integer", "(", "options", ".", "hue", ")", ")", "{", "this", ".", "options", ".", "hue", "=", "options", ".", "hue", "%", "360", ";", "}", "else", "{", "throw", "is", ".", "invalidParameterError", "(", "'hue'", ",", "'number'", ",", "options", ".", "hue", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Transforms", "the", "image", "using", "brightness", "saturation", "and", "hue", "rotation", "." ]

[ "function", "findWhereUnwrapped", "(", "wrapper", ",", "predicate", ",", "filter", "=", "treeFilter", ")", "{", "return", "wrapper", ".", "flatMap", "(", "n", "=>", "filter", "(", "n", ".", "getNodeInternal", "(", ")", ",", "predicate", ")", ")", ";", "}" ]

[ "Finds", "all", "nodes", "in", "the", "current", "wrapper", "nodes", "render", "trees", "that", "match", "the", "provided", "predicate", "function", "." ]

[ "function", "filterWhereUnwrapped", "(", "wrapper", ",", "predicate", ")", "{", "return", "wrapper", ".", "wrap", "(", "wrapper", ".", "getNodesInternal", "(", ")", ".", "filter", "(", "predicate", ")", ".", "filter", "(", "Boolean", ")", ")", ";", "}" ]

[ "Returns", "a", "new", "wrapper", "instance", "with", "only", "the", "nodes", "of", "the", "current", "wrapper", "instance", "that", "match", "the", "provided", "predicate", "function", "." ]

[ "function", "validateOptions", "(", "options", ")", "{", "const", "{", "lifecycleExperimental", ",", "disableLifecycleMethods", ",", "enableComponentDidUpdateOnSetState", ",", "supportPrevContextArgumentOfComponentDidUpdate", ",", "lifecycles", ",", "}", "=", "options", ";", "if", "(", "typeof", "lifecycleExperimental", "!==", "'undefined'", "&&", "typeof", "lifecycleExperimental", "!==", "'boolean'", ")", "{", "throw", "new", "Error", "(", "'lifecycleExperimental must be either true or false if provided'", ")", ";", "}", "if", "(", "typeof", "disableLifecycleMethods", "!==", "'undefined'", "&&", "typeof", "disableLifecycleMethods", "!==", "'boolean'", ")", "{", "throw", "new", "Error", "(", "'disableLifecycleMethods must be either true or false if provided'", ")", ";", "}", "if", "(", "lifecycleExperimental", "!=", "null", "&&", "disableLifecycleMethods", "!=", "null", "&&", "lifecycleExperimental", "===", "disableLifecycleMethods", ")", "{", "throw", "new", "Error", "(", "'lifecycleExperimental and disableLifecycleMethods cannot be set to the same value'", ")", ";", "}", "if", "(", "typeof", "enableComponentDidUpdateOnSetState", "!==", "'undefined'", "&&", "lifecycles", ".", "componentDidUpdate", "&&", "lifecycles", ".", "componentDidUpdate", ".", "onSetState", "!==", "enableComponentDidUpdateOnSetState", ")", "{", "throw", "new", "TypeError", "(", "'the legacy enableComponentDidUpdateOnSetState option should be matched by `lifecycles: { componentDidUpdate: { onSetState: true } }`, for compatibility'", ")", ";", "}", "if", "(", "typeof", "supportPrevContextArgumentOfComponentDidUpdate", "!==", "'undefined'", "&&", "lifecycles", ".", "componentDidUpdate", "&&", "lifecycles", ".", "componentDidUpdate", ".", "prevContext", "!==", "supportPrevContextArgumentOfComponentDidUpdate", ")", "{", "throw", "new", "TypeError", "(", "'the legacy supportPrevContextArgumentOfComponentDidUpdate option should be matched by `lifecycles: { componentDidUpdate: { prevContext: true } }`, for compatibility'", ")", ";", "}", "}" ]

[ "Ensure", "options", "passed", "to", "ShallowWrapper", "are", "valid", ".", "Throws", "otherwise", "." ]

[ "function", "getContextFromWrappingComponent", "(", "wrapper", ",", "adapter", ")", "{", "const", "rootFinder", "=", "deepRender", "(", "wrapper", ",", "wrapper", "[", "ROOT_FINDER", "]", ",", "adapter", ")", ";", "if", "(", "!", "rootFinder", ")", "{", "throw", "new", "Error", "(", "'`wrappingComponent` must render its children!'", ")", ";", "}", "return", "{", "legacyContext", ":", "rootFinder", "[", "OPTIONS", "]", ".", "context", ",", "providerValues", ":", "rootFinder", "[", "PROVIDER_VALUES", "]", ",", "}", ";", "}" ]

[ "Deep", "-", "renders", "the", "wrappingComponent", "and", "returns", "the", "context", "that", "should", "be", "accessible", "to", "the", "primary", "wrapper", "." ]

[ "function", "updatePrimaryRootContext", "(", "wrappingComponent", ")", "{", "const", "adapter", "=", "getAdapter", "(", "wrappingComponent", "[", "OPTIONS", "]", ")", ";", "const", "primaryWrapper", "=", "wrappingComponent", "[", "PRIMARY_WRAPPER", "]", ";", "const", "primaryRenderer", "=", "primaryWrapper", "[", "RENDERER", "]", ";", "const", "primaryNode", "=", "primaryRenderer", ".", "getNode", "(", ")", ";", "const", "{", "legacyContext", ",", "providerValues", ",", "}", "=", "getContextFromWrappingComponent", "(", "wrappingComponent", ",", "adapter", ")", ";", "const", "prevProviderValues", "=", "primaryWrapper", "[", "PROVIDER_VALUES", "]", ";", "primaryWrapper", ".", "setContext", "(", "{", "...", "wrappingComponent", "[", "PRIMARY_WRAPPER", "]", "[", "OPTIONS", "]", ".", "context", ",", "...", "legacyContext", ",", "}", ")", ";", "primaryWrapper", "[", "PROVIDER_VALUES", "]", "=", "new", "Map", "(", "[", "...", "prevProviderValues", ",", "...", "providerValues", "]", ")", ";", "if", "(", "typeof", "adapter", ".", "isContextConsumer", "===", "'function'", "&&", "adapter", ".", "isContextConsumer", "(", "primaryNode", ".", "type", ")", ")", "{", "const", "Consumer", "=", "primaryNode", ".", "type", ";", "// Adapters with an `isContextConsumer` method will definitely have a `getProviderFromConsumer`", "// method.", "const", "Provider", "=", "adapter", ".", "getProviderFromConsumer", "(", "Consumer", ")", ";", "const", "newValue", "=", "providerValues", ".", "get", "(", "Provider", ")", ";", "const", "oldValue", "=", "prevProviderValues", ".", "get", "(", "Provider", ")", ";", "// Use referential comparison like React", "if", "(", "newValue", "!==", "oldValue", ")", "{", "primaryWrapper", ".", "rerender", "(", ")", ";", "}", "}", "}" ]

[ "Updates", "the", "context", "of", "the", "primary", "wrapper", "when", "the", "wrappingComponent", "re", "-", "renders", "." ]

[ "function", "nodeMatchesToken", "(", "node", ",", "token", ",", "root", ")", "{", "if", "(", "node", "===", "null", "||", "typeof", "node", "===", "'string'", ")", "{", "return", "false", ";", "}", "switch", "(", "token", ".", "type", ")", "{", "/**\n * Match every node\n * @example '*' matches every node\n */", "case", "UNIVERSAL_SELECTOR", ":", "return", "true", ";", "/**\n * Match against the className prop\n * @example '.active' matches <div className='active' />\n */", "case", "CLASS_SELECTOR", ":", "return", "hasClassName", "(", "node", ",", "token", ".", "name", ")", ";", "/**\n * Simple type matching\n * @example 'div' matches <div />\n */", "case", "TYPE_SELECTOR", ":", "return", "nodeHasType", "(", "node", ",", "token", ".", "name", ")", ";", "/**\n * Match against the `id` prop\n * @example '#nav' matches <ul id=\"nav\" />\n */", "case", "ID_SELECTOR", ":", "return", "nodeHasId", "(", "node", ",", "token", ".", "name", ")", ";", "/**\n * Matches if an attribute is present, regardless\n * of its value\n * @example '[disabled]' matches <a disabled />\n */", "case", "ATTRIBUTE_PRESENCE", ":", "return", "matchAttributeSelector", "(", "node", ",", "token", ")", ";", "/**\n * Matches if an attribute is present with the\n * provided value\n * @example '[data-foo=foo]' matches <div data-foo=\"foo\" />\n */", "case", "ATTRIBUTE_VALUE", ":", "return", "matchAttributeSelector", "(", "node", ",", "token", ")", ";", "case", "PSEUDO_ELEMENT", ":", "case", "PSEUDO_CLASS", ":", "return", "matchPseudoSelector", "(", "node", ",", "token", ",", "root", ")", ";", "default", ":", "throw", "new", "Error", "(", "`", "${", "token", ".", "type", "}", "`", ")", ";", "}", "}" ]

[ "Takes", "a", "node", "and", "a", "token", "and", "determines", "if", "the", "node", "matches", "the", "predicate", "defined", "by", "the", "token", "." ]

[ "function", "buildPredicateFromToken", "(", "token", ",", "root", ")", "{", "return", "node", "=>", "token", ".", "body", ".", "every", "(", "bodyToken", "=>", "nodeMatchesToken", "(", "node", ",", "bodyToken", ",", "root", ")", ")", ";", "}" ]

[ "Returns", "a", "predicate", "function", "that", "checks", "if", "a", "node", "matches", "every", "token", "in", "the", "body", "of", "a", "selector", "token", "." ]

[ "function", "matchDescendant", "(", "nodes", ",", "predicate", ")", "{", "return", "uniqueReduce", "(", "(", "matches", ",", "node", ")", "=>", "matches", ".", "concat", "(", "treeFilter", "(", "node", ",", "predicate", ")", ")", ",", "flat", "(", "nodes", ".", "map", "(", "childrenOfNode", ")", ")", ",", ")", ";", "}" ]

[ "Matches", "all", "descendant", "nodes", "against", "a", "predicate", "returning", "those", "that", "match", "." ]

[ "function", "getEntry", "(", "knownHashes", ",", "url", ",", "revision", ")", "{", "// We're assuming that if the URL contains any of the known hashes", "// (either the short or full chunk hash or compilation hash) then it's", "// already revisioned, and we don't need additional out-of-band revisioning.", "if", "(", "!", "revision", "||", "knownHashes", ".", "some", "(", "(", "hash", ")", "=>", "url", ".", "includes", "(", "hash", ")", ")", ")", "{", "return", "{", "url", "}", ";", "}", "return", "{", "revision", ",", "url", "}", ";", "}" ]

[ "A", "single", "manifest", "entry", "that", "Workbox", "can", "precache", ".", "When", "possible", "we", "leave", "out", "the", "revision", "information", "which", "tells", "Workbox", "that", "the", "URL", "contains", "enough", "info", "to", "uniquely", "version", "the", "asset", "." ]

[ "function", "getKnownHashesFromAssets", "(", "assetMetadata", ")", "{", "const", "knownHashes", "=", "new", "Set", "(", ")", ";", "for", "(", "const", "metadata", "of", "Object", ".", "values", "(", "assetMetadata", ")", ")", "{", "knownHashes", ".", "add", "(", "metadata", ".", "hash", ")", ";", "}", "return", "knownHashes", ";", "}" ]

[ "Given", "an", "assetMetadata", "mapping", "returns", "a", "Set", "of", "all", "of", "the", "hashes", "that", "are", "associated", "with", "at", "least", "one", "asset", "." ]

[ "function", "getManifestEntriesFromCompilation", "(", "compilation", ",", "config", ")", "{", "const", "blacklistedChunkNames", "=", "config", ".", "excludeChunks", ";", "const", "whitelistedChunkNames", "=", "config", ".", "chunks", ";", "const", "{", "assets", ",", "chunks", "}", "=", "compilation", ";", "const", "{", "publicPath", "}", "=", "compilation", ".", "options", ".", "output", ";", "const", "assetMetadata", "=", "generateMetadataForAssets", "(", "assets", ",", "chunks", ")", ";", "const", "filteredAssetMetadata", "=", "filterAssets", "(", "assetMetadata", ",", "whitelistedChunkNames", ",", "blacklistedChunkNames", ")", ";", "const", "knownHashes", "=", "[", "compilation", ".", "hash", ",", "compilation", ".", "fullHash", ",", "...", "getKnownHashesFromAssets", "(", "filteredAssetMetadata", ")", ",", "]", ".", "filter", "(", "(", "hash", ")", "=>", "!", "!", "hash", ")", ";", "const", "manifestEntries", "=", "[", "]", ";", "for", "(", "const", "[", "file", ",", "metadata", "]", "of", "Object", ".", "entries", "(", "filteredAssetMetadata", ")", ")", "{", "// Filter based on test/include/exclude options set in the config,", "// following webpack's conventions.", "// This matches the behavior of, e.g., UglifyJS's webpack plugin.", "if", "(", "!", "ModuleFilenameHelpers", ".", "matchObject", "(", "config", ",", "file", ")", ")", "{", "continue", ";", "}", "const", "publicURL", "=", "resolveWebpackURL", "(", "publicPath", ",", "file", ")", ";", "const", "manifestEntry", "=", "getEntry", "(", "knownHashes", ",", "publicURL", ",", "metadata", ".", "hash", ")", ";", "manifestEntries", ".", "push", "(", "manifestEntry", ")", ";", "}", "return", "manifestEntries", ";", "}" ]

[ "Generate", "an", "array", "of", "manifest", "entries", "using", "webpack", "s", "compilation", "data", "." ]

[ "function", "getOptionsString", "(", "options", "=", "{", "}", ")", "{", "let", "plugins", "=", "[", "]", ";", "if", "(", "options", ".", "plugins", ")", "{", "// Using libs because JSON.stringify won't handle functions.", "plugins", "=", "options", ".", "plugins", ".", "map", "(", "stringifyWithoutComments", ")", ";", "delete", "options", ".", "plugins", ";", "}", "// Pull handler-specific config from the options object, since they are", "// not directly used to construct a Plugin instance. If set, need to be", "// passed as options to the handler constructor instead.", "const", "handlerOptionKeys", "=", "[", "'cacheName'", ",", "'networkTimeoutSeconds'", ",", "'fetchOptions'", ",", "'matchOptions'", ",", "]", ";", "const", "handlerOptions", "=", "{", "}", ";", "for", "(", "const", "key", "of", "handlerOptionKeys", ")", "{", "if", "(", "key", "in", "options", ")", "{", "handlerOptions", "[", "key", "]", "=", "options", "[", "key", "]", ";", "delete", "options", "[", "key", "]", ";", "}", "}", "const", "pluginsMapping", "=", "{", "backgroundSync", ":", "'workbox.backgroundSync.Plugin'", ",", "broadcastUpdate", ":", "'workbox.broadcastUpdate.Plugin'", ",", "expiration", ":", "'workbox.expiration.Plugin'", ",", "cacheableResponse", ":", "'workbox.cacheableResponse.Plugin'", ",", "}", ";", "for", "(", "const", "[", "pluginName", ",", "pluginConfig", "]", "of", "Object", ".", "entries", "(", "options", ")", ")", "{", "// Ensure that we have some valid configuration to pass to Plugin().", "if", "(", "Object", ".", "keys", "(", "pluginConfig", ")", ".", "length", "===", "0", ")", "{", "continue", ";", "}", "const", "pluginString", "=", "pluginsMapping", "[", "pluginName", "]", ";", "if", "(", "!", "pluginString", ")", "{", "throw", "new", "Error", "(", "`", "${", "errors", "[", "'bad-runtime-caching-config'", "]", "}", "${", "pluginName", "}", "`", ")", ";", "}", "let", "pluginCode", ";", "switch", "(", "pluginName", ")", "{", "// Special case logic for plugins that have a required parameter, and then", "// an additional optional config parameter.", "case", "'backgroundSync'", ":", "{", "const", "name", "=", "pluginConfig", ".", "name", ";", "pluginCode", "=", "`", "${", "pluginString", "}", "${", "JSON", ".", "stringify", "(", "name", ")", "}", "`", ";", "if", "(", "'options'", "in", "pluginConfig", ")", "{", "pluginCode", "+=", "`", "${", "stringifyWithoutComments", "(", "pluginConfig", ".", "options", ")", "}", "`", ";", "}", "pluginCode", "+=", "`", "`", ";", "break", ";", "}", "case", "'broadcastUpdate'", ":", "{", "const", "channelName", "=", "pluginConfig", ".", "channelName", ";", "const", "opts", "=", "Object", ".", "assign", "(", "{", "channelName", "}", ",", "pluginConfig", ".", "options", ")", ";", "pluginCode", "=", "`", "${", "pluginString", "}", "${", "stringifyWithoutComments", "(", "opts", ")", "}", "`", ";", "break", ";", "}", "// For plugins that just pass in an Object to the constructor, like", "// expiration and cacheableResponse", "default", ":", "{", "pluginCode", "=", "`", "${", "pluginString", "}", "${", "stringifyWithoutComments", "(", "pluginConfig", ")", "}", "`", ";", "}", "}", "plugins", ".", "push", "(", "pluginCode", ")", ";", "}", "if", "(", "Object", ".", "keys", "(", "handlerOptions", ")", ".", "length", ">", "0", "||", "plugins", ".", "length", ">", "0", ")", "{", "const", "optionsString", "=", "JSON", ".", "stringify", "(", "handlerOptions", ")", ".", "slice", "(", "1", ",", "-", "1", ")", ";", "return", "ol", "`", "${", "optionsString", "?", "optionsString", "+", "','", ":", "''", "}", "${", "plugins", ".", "join", "(", "', '", ")", "}", "`", ";", "}", "else", "{", "return", "''", ";", "}", "}" ]

[ "Given", "a", "set", "of", "options", "that", "configures", "sw", "-", "toolbox", "s", "behavior", "convert", "it", "into", "a", "string", "that", "would", "configure", "equivalent", "workbox", "-", "sw", "behavior", "." ]

[ "async", "function", "generateSWString", "(", "config", ")", "{", "// This check needs to be done before validation, since the deprecated options", "// will be renamed.", "const", "deprecationWarnings", "=", "checkForDeprecatedOptions", "(", "config", ")", ";", "const", "options", "=", "validate", "(", "config", ",", "generateSWStringSchema", ")", ";", "const", "{", "manifestEntries", ",", "warnings", "}", "=", "await", "getFileManifestEntries", "(", "options", ")", ";", "const", "swString", "=", "await", "populateSWTemplate", "(", "Object", ".", "assign", "(", "{", "manifestEntries", ",", "}", ",", "options", ")", ")", ";", "// Add in any deprecation warnings.", "warnings", ".", "push", "(", "...", "deprecationWarnings", ")", ";", "return", "{", "swString", ",", "warnings", "}", ";", "}" ]

[ "This", "method", "generates", "a", "service", "worker", "based", "on", "the", "configuration", "options", "provided", "." ]

[ "async", "function", "runBuildCommand", "(", "{", "command", ",", "config", ",", "watch", "}", ")", "{", "try", "{", "const", "{", "size", ",", "count", ",", "warnings", "}", "=", "await", "workboxBuild", "[", "command", "]", "(", "config", ")", ";", "for", "(", "const", "warning", "of", "warnings", ")", "{", "logger", ".", "warn", "(", "warning", ")", ";", "}", "logger", ".", "log", "(", "`", "${", "config", ".", "swDest", "}", "\\n", "`", "+", "`", "${", "count", "}", "${", "prettyBytes", "(", "size", ")", "}", "`", ")", ";", "if", "(", "watch", ")", "{", "logger", ".", "log", "(", "`", "\\n", "`", ")", ";", "}", "}", "catch", "(", "error", ")", "{", "// See https://github.com/hapijs/joi/blob/v11.3.4/API.md#errors", "if", "(", "typeof", "error", ".", "annotate", "===", "'function'", ")", "{", "throw", "new", "Error", "(", "`", "${", "errors", "[", "'config-validation-failed'", "]", "}", "\\n", "${", "error", ".", "annotate", "(", ")", "}", "`", ")", ";", "}", "logger", ".", "error", "(", "errors", "[", "'workbox-build-runtime-error'", "]", ")", ";", "throw", "error", ";", "}", "}" ]

[ "Runs", "the", "specified", "build", "command", "with", "the", "provided", "configuration", "." ]

[ "async", "function", "getManifest", "(", "config", ")", "{", "// This check needs to be done before validation, since the deprecated options", "// will be renamed.", "const", "deprecationWarnings", "=", "checkForDeprecatedOptions", "(", "config", ")", ";", "const", "options", "=", "validate", "(", "config", ",", "getManifestSchema", ")", ";", "const", "{", "manifestEntries", ",", "count", ",", "size", ",", "warnings", "}", "=", "await", "getFileManifestEntries", "(", "options", ")", ";", "// Add in any deprecation warnings.", "warnings", ".", "push", "(", "...", "deprecationWarnings", ")", ";", "return", "{", "manifestEntries", ",", "count", ",", "size", ",", "warnings", "}", ";", "}" ]

[ "This", "method", "returns", "a", "list", "of", "URLs", "to", "precache", "referred", "to", "as", "a", "precache", "manifest", "along", "with", "details", "about", "the", "number", "of", "entries", "and", "their", "size", "based", "on", "the", "options", "you", "provide", "." ]

[ "function", "Seeder", "(", "knex", ")", "{", "this", ".", "knex", "=", "knex", ";", "this", ".", "config", "=", "this", ".", "setConfig", "(", "knex", ".", "client", ".", "config", ".", "seeds", ")", ";", "}" ]

[ "The", "new", "seeds", "we", "re", "performing", "typically", "called", "from", "the", "knex", ".", "seed", "interface", "on", "the", "main", "knex", "object", ".", "Passes", "the", "knex", "instance", "performing", "the", "seeds", "." ]

[ "function", "JoinClause", "(", "table", ",", "type", ",", "schema", ")", "{", "this", ".", "schema", "=", "schema", ";", "this", ".", "table", "=", "table", ";", "this", ".", "joinType", "=", "type", ";", "this", ".", "and", "=", "this", ";", "this", ".", "clauses", "=", "[", "]", ";", "}" ]

[ "The", "JoinClause", "is", "an", "object", "holding", "any", "necessary", "info", "about", "a", "join", "including", "the", "type", "and", "any", "associated", "tables", "&", "columns", "being", "joined", "." ]

[ "function", "yyyymmddhhmmss", "(", ")", "{", "const", "d", "=", "new", "Date", "(", ")", ";", "return", "(", "d", ".", "getFullYear", "(", ")", ".", "toString", "(", ")", "+", "padDate", "(", "d", ".", "getMonth", "(", ")", "+", "1", ")", "+", "padDate", "(", "d", ".", "getDate", "(", ")", ")", "+", "padDate", "(", "d", ".", "getHours", "(", ")", ")", "+", "padDate", "(", "d", ".", "getMinutes", "(", ")", ")", "+", "padDate", "(", "d", ".", "getSeconds", "(", ")", ")", ")", ";", "}" ]

[ "Get", "a", "date", "object", "in", "the", "correct", "format", "without", "requiring", "a", "full", "out", "library", "like", "moment", ".", "js", "." ]

[ "function", "SchemaBuilder", "(", "client", ")", "{", "this", ".", "client", "=", "client", ";", "this", ".", "_sequence", "=", "[", "]", ";", "if", "(", "client", ".", "config", ")", "{", "this", ".", "_debug", "=", "client", ".", "config", ".", "debug", ";", "saveAsyncStack", "(", "this", ",", "4", ")", ";", "}", "}" ]

[ "Constructor", "for", "the", "builder", "instance", "typically", "called", "from", "knex", ".", "builder", "accepting", "the", "current", "knex", "instance", "and", "pulling", "out", "the", "client", "and", "grammar", "from", "the", "current", "knex", "instance", "." ]

[ "function", "Client", "(", "config", "=", "{", "}", ")", "{", "this", ".", "config", "=", "config", ";", "this", ".", "logger", "=", "new", "Logger", "(", "config", ")", ";", "//Client is a required field, so throw error if it's not supplied.", "//If 'this.dialect' is set, then this is a 'super()' call, in which case", "//'client' does not have to be set as it's already assigned on the client prototype.", "if", "(", "this", ".", "dialect", "&&", "!", "this", ".", "config", ".", "client", ")", "{", "this", ".", "logger", ".", "warn", "(", "`", "`", ")", ";", "}", "const", "dbClient", "=", "this", ".", "config", ".", "client", "||", "this", ".", "dialect", ";", "if", "(", "!", "dbClient", ")", "{", "throw", "new", "Error", "(", "`", "`", ")", ";", "}", "if", "(", "config", ".", "version", ")", "{", "this", ".", "version", "=", "config", ".", "version", ";", "}", "this", ".", "connectionSettings", "=", "cloneDeep", "(", "config", ".", "connection", "||", "{", "}", ")", ";", "if", "(", "this", ".", "driverName", "&&", "config", ".", "connection", ")", "{", "this", ".", "initializeDriver", "(", ")", ";", "if", "(", "!", "config", ".", "pool", "||", "(", "config", ".", "pool", "&&", "config", ".", "pool", ".", "max", "!==", "0", ")", ")", "{", "this", ".", "initializePool", "(", "config", ")", ";", "}", "}", "this", ".", "valueForUndefined", "=", "this", ".", "raw", "(", "'DEFAULT'", ")", ";", "if", "(", "config", ".", "useNullAsDefault", ")", "{", "this", ".", "valueForUndefined", "=", "null", ";", "}", "}" ]

[ "The", "base", "client", "provides", "the", "general", "structure", "for", "a", "dialect", "specific", "client", "object", "." ]

[ "function", "SQLite3_DDL", "(", "client", ",", "tableCompiler", ",", "pragma", ",", "connection", ")", "{", "this", ".", "client", "=", "client", ";", "this", ".", "tableCompiler", "=", "tableCompiler", ";", "this", ".", "pragma", "=", "pragma", ";", "this", ".", "tableNameRaw", "=", "this", ".", "tableCompiler", ".", "tableNameRaw", ";", "this", ".", "alteredName", "=", "uniqueId", "(", "'_knex_temp_alter'", ")", ";", "this", ".", "connection", "=", "connection", ";", "this", ".", "formatter", "=", "client", "&&", "client", ".", "config", "&&", "client", ".", "config", ".", "wrapIdentifier", "?", "client", ".", "config", ".", "wrapIdentifier", ":", "(", "value", ")", "=>", "value", ";", "}" ]

[ "So", "altering", "the", "schema", "in", "SQLite3", "is", "a", "major", "pain", ".", "We", "have", "our", "own", "object", "to", "deal", "with", "the", "renaming", "and", "altering", "the", "types", "for", "sqlite3", "things", "." ]

[ "function", "makeTransactor", "(", "trx", ",", "connection", ",", "trxClient", ")", "{", "const", "transactor", "=", "makeKnex", "(", "trxClient", ")", ";", "transactor", ".", "withUserParams", "=", "(", ")", "=>", "{", "throw", "new", "Error", "(", "'Cannot set user params on a transaction - it can only inherit params from main knex instance'", ")", ";", "}", ";", "transactor", ".", "isTransaction", "=", "true", ";", "transactor", ".", "userParams", "=", "trx", ".", "userParams", "||", "{", "}", ";", "transactor", ".", "transaction", "=", "function", "(", "container", ",", "options", ")", "{", "return", "trxClient", ".", "transaction", "(", "container", ",", "options", ",", "trx", ")", ";", "}", ";", "transactor", ".", "savepoint", "=", "function", "(", "container", ",", "options", ")", "{", "return", "transactor", ".", "transaction", "(", "container", ",", "options", ")", ";", "}", ";", "if", "(", "trx", ".", "client", ".", "transacting", ")", "{", "transactor", ".", "commit", "=", "(", "value", ")", "=>", "trx", ".", "release", "(", "connection", ",", "value", ")", ";", "transactor", ".", "rollback", "=", "(", "error", ")", "=>", "trx", ".", "rollbackTo", "(", "connection", ",", "error", ")", ";", "}", "else", "{", "transactor", ".", "commit", "=", "(", "value", ")", "=>", "trx", ".", "commit", "(", "connection", ",", "value", ")", ";", "transactor", ".", "rollback", "=", "(", "error", ")", "=>", "trx", ".", "rollback", "(", "connection", ",", "error", ")", ";", "}", "return", "transactor", ";", "}" ]

[ "The", "transactor", "is", "a", "full", "featured", "knex", "object", "with", "a", "commit", "a", "rollback", "and", "a", "savepoint", "function", ".", "The", "savepoint", "is", "just", "sugar", "for", "creating", "a", "new", "transaction", ".", "If", "the", "rollback", "is", "run", "inside", "a", "savepoint", "it", "rolls", "back", "to", "the", "last", "savepoint", "-", "otherwise", "it", "rolls", "back", "the", "transaction", "." ]

[ "function", "makeTxClient", "(", "trx", ",", "client", ",", "connection", ")", "{", "const", "trxClient", "=", "Object", ".", "create", "(", "client", ".", "constructor", ".", "prototype", ")", ";", "trxClient", ".", "version", "=", "client", ".", "version", ";", "trxClient", ".", "config", "=", "client", ".", "config", ";", "trxClient", ".", "driver", "=", "client", ".", "driver", ";", "trxClient", ".", "connectionSettings", "=", "client", ".", "connectionSettings", ";", "trxClient", ".", "transacting", "=", "true", ";", "trxClient", ".", "valueForUndefined", "=", "client", ".", "valueForUndefined", ";", "trxClient", ".", "logger", "=", "client", ".", "logger", ";", "trxClient", ".", "on", "(", "'query'", ",", "function", "(", "arg", ")", "{", "trx", ".", "emit", "(", "'query'", ",", "arg", ")", ";", "client", ".", "emit", "(", "'query'", ",", "arg", ")", ";", "}", ")", ";", "trxClient", ".", "on", "(", "'query-error'", ",", "function", "(", "err", ",", "obj", ")", "{", "trx", ".", "emit", "(", "'query-error'", ",", "err", ",", "obj", ")", ";", "client", ".", "emit", "(", "'query-error'", ",", "err", ",", "obj", ")", ";", "}", ")", ";", "trxClient", ".", "on", "(", "'query-response'", ",", "function", "(", "response", ",", "obj", ",", "builder", ")", "{", "trx", ".", "emit", "(", "'query-response'", ",", "response", ",", "obj", ",", "builder", ")", ";", "client", ".", "emit", "(", "'query-response'", ",", "response", ",", "obj", ",", "builder", ")", ";", "}", ")", ";", "const", "_query", "=", "trxClient", ".", "query", ";", "trxClient", ".", "query", "=", "function", "(", "conn", ",", "obj", ")", "{", "const", "completed", "=", "trx", ".", "isCompleted", "(", ")", ";", "return", "Promise", ".", "try", "(", "function", "(", ")", "{", "if", "(", "conn", "!==", "connection", ")", "throw", "new", "Error", "(", "'Invalid connection for transaction query.'", ")", ";", "if", "(", "completed", ")", "completedError", "(", "trx", ",", "obj", ")", ";", "return", "_query", ".", "call", "(", "trxClient", ",", "conn", ",", "obj", ")", ";", "}", ")", ";", "}", ";", "const", "_stream", "=", "trxClient", ".", "stream", ";", "trxClient", ".", "stream", "=", "function", "(", "conn", ",", "obj", ",", "stream", ",", "options", ")", "{", "const", "completed", "=", "trx", ".", "isCompleted", "(", ")", ";", "return", "Promise", ".", "try", "(", "function", "(", ")", "{", "if", "(", "conn", "!==", "connection", ")", "throw", "new", "Error", "(", "'Invalid connection for transaction query.'", ")", ";", "if", "(", "completed", ")", "completedError", "(", "trx", ",", "obj", ")", ";", "return", "_stream", ".", "call", "(", "trxClient", ",", "conn", ",", "obj", ",", "stream", ",", "options", ")", ";", "}", ")", ";", "}", ";", "trxClient", ".", "acquireConnection", "=", "function", "(", ")", "{", "return", "Promise", ".", "resolve", "(", "connection", ")", ";", "}", ";", "trxClient", ".", "releaseConnection", "=", "function", "(", ")", "{", "return", "Promise", ".", "resolve", "(", ")", ";", "}", ";", "return", "trxClient", ";", "}" ]

[ "We", "need", "to", "make", "a", "client", "object", "which", "always", "acquires", "the", "same", "connection", "and", "does", "not", "release", "back", "into", "the", "pool", "." ]

[ "function", "getTable", "(", "trxOrKnex", ",", "tableName", ",", "schemaName", ")", "{", "return", "schemaName", "?", "trxOrKnex", "(", "tableName", ")", ".", "withSchema", "(", "schemaName", ")", ":", "trxOrKnex", "(", "tableName", ")", ";", "}" ]

[ "Get", "schema", "-", "aware", "query", "builder", "for", "a", "given", "table", "and", "schema", "name" ]

[ "function", "validateMigrationList", "(", "migrationSource", ",", "migrations", ")", "{", "const", "all", "=", "migrations", "[", "0", "]", ";", "const", "completed", "=", "migrations", "[", "1", "]", ";", "const", "diff", "=", "getMissingMigrations", "(", "migrationSource", ",", "completed", ",", "all", ")", ";", "if", "(", "!", "isEmpty", "(", "diff", ")", ")", "{", "throw", "new", "Error", "(", "`", "${", "diff", ".", "join", "(", "', '", ")", "}", "`", ")", ";", "}", "}" ]

[ "Validates", "that", "migrations", "are", "present", "in", "the", "appropriate", "directories", "." ]

[ "function", "findAccessibleSync", "(", "logprefix", ",", "dir", ",", "candidates", ")", "{", "for", "(", "var", "next", "=", "0", ";", "next", "<", "candidates", ".", "length", ";", "next", "++", ")", "{", "var", "candidate", "=", "path", ".", "resolve", "(", "dir", ",", "candidates", "[", "next", "]", ")", "try", "{", "var", "fd", "=", "fs", ".", "openSync", "(", "candidate", ",", "'r'", ")", "}", "catch", "(", "e", ")", "{", "// this candidate was not found or not readable, do nothing", "log", ".", "silly", "(", "logprefix", ",", "'Could not open %s: %s'", ",", "candidate", ",", "e", ".", "message", ")", "continue", "}", "fs", ".", "closeSync", "(", "fd", ")", "log", ".", "silly", "(", "logprefix", ",", "'Found readable %s'", ",", "candidate", ")", "return", "candidate", "}", "return", "undefined", "}" ]

[ "Returns", "the", "first", "file", "or", "directory", "from", "an", "array", "of", "candidates", "that", "is", "readable", "by", "the", "current", "user", "or", "undefined", "if", "none", "of", "the", "candidates", "are", "readable", "." ]

[ "function", "findPython", "(", ")", "{", "const", "SKIP", "=", "0", ",", "FAIL", "=", "1", "const", "toCheck", "=", "[", "{", "before", ":", "(", ")", "=>", "{", "if", "(", "!", "this", ".", "configPython", ")", "{", "this", ".", "addLog", "(", "'Python is not set from command line or npm configuration'", ")", "return", "SKIP", "}", "this", ".", "addLog", "(", "'checking Python explicitly set from command line or '", "+", "'npm configuration'", ")", "this", ".", "addLog", "(", "'- \"--python=\" or \"npm config get python\" is '", "+", "`", "${", "this", ".", "configPython", "}", "`", ")", "}", ",", "check", ":", "this", ".", "checkCommand", ",", "arg", ":", "this", ".", "configPython", ",", "}", ",", "{", "before", ":", "(", ")", "=>", "{", "if", "(", "!", "this", ".", "env", ".", "PYTHON", ")", "{", "this", ".", "addLog", "(", "'Python is not set from environment variable PYTHON'", ")", "return", "SKIP", "}", "this", ".", "addLog", "(", "'checking Python explicitly set from environment variable PYTHON'", ")", "this", ".", "addLog", "(", "`", "${", "this", ".", "env", ".", "PYTHON", "}", "`", ")", "}", ",", "check", ":", "this", ".", "checkCommand", ",", "arg", ":", "this", ".", "env", ".", "PYTHON", ",", "}", ",", "{", "before", ":", "(", ")", "=>", "{", "this", ".", "addLog", "(", "'checking if \"python2\" can be used'", ")", "}", ",", "check", ":", "this", ".", "checkCommand", ",", "arg", ":", "'python2'", ",", "}", ",", "{", "before", ":", "(", ")", "=>", "{", "this", ".", "addLog", "(", "'checking if \"python\" can be used'", ")", "}", ",", "check", ":", "this", ".", "checkCommand", ",", "arg", ":", "'python'", ",", "}", ",", "{", "before", ":", "(", ")", "=>", "{", "if", "(", "!", "this", ".", "win", ")", "{", "// Everything after this is Windows specific", "return", "FAIL", "}", "this", ".", "addLog", "(", "'checking if the py launcher can be used to find Python 2'", ")", "}", ",", "check", ":", "this", ".", "checkPyLauncher", ",", "}", ",", "{", "before", ":", "(", ")", "=>", "{", "this", ".", "addLog", "(", "'checking if Python 2 is installed in the default location'", ")", "}", ",", "check", ":", "this", ".", "checkExecPath", ",", "arg", ":", "this", ".", "defaultLocation", ",", "}", ",", "]", "function", "runChecks", "(", "err", ")", "{", "this", ".", "log", ".", "silly", "(", "'runChecks: err = %j'", ",", "err", "&&", "err", ".", "stack", "||", "err", ")", "const", "check", "=", "toCheck", ".", "shift", "(", ")", "if", "(", "!", "check", ")", "{", "return", "this", ".", "fail", "(", ")", "}", "const", "before", "=", "check", ".", "before", ".", "apply", "(", "this", ")", "if", "(", "before", "===", "SKIP", ")", "{", "return", "runChecks", ".", "apply", "(", "this", ")", "}", "if", "(", "before", "===", "FAIL", ")", "{", "return", "this", ".", "fail", "(", ")", "}", "const", "args", "=", "[", "runChecks", ".", "bind", "(", "this", ")", "]", "if", "(", "check", ".", "arg", ")", "{", "args", ".", "unshift", "(", "check", ".", "arg", ")", "}", "check", ".", "check", ".", "apply", "(", "this", ",", "args", ")", "}", "runChecks", ".", "apply", "(", "this", ")", "}" ]

[ "Find", "Python", "by", "trying", "a", "sequence", "of", "possibilities", ".", "Ignore", "errors", "keep", "trying", "until", "Python", "is", "found", "." ]

[ "function", "checkExecPath", "(", "execPath", ",", "errorCallback", ")", "{", "this", ".", "log", ".", "verbose", "(", "`", "${", "execPath", "}", "`", ")", "this", ".", "run", "(", "execPath", ",", "this", ".", "argsVersion", ",", "false", ",", "function", "(", "err", ",", "version", ")", "{", "// Possible outcomes:", "// - Error: executable can not be run (likely meaning the command wasn't", "// a Python executable and the previous command produced gibberish)", "// - Gibberish: somehow the last command produced an executable path,", "// this will fail when verifying the version", "// - Version of the Python executable", "if", "(", "err", ")", "{", "this", ".", "addLog", "(", "`", "${", "execPath", "}", "`", ")", "return", "errorCallback", "(", "err", ")", "}", "this", ".", "addLog", "(", "`", "${", "version", "}", "`", ")", "const", "range", "=", "semver", ".", "Range", "(", "this", ".", "semverRange", ")", "var", "valid", "=", "false", "try", "{", "valid", "=", "range", ".", "test", "(", "version", ")", "}", "catch", "(", "err", ")", "{", "this", ".", "log", ".", "silly", "(", "'range.test() threw:\\n%s'", ",", "err", ".", "stack", ")", "this", ".", "addLog", "(", "`", "${", "execPath", "}", "`", ")", "this", ".", "addLog", "(", "'- is it a Python executable?'", ")", "return", "errorCallback", "(", "err", ")", "}", "if", "(", "!", "valid", ")", "{", "this", ".", "addLog", "(", "`", "${", "version", "}", "${", "this", ".", "semverRange", "}", "`", ")", "this", ".", "addLog", "(", "'- THIS VERSION OF PYTHON IS NOT SUPPORTED'", ")", "return", "errorCallback", "(", "new", "Error", "(", "`", "${", "version", "}", "`", ")", ")", "}", "this", ".", "succeed", "(", "execPath", ",", "version", ")", "}", ".", "bind", "(", "this", ")", ")", "}" ]

[ "Check", "if", "a", "Python", "executable", "is", "the", "correct", "version", "to", "use", ".", "Will", "exit", "the", "Python", "finder", "on", "success", "." ]

[ "function", "run", "(", "exec", ",", "args", ",", "shell", ",", "callback", ")", "{", "var", "env", "=", "extend", "(", "{", "}", ",", "this", ".", "env", ")", "env", ".", "TERM", "=", "'dumb'", "const", "opts", "=", "{", "env", ":", "env", ",", "shell", ":", "shell", "}", "this", ".", "log", ".", "silly", "(", "'execFile: exec = %j'", ",", "exec", ")", "this", ".", "log", ".", "silly", "(", "'execFile: args = %j'", ",", "args", ")", "this", ".", "log", ".", "silly", "(", "'execFile: opts = %j'", ",", "opts", ")", "try", "{", "this", ".", "execFile", "(", "exec", ",", "args", ",", "opts", ",", "execFileCallback", ".", "bind", "(", "this", ")", ")", "}", "catch", "(", "err", ")", "{", "this", ".", "log", ".", "silly", "(", "'execFile: threw:\\n%s'", ",", "err", ".", "stack", ")", "return", "callback", "(", "err", ")", "}", "function", "execFileCallback", "(", "err", ",", "stdout", ",", "stderr", ")", "{", "this", ".", "log", ".", "silly", "(", "'execFile result: err = %j'", ",", "err", "&&", "err", ".", "stack", "||", "err", ")", "this", ".", "log", ".", "silly", "(", "'execFile result: stdout = %j'", ",", "stdout", ")", "this", ".", "log", ".", "silly", "(", "'execFile result: stderr = %j'", ",", "stderr", ")", "if", "(", "err", ")", "{", "return", "callback", "(", "err", ")", "}", "const", "execPath", "=", "stdout", ".", "trim", "(", ")", "callback", "(", "null", ",", "execPath", ")", "}", "}" ]

[ "Run", "an", "executable", "or", "shell", "command", "trimming", "the", "output", "." ]

[ "function", "cb", "(", "err", ")", "{", "if", "(", "cb", ".", "done", ")", "return", "cb", ".", "done", "=", "true", "if", "(", "err", ")", "{", "log", ".", "warn", "(", "'install'", ",", "'got an error, rolling back install'", ")", "// roll-back the install if anything went wrong", "gyp", ".", "commands", ".", "remove", "(", "[", "release", ".", "versionDir", "]", ",", "function", "(", ")", "{", "callback", "(", "err", ")", "}", ")", "}", "else", "{", "callback", "(", "null", ",", "release", ".", "version", ")", "}", "}" ]

[ "ensure", "no", "double", "-", "callbacks", "happen" ]

[ "function", "afterTarball", "(", ")", "{", "if", "(", "badDownload", ")", "return", "if", "(", "extractCount", "===", "0", ")", "{", "return", "cb", "(", "new", "Error", "(", "'There was a fatal problem while downloading/extracting the tarball'", ")", ")", "}", "log", ".", "verbose", "(", "'tarball'", ",", "'done parsing tarball'", ")", "var", "async", "=", "0", "if", "(", "win", ")", "{", "// need to download node.lib", "async", "++", "downloadNodeLib", "(", "deref", ")", "}", "// write the \"installVersion\" file", "async", "++", "var", "installVersionPath", "=", "path", ".", "resolve", "(", "devDir", ",", "'installVersion'", ")", "fs", ".", "writeFile", "(", "installVersionPath", ",", "gyp", ".", "package", ".", "installVersion", "+", "'\\n'", ",", "deref", ")", "// Only download SHASUMS.txt if not using tarPath override", "if", "(", "!", "tarPath", ")", "{", "// download SHASUMS.txt", "async", "++", "downloadShasums", "(", "deref", ")", "}", "if", "(", "async", "===", "0", ")", "{", "// no async tasks required", "cb", "(", ")", "}", "function", "deref", "(", "err", ")", "{", "if", "(", "err", ")", "return", "cb", "(", "err", ")", "async", "--", "if", "(", "!", "async", ")", "{", "log", ".", "verbose", "(", "'download contents checksum'", ",", "JSON", ".", "stringify", "(", "contentShasums", ")", ")", "// check content shasums", "for", "(", "var", "k", "in", "contentShasums", ")", "{", "log", ".", "verbose", "(", "'validating download checksum for '", "+", "k", ",", "'(%s == %s)'", ",", "contentShasums", "[", "k", "]", ",", "expectShasums", "[", "k", "]", ")", "if", "(", "contentShasums", "[", "k", "]", "!==", "expectShasums", "[", "k", "]", ")", "{", "cb", "(", "new", "Error", "(", "k", "+", "' local checksum '", "+", "contentShasums", "[", "k", "]", "+", "' not match remote '", "+", "expectShasums", "[", "k", "]", ")", ")", "return", "}", "}", "cb", "(", ")", "}", "}", "}" ]

[ "invoked", "after", "the", "tarball", "has", "finished", "being", "extracted" ]

[ "function", "loadConfigGypi", "(", ")", "{", "var", "configPath", "=", "path", ".", "resolve", "(", "'build'", ",", "'config.gypi'", ")", "fs", ".", "readFile", "(", "configPath", ",", "'utf8'", ",", "function", "(", "err", ",", "data", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", ".", "code", "==", "'ENOENT'", ")", "{", "callback", "(", "new", "Error", "(", "'You must run `node-gyp configure` first!'", ")", ")", "}", "else", "{", "callback", "(", "err", ")", "}", "return", "}", "config", "=", "JSON", ".", "parse", "(", "data", ".", "replace", "(", "/", "\\#.+\\n", "/", ",", "''", ")", ")", "// get the 'arch', 'buildType', and 'nodeDir' vars from the config", "buildType", "=", "config", ".", "target_defaults", ".", "default_configuration", "arch", "=", "config", ".", "variables", ".", "target_arch", "nodeDir", "=", "config", ".", "variables", ".", "nodedir", "if", "(", "'debug'", "in", "gyp", ".", "opts", ")", "{", "buildType", "=", "gyp", ".", "opts", ".", "debug", "?", "'Debug'", ":", "'Release'", "}", "if", "(", "!", "buildType", ")", "{", "buildType", "=", "'Release'", "}", "log", ".", "verbose", "(", "'build type'", ",", "buildType", ")", "log", ".", "verbose", "(", "'architecture'", ",", "arch", ")", "log", ".", "verbose", "(", "'node dev dir'", ",", "nodeDir", ")", "if", "(", "win", ")", "{", "findSolutionFile", "(", ")", "}", "else", "{", "doWhich", "(", ")", "}", "}", ")", "}" ]

[ "Load", "the", "config", ".", "gypi", "file", "that", "was", "generated", "during", "configure", "." ]

[ "function", "findMsbuild", "(", ")", "{", "log", ".", "verbose", "(", "'could not find \"msbuild.exe\" in PATH - finding location in registry'", ")", "var", "notfoundErr", "=", "'Can\\'t find \"msbuild.exe\". Do you have Microsoft Visual Studio C++ 2008+ installed?'", "var", "cmd", "=", "'reg query \"HKLM\\\\Software\\\\Microsoft\\\\MSBuild\\\\ToolsVersions\" /s'", "if", "(", "process", ".", "arch", "!==", "'ia32'", ")", "cmd", "+=", "' /reg:32'", "exec", "(", "cmd", ",", "function", "(", "err", ",", "stdout", ")", "{", "if", "(", "err", ")", "{", "return", "callback", "(", "new", "Error", "(", "err", ".", "message", "+", "'\\n'", "+", "notfoundErr", ")", ")", "}", "var", "reVers", "=", "/", "ToolsVersions\\\\([^\\\\]+)$", "/", "i", ",", "rePath", "=", "/", "\\r\\n[ \\t]+MSBuildToolsPath[ \\t]+REG_SZ[ \\t]+([^\\r]+)", "/", "i", ",", "msbuilds", "=", "[", "]", ",", "r", ",", "msbuildPath", "stdout", ".", "split", "(", "'\\r\\n\\r\\n'", ")", ".", "forEach", "(", "function", "(", "l", ")", "{", "if", "(", "!", "l", ")", "return", "l", "=", "l", ".", "trim", "(", ")", "if", "(", "r", "=", "reVers", ".", "exec", "(", "l", ".", "substring", "(", "0", ",", "l", ".", "indexOf", "(", "'\\r\\n'", ")", ")", ")", ")", "{", "var", "ver", "=", "parseFloat", "(", "r", "[", "1", "]", ",", "10", ")", "if", "(", "ver", ">=", "3.5", ")", "{", "if", "(", "r", "=", "rePath", ".", "exec", "(", "l", ")", ")", "{", "msbuilds", ".", "push", "(", "{", "version", ":", "ver", ",", "path", ":", "r", "[", "1", "]", "}", ")", "}", "}", "}", "}", ")", "msbuilds", ".", "sort", "(", "function", "(", "x", ",", "y", ")", "{", "return", "(", "x", ".", "version", "<", "y", ".", "version", "?", "-", "1", ":", "1", ")", "}", ")", ";", "(", "function", "verifyMsbuild", "(", ")", "{", "if", "(", "!", "msbuilds", ".", "length", ")", "return", "callback", "(", "new", "Error", "(", "notfoundErr", ")", ")", "msbuildPath", "=", "path", ".", "resolve", "(", "msbuilds", ".", "pop", "(", ")", ".", "path", ",", "'msbuild.exe'", ")", "fs", ".", "stat", "(", "msbuildPath", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", ".", "code", "==", "'ENOENT'", ")", "{", "if", "(", "msbuilds", ".", "length", ")", "{", "return", "verifyMsbuild", "(", ")", "}", "else", "{", "callback", "(", "new", "Error", "(", "notfoundErr", ")", ")", "}", "}", "else", "{", "callback", "(", "err", ")", "}", "return", "}", "command", "=", "msbuildPath", "doBuild", "(", ")", "}", ")", "}", ")", "(", ")", "}", ")", "}" ]

[ "Search", "for", "the", "location", "of", "msbuild", ".", "exe", "file", "on", "Windows", "." ]

[ "function", "doBuild", "(", ")", "{", "// Enable Verbose build", "var", "verbose", "=", "log", ".", "levels", "[", "log", ".", "level", "]", "<=", "log", ".", "levels", ".", "verbose", "if", "(", "!", "win", "&&", "verbose", ")", "{", "argv", ".", "push", "(", "'V=1'", ")", "}", "if", "(", "win", "&&", "!", "verbose", ")", "{", "argv", ".", "push", "(", "'/clp:Verbosity=minimal'", ")", "}", "if", "(", "win", ")", "{", "// Turn off the Microsoft logo on Windows", "argv", ".", "push", "(", "'/nologo'", ")", "}", "// Specify the build type, Release by default", "if", "(", "win", ")", "{", "// Convert .gypi config target_arch to MSBuild /Platform", "// Since there are many ways to state '32-bit Intel', default to it.", "// N.B. msbuild's Condition string equality tests are case-insensitive.", "var", "archLower", "=", "arch", ".", "toLowerCase", "(", ")", "var", "p", "=", "archLower", "===", "'x64'", "?", "'x64'", ":", "(", "archLower", "===", "'arm'", "?", "'ARM'", ":", "(", "archLower", "===", "'arm64'", "?", "'ARM64'", ":", "'Win32'", ")", ")", "argv", ".", "push", "(", "'/p:Configuration='", "+", "buildType", "+", "';Platform='", "+", "p", ")", "if", "(", "jobs", ")", "{", "var", "j", "=", "parseInt", "(", "jobs", ",", "10", ")", "if", "(", "!", "isNaN", "(", "j", ")", "&&", "j", ">", "0", ")", "{", "argv", ".", "push", "(", "'/m:'", "+", "j", ")", "}", "else", "if", "(", "jobs", ".", "toUpperCase", "(", ")", "===", "'MAX'", ")", "{", "argv", ".", "push", "(", "'/m:'", "+", "require", "(", "'os'", ")", ".", "cpus", "(", ")", ".", "length", ")", "}", "}", "}", "else", "{", "argv", ".", "push", "(", "'BUILDTYPE='", "+", "buildType", ")", "// Invoke the Makefile in the 'build' dir.", "argv", ".", "push", "(", "'-C'", ")", "argv", ".", "push", "(", "'build'", ")", "if", "(", "jobs", ")", "{", "var", "j", "=", "parseInt", "(", "jobs", ",", "10", ")", "if", "(", "!", "isNaN", "(", "j", ")", "&&", "j", ">", "0", ")", "{", "argv", ".", "push", "(", "'--jobs'", ")", "argv", ".", "push", "(", "j", ")", "}", "else", "if", "(", "jobs", ".", "toUpperCase", "(", ")", "===", "'MAX'", ")", "{", "argv", ".", "push", "(", "'--jobs'", ")", "argv", ".", "push", "(", "require", "(", "'os'", ")", ".", "cpus", "(", ")", ".", "length", ")", "}", "}", "}", "if", "(", "win", ")", "{", "// did the user specify their own .sln file?", "var", "hasSln", "=", "argv", ".", "some", "(", "function", "(", "arg", ")", "{", "return", "path", ".", "extname", "(", "arg", ")", "==", "'.sln'", "}", ")", "if", "(", "!", "hasSln", ")", "{", "argv", ".", "unshift", "(", "gyp", ".", "opts", ".", "solution", "||", "guessedSolution", ")", "}", "}", "var", "proc", "=", "gyp", ".", "spawn", "(", "command", ",", "argv", ")", "proc", ".", "on", "(", "'exit'", ",", "onExit", ")", "}" ]

[ "Actually", "spawn", "the", "process", "and", "compile", "the", "module", "." ]

[ "function", "inflateOnData", "(", "chunk", ")", "{", "this", "[", "kTotalLength", "]", "+=", "chunk", ".", "length", ";", "if", "(", "this", "[", "kPerMessageDeflate", "]", ".", "_maxPayload", "<", "1", "||", "this", "[", "kTotalLength", "]", "<=", "this", "[", "kPerMessageDeflate", "]", ".", "_maxPayload", ")", "{", "this", "[", "kBuffers", "]", ".", "push", "(", "chunk", ")", ";", "return", ";", "}", "this", "[", "kError", "]", "=", "new", "RangeError", "(", "'Max payload size exceeded'", ")", ";", "this", "[", "kError", "]", "[", "kStatusCode", "]", "=", "1009", ";", "this", ".", "removeListener", "(", "'data'", ",", "inflateOnData", ")", ";", "this", ".", "reset", "(", ")", ";", "}" ]

[ "The", "listener", "of", "the", "zlib", ".", "InflateRaw", "stream", "data", "event", "." ]

[ "function", "error", "(", "ErrorCtor", ",", "message", ",", "prefix", ",", "statusCode", ")", "{", "const", "err", "=", "new", "ErrorCtor", "(", "prefix", "?", "`", "${", "message", "}", "`", ":", "message", ")", ";", "Error", ".", "captureStackTrace", "(", "err", ",", "error", ")", ";", "err", "[", "kStatusCode", "]", "=", "statusCode", ";", "return", "err", ";", "}" ]

[ "Builds", "an", "error", "object", "." ]

[ "function", "concat", "(", "list", ",", "totalLength", ")", "{", "if", "(", "list", ".", "length", "===", "0", ")", "return", "EMPTY_BUFFER", ";", "if", "(", "list", ".", "length", "===", "1", ")", "return", "list", "[", "0", "]", ";", "const", "target", "=", "Buffer", ".", "allocUnsafe", "(", "totalLength", ")", ";", "let", "offset", "=", "0", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "list", ".", "length", ";", "i", "++", ")", "{", "const", "buf", "=", "list", "[", "i", "]", ";", "buf", ".", "copy", "(", "target", ",", "offset", ")", ";", "offset", "+=", "buf", ".", "length", ";", "}", "return", "target", ";", "}" ]

[ "Merges", "an", "array", "of", "buffers", "into", "a", "new", "buffer", "." ]

[ "function", "_mask", "(", "source", ",", "mask", ",", "output", ",", "offset", ",", "length", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "output", "[", "offset", "+", "i", "]", "=", "source", "[", "i", "]", "^", "mask", "[", "i", "&", "3", "]", ";", "}", "}" ]

[ "Masks", "a", "buffer", "using", "the", "given", "mask", "." ]

[ "function", "_unmask", "(", "buffer", ",", "mask", ")", "{", "// Required until https://github.com/nodejs/node/issues/9006 is resolved.", "const", "length", "=", "buffer", ".", "length", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "buffer", "[", "i", "]", "^=", "mask", "[", "i", "&", "3", "]", ";", "}", "}" ]

[ "Unmasks", "a", "buffer", "using", "the", "given", "mask", "." ]

[ "function", "toArrayBuffer", "(", "buf", ")", "{", "if", "(", "buf", ".", "byteLength", "===", "buf", ".", "buffer", ".", "byteLength", ")", "{", "return", "buf", ".", "buffer", ";", "}", "return", "buf", ".", "buffer", ".", "slice", "(", "buf", ".", "byteOffset", ",", "buf", ".", "byteOffset", "+", "buf", ".", "byteLength", ")", ";", "}" ]

[ "Converts", "a", "buffer", "to", "an", "ArrayBuffer", "." ]

[ "function", "toBuffer", "(", "data", ")", "{", "toBuffer", ".", "readOnly", "=", "true", ";", "if", "(", "Buffer", ".", "isBuffer", "(", "data", ")", ")", "return", "data", ";", "let", "buf", ";", "if", "(", "data", "instanceof", "ArrayBuffer", ")", "{", "buf", "=", "Buffer", ".", "from", "(", "data", ")", ";", "}", "else", "if", "(", "ArrayBuffer", ".", "isView", "(", "data", ")", ")", "{", "buf", "=", "viewToBuffer", "(", "data", ")", ";", "}", "else", "{", "buf", "=", "Buffer", ".", "from", "(", "data", ")", ";", "toBuffer", ".", "readOnly", "=", "false", ";", "}", "return", "buf", ";", "}" ]

[ "Converts", "data", "to", "a", "Buffer", "." ]

[ "function", "viewToBuffer", "(", "view", ")", "{", "const", "buf", "=", "Buffer", ".", "from", "(", "view", ".", "buffer", ")", ";", "if", "(", "view", ".", "byteLength", "!==", "view", ".", "buffer", ".", "byteLength", ")", "{", "return", "buf", ".", "slice", "(", "view", ".", "byteOffset", ",", "view", ".", "byteOffset", "+", "view", ".", "byteLength", ")", ";", "}", "return", "buf", ";", "}" ]

[ "Converts", "an", "ArrayBuffer", "view", "into", "a", "buffer", "." ]

[ "function", "abortHandshake", "(", "socket", ",", "code", ",", "message", ",", "headers", ")", "{", "if", "(", "socket", ".", "writable", ")", "{", "message", "=", "message", "||", "STATUS_CODES", "[", "code", "]", ";", "headers", "=", "{", "Connection", ":", "'close'", ",", "'Content-type'", ":", "'text/html'", ",", "'Content-Length'", ":", "Buffer", ".", "byteLength", "(", "message", ")", ",", "...", "headers", "}", ";", "socket", ".", "write", "(", "`", "${", "code", "}", "${", "STATUS_CODES", "[", "code", "]", "}", "\\r", "\\n", "`", "+", "Object", ".", "keys", "(", "headers", ")", ".", "map", "(", "(", "h", ")", "=>", "`", "${", "h", "}", "${", "headers", "[", "h", "]", "}", "`", ")", ".", "join", "(", "'\\r\\n'", ")", "+", "'\\r\\n\\r\\n'", "+", "message", ")", ";", "}", "socket", ".", "removeListener", "(", "'error'", ",", "socketOnError", ")", ";", "socket", ".", "destroy", "(", ")", ";", "}" ]

[ "Close", "the", "connection", "when", "preconditions", "are", "not", "fulfilled", "." ]

[ "function", "push", "(", "dest", ",", "name", ",", "elem", ")", "{", "if", "(", "dest", "[", "name", "]", "===", "undefined", ")", "dest", "[", "name", "]", "=", "[", "elem", "]", ";", "else", "dest", "[", "name", "]", ".", "push", "(", "elem", ")", ";", "}" ]

[ "Adds", "an", "offer", "to", "the", "map", "of", "extension", "offers", "or", "a", "parameter", "to", "the", "map", "of", "parameters", "." ]

[ "function", "format", "(", "extensions", ")", "{", "return", "Object", ".", "keys", "(", "extensions", ")", ".", "map", "(", "(", "extension", ")", "=>", "{", "let", "configurations", "=", "extensions", "[", "extension", "]", ";", "if", "(", "!", "Array", ".", "isArray", "(", "configurations", ")", ")", "configurations", "=", "[", "configurations", "]", ";", "return", "configurations", ".", "map", "(", "(", "params", ")", "=>", "{", "return", "[", "extension", "]", ".", "concat", "(", "Object", ".", "keys", "(", "params", ")", ".", "map", "(", "(", "k", ")", "=>", "{", "let", "values", "=", "params", "[", "k", "]", ";", "if", "(", "!", "Array", ".", "isArray", "(", "values", ")", ")", "values", "=", "[", "values", "]", ";", "return", "values", ".", "map", "(", "(", "v", ")", "=>", "(", "v", "===", "true", "?", "k", ":", "`", "${", "k", "}", "${", "v", "}", "`", ")", ")", ".", "join", "(", "'; '", ")", ";", "}", ")", ")", ".", "join", "(", "'; '", ")", ";", "}", ")", ".", "join", "(", "', '", ")", ";", "}", ")", ".", "join", "(", "', '", ")", ";", "}" ]

[ "Builds", "the", "Sec", "-", "WebSocket", "-", "Extensions", "header", "field", "value", "." ]

[ "function", "tlsConnect", "(", "options", ")", "{", "options", ".", "path", "=", "undefined", ";", "options", ".", "servername", "=", "options", ".", "servername", "||", "options", ".", "host", ";", "return", "tls", ".", "connect", "(", "options", ")", ";", "}" ]

[ "Create", "a", "tls", ".", "TLSSocket", "and", "initiate", "a", "connection", "." ]

[ "function", "abortHandshake", "(", "websocket", ",", "stream", ",", "message", ")", "{", "websocket", ".", "readyState", "=", "WebSocket", ".", "CLOSING", ";", "const", "err", "=", "new", "Error", "(", "message", ")", ";", "Error", ".", "captureStackTrace", "(", "err", ",", "abortHandshake", ")", ";", "if", "(", "stream", ".", "setHeader", ")", "{", "stream", ".", "abort", "(", ")", ";", "stream", ".", "once", "(", "'abort'", ",", "websocket", ".", "emitClose", ".", "bind", "(", "websocket", ")", ")", ";", "websocket", ".", "emit", "(", "'error'", ",", "err", ")", ";", "}", "else", "{", "stream", ".", "destroy", "(", "err", ")", ";", "stream", ".", "once", "(", "'error'", ",", "websocket", ".", "emit", ".", "bind", "(", "websocket", ",", "'error'", ")", ")", ";", "stream", ".", "once", "(", "'close'", ",", "websocket", ".", "emitClose", ".", "bind", "(", "websocket", ")", ")", ";", "}", "}" ]

[ "Abort", "the", "handshake", "and", "emit", "an", "error", "." ]

[ "function", "receiverOnConclude", "(", "code", ",", "reason", ")", "{", "const", "websocket", "=", "this", "[", "kWebSocket", "]", ";", "websocket", ".", "_socket", ".", "removeListener", "(", "'data'", ",", "socketOnData", ")", ";", "websocket", ".", "_socket", ".", "resume", "(", ")", ";", "websocket", ".", "_closeFrameReceived", "=", "true", ";", "websocket", ".", "_closeMessage", "=", "reason", ";", "websocket", ".", "_closeCode", "=", "code", ";", "if", "(", "code", "===", "1005", ")", "websocket", ".", "close", "(", ")", ";", "else", "websocket", ".", "close", "(", "code", ",", "reason", ")", ";", "}" ]

[ "The", "listener", "of", "the", "Receiver", "conclude", "event", "." ]

[ "function", "receiverOnError", "(", "err", ")", "{", "const", "websocket", "=", "this", "[", "kWebSocket", "]", ";", "websocket", ".", "_socket", ".", "removeListener", "(", "'data'", ",", "socketOnData", ")", ";", "websocket", ".", "readyState", "=", "WebSocket", ".", "CLOSING", ";", "websocket", ".", "_closeCode", "=", "err", "[", "kStatusCode", "]", ";", "websocket", ".", "emit", "(", "'error'", ",", "err", ")", ";", "websocket", ".", "_socket", ".", "destroy", "(", ")", ";", "}" ]

[ "The", "listener", "of", "the", "Receiver", "error", "event", "." ]

[ "function", "receiverOnPing", "(", "data", ")", "{", "const", "websocket", "=", "this", "[", "kWebSocket", "]", ";", "websocket", ".", "pong", "(", "data", ",", "!", "websocket", ".", "_isServer", ",", "NOOP", ")", ";", "websocket", ".", "emit", "(", "'ping'", ",", "data", ")", ";", "}" ]

[ "The", "listener", "of", "the", "Receiver", "ping", "event", "." ]

[ "function", "socketOnClose", "(", ")", "{", "const", "websocket", "=", "this", "[", "kWebSocket", "]", ";", "this", ".", "removeListener", "(", "'close'", ",", "socketOnClose", ")", ";", "this", ".", "removeListener", "(", "'end'", ",", "socketOnEnd", ")", ";", "websocket", ".", "readyState", "=", "WebSocket", ".", "CLOSING", ";", "//", "// The close frame might not have been received or the `'end'` event emitted,", "// for example, if the socket was destroyed due to an error. Ensure that the", "// `receiver` stream is closed after writing any remaining buffered data to", "// it. If the readable side of the socket is in flowing mode then there is no", "// buffered data as everything has been already written and `readable.read()`", "// will return `null`. If instead, the socket is paused, any possible buffered", "// data will be read as a single chunk and emitted synchronously in a single", "// `'data'` event.", "//", "websocket", ".", "_socket", ".", "read", "(", ")", ";", "websocket", ".", "_receiver", ".", "end", "(", ")", ";", "this", ".", "removeListener", "(", "'data'", ",", "socketOnData", ")", ";", "this", "[", "kWebSocket", "]", "=", "undefined", ";", "clearTimeout", "(", "websocket", ".", "_closeTimer", ")", ";", "if", "(", "websocket", ".", "_receiver", ".", "_writableState", ".", "finished", "||", "websocket", ".", "_receiver", ".", "_writableState", ".", "errorEmitted", ")", "{", "websocket", ".", "emitClose", "(", ")", ";", "}", "else", "{", "websocket", ".", "_receiver", ".", "on", "(", "'error'", ",", "receiverOnFinish", ")", ";", "websocket", ".", "_receiver", ".", "on", "(", "'finish'", ",", "receiverOnFinish", ")", ";", "}", "}" ]

[ "The", "listener", "of", "the", "net", ".", "Socket", "close", "event", "." ]

[ "function", "socketOnEnd", "(", ")", "{", "const", "websocket", "=", "this", "[", "kWebSocket", "]", ";", "websocket", ".", "readyState", "=", "WebSocket", ".", "CLOSING", ";", "websocket", ".", "_receiver", ".", "end", "(", ")", ";", "this", ".", "end", "(", ")", ";", "}" ]

[ "The", "listener", "of", "the", "net", ".", "Socket", "end", "event", "." ]

[ "function", "socketOnError", "(", ")", "{", "const", "websocket", "=", "this", "[", "kWebSocket", "]", ";", "this", ".", "removeListener", "(", "'error'", ",", "socketOnError", ")", ";", "this", ".", "on", "(", "'error'", ",", "NOOP", ")", ";", "websocket", ".", "readyState", "=", "WebSocket", ".", "CLOSING", ";", "this", ".", "destroy", "(", ")", ";", "}" ]

[ "The", "listener", "of", "the", "net", ".", "Socket", "error", "event", "." ]

[ "function", "all", "(", "array", ",", "pred", ")", "{", "for", "(", "let", "idx", "=", "0", ",", "len", "=", "array", ".", "length", ";", "idx", "<", "len", ";", "idx", "++", ")", "{", "if", "(", "!", "pred", "(", "array", "[", "idx", "]", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "returns", "true", "if", "all", "of", "the", "values", "in", "the", "array", "pass", "the", "predicate", "truth", "test", "." ]

[ "function", "contains", "(", "array", ",", "item", ")", "{", "if", "(", "array", "&&", "array", ".", "length", "&&", "item", ")", "{", "return", "array", ".", "indexOf", "(", "item", ")", "!==", "-", "1", ";", "}", "return", "false", ";", "}" ]

[ "returns", "true", "if", "the", "value", "is", "present", "in", "the", "list", "." ]

[ "function", "sum", "(", "array", ",", "fn", ")", "{", "fn", "=", "fn", "||", "func", ".", "self", ";", "return", "array", ".", "reduce", "(", "function", "(", "memo", ",", "v", ")", "{", "return", "memo", "+", "fn", "(", "v", ")", ";", "}", ",", "0", ")", ";", "}" ]

[ "get", "sum", "from", "a", "list" ]

[ "function", "from", "(", "collection", ")", "{", "const", "result", "=", "[", "]", ";", "const", "length", "=", "collection", ".", "length", ";", "let", "idx", "=", "-", "1", ";", "while", "(", "++", "idx", "<", "length", ")", "{", "result", "[", "idx", "]", "=", "collection", "[", "idx", "]", ";", "}", "return", "result", ";", "}" ]

[ "returns", "a", "copy", "of", "the", "collection", "with", "array", "type", "." ]

[ "function", "compact", "(", "array", ")", "{", "const", "aResult", "=", "[", "]", ";", "for", "(", "let", "idx", "=", "0", ",", "len", "=", "array", ".", "length", ";", "idx", "<", "len", ";", "idx", "++", ")", "{", "if", "(", "array", "[", "idx", "]", ")", "{", "aResult", ".", "push", "(", "array", "[", "idx", "]", ")", ";", "}", "}", "return", "aResult", ";", "}" ]

[ "returns", "a", "copy", "of", "the", "array", "with", "all", "false", "values", "removed" ]

[ "function", "unique", "(", "array", ")", "{", "const", "results", "=", "[", "]", ";", "for", "(", "let", "idx", "=", "0", ",", "len", "=", "array", ".", "length", ";", "idx", "<", "len", ";", "idx", "++", ")", "{", "if", "(", "!", "contains", "(", "results", ",", "array", "[", "idx", "]", ")", ")", "{", "results", ".", "push", "(", "array", "[", "idx", "]", ")", ";", "}", "}", "return", "results", ";", "}" ]

[ "produces", "a", "duplicate", "-", "free", "version", "of", "the", "array" ]

[ "function", "prev", "(", "array", ",", "item", ")", "{", "if", "(", "array", "&&", "array", ".", "length", "&&", "item", ")", "{", "const", "idx", "=", "array", ".", "indexOf", "(", "item", ")", ";", "return", "idx", "===", "-", "1", "?", "null", ":", "array", "[", "idx", "-", "1", "]", ";", "}", "return", "null", ";", "}" ]

[ "returns", "prev", "item", "." ]

[ "function", "listDescendant", "(", "node", ",", "pred", ")", "{", "const", "descendants", "=", "[", "]", ";", "pred", "=", "pred", "||", "func", ".", "ok", ";", "// start DFS(depth first search) with node", "(", "function", "fnWalk", "(", "current", ")", "{", "if", "(", "node", "!==", "current", "&&", "pred", "(", "current", ")", ")", "{", "descendants", ".", "push", "(", "current", ")", ";", "}", "for", "(", "let", "idx", "=", "0", ",", "len", "=", "current", ".", "childNodes", ".", "length", ";", "idx", "<", "len", ";", "idx", "++", ")", "{", "fnWalk", "(", "current", ".", "childNodes", "[", "idx", "]", ")", ";", "}", "}", ")", "(", "node", ")", ";", "return", "descendants", ";", "}" ]

[ "listing", "descendant", "nodes" ]

[ "function", "isLeftEdgeOf", "(", "node", ",", "ancestor", ")", "{", "while", "(", "node", "&&", "node", "!==", "ancestor", ")", "{", "if", "(", "position", "(", "node", ")", "!==", "0", ")", "{", "return", "false", ";", "}", "node", "=", "node", ".", "parentNode", ";", "}", "return", "true", ";", "}" ]

[ "returns", "whether", "node", "is", "left", "edge", "of", "ancestor", "or", "not", "." ]

[ "function", "prevPoint", "(", "point", ",", "isSkipInnerOffset", ")", "{", "let", "node", ";", "let", "offset", ";", "if", "(", "point", ".", "offset", "===", "0", ")", "{", "if", "(", "isEditable", "(", "point", ".", "node", ")", ")", "{", "return", "null", ";", "}", "node", "=", "point", ".", "node", ".", "parentNode", ";", "offset", "=", "position", "(", "point", ".", "node", ")", ";", "}", "else", "if", "(", "hasChildren", "(", "point", ".", "node", ")", ")", "{", "node", "=", "point", ".", "node", ".", "childNodes", "[", "point", ".", "offset", "-", "1", "]", ";", "offset", "=", "nodeLength", "(", "node", ")", ";", "}", "else", "{", "node", "=", "point", ".", "node", ";", "offset", "=", "isSkipInnerOffset", "?", "0", ":", "point", ".", "offset", "-", "1", ";", "}", "return", "{", "node", ":", "node", ",", "offset", ":", "offset", ",", "}", ";", "}" ]

[ "returns", "previous", "boundaryPoint" ]