Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", ")", "{", "var", "obj", "=", "arguments", "[", "0", "]", ",", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ",", "1", ")", ";", "function", "copy", "(", "destination", ",", "source", ")", "{", "for", "(", "var", "property", "in", "source", ")", "{", "if", "(", "source", "[", "property", "]", "&&", "source", "[", "property", "]", ".", "constructor", "&&", "source", "[", "property", "]", ".", "constructor", "===", "Object", ")", "{", "destination", "[", "property", "]", "=", "destination", "[", "property", "]", "||", "{", "}", ";", "copy", "(", "destination", "[", "property", "]", ",", "source", "[", "property", "]", ")", ";", "}", "else", "{", "destination", "[", "property", "]", "=", "source", "[", "property", "]", ";", "}", "}", "return", "destination", ";", "}", "for", "(", "var", "i", "in", "args", ")", "{", "copy", "(", "obj", ",", "args", "[", "i", "]", ")", ";", "}", "return", "obj", ";", "}" ]

[ "Recursively", "merge", "objects", "together" ]

[ "function", "(", "proto", ")", "{", "function", "F", "(", ")", "{", "}", "this", ".", "merge", "(", "F", ".", "prototype", ",", "proto", "||", "{", "}", ",", "(", "function", "(", ")", "{", "var", "Events", "=", "function", "(", ")", "{", "}", ";", "Events", ".", "prototype", "=", "EventEmitter", ".", "prototype", ";", "return", "new", "Events", "(", ")", ";", "}", ")", "(", ")", ")", ";", "return", "new", "F", "(", ")", ";", "}" ]

[ "Factory", "for", "extending", "from", "EventEmitter" ]

[ "function", "splitByDot", "(", "str", ")", "{", "var", "result", "=", "[", "]", ";", "var", "s", "=", "\"\"", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "str", ".", "length", ";", "i", "++", ")", "{", "if", "(", "str", "[", "i", "]", "==", "\"\\\\\"", "&&", "str", "[", "i", "+", "1", "]", "==", "\".\"", ")", "{", "i", "++", ";", "s", "+=", "\".\"", ";", "continue", ";", "}", "if", "(", "str", "[", "i", "]", "==", "\".\"", ")", "{", "result", ".", "push", "(", "s", ")", ";", "s", "=", "\"\"", ";", "continue", ";", "}", "s", "+=", "str", "[", "i", "]", ";", "}", "if", "(", "s", ")", "{", "result", ".", "push", "(", "s", ")", ";", "}", "return", "result", ";", "}" ]

[ "Splits", "dot", "notation", "selector", "by", "its", "components", "Escaped", "dots", "are", "ignored" ]

[ "function", "normilizeSquareBrackets", "(", "str", ")", "{", "var", "m", ";", "while", "(", "(", "m", "=", "reSqrBrackets", ".", "exec", "(", "str", ")", ")", ")", "{", "var", "header", "=", "m", "[", "1", "]", "?", "m", "[", "1", "]", "+", "'.'", ":", "''", ";", "var", "body", "=", "m", "[", "2", "]", ".", "replace", "(", "/", "\\.", "/", "g", ",", "\"\\\\.\"", ")", ";", "var", "footer", "=", "m", "[", "3", "]", "||", "''", ";", "str", "=", "header", "+", "body", "+", "footer", ";", "}", "return", "str", ";", "}" ]

[ "Replaces", "square", "brackets", "notation", "by", "escaped", "dot", "notation" ]

[ "function", "ArrayLoader", "(", "posts", ")", "{", "var", "self", "=", "this", ";", "posts", ".", "forEach", "(", "function", "(", "post", ",", "index", ")", "{", "if", "(", "!", "(", "'id'", "in", "post", ")", ")", "{", "post", ".", "id", "=", "index", ";", "}", "}", ")", ";", "process", ".", "nextTick", "(", "function", "(", ")", "{", "self", ".", "emit", "(", "'load'", ",", "posts", ")", ";", "}", ")", ";", "}" ]

[ "Create", "a", "new", "array", "loader", "." ]

[ "function", "(", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "options", ".", "$db", "=", "cOptions", ".", "db", ";", "options", ".", "$dbName", "=", "cOptions", ".", "database", ";", "options", ".", "$model", "=", "cOptions", ".", "model", ";", "return", "new", "cOptions", ".", "cls", "(", "options", ")", ";", "}" ]

[ "create", "a", "constructor", "proxy" ]

[ "function", "report", "(", "items", ",", "heading", ")", "{", "grunt", ".", "log", ".", "subhead", "(", "heading", ")", ";", "if", "(", "items", ".", "length", ">", "0", ")", "{", "grunt", ".", "log", ".", "error", "(", "grunt", ".", "log", ".", "wordlist", "(", "items", ",", "{", "separator", ":", "'\\n'", "}", ")", ")", ";", "}", "else", "{", "grunt", ".", "log", ".", "ok", "(", ")", ";", "}", "}" ]

[ "Report", "the", "status", "of", "items" ]

[ "function", "obj", "(", "argv", ",", "callback", ")", "{", "var", "uri", "=", "argv", "[", "2", "]", ";", "if", "(", "argv", "[", "3", "]", ")", "{", "util", ".", "put", "(", "argv", "[", "2", "]", ",", "'<> <> \"\"\"'", "+", "argv", "[", "3", "]", "+", "'\"\"\" .'", ",", "function", "(", "err", ",", "callback", ")", "{", "if", "(", "err", ")", "{", "console", ".", "error", "(", "err", ")", ";", "}", "else", "{", "console", ".", "log", "(", "'put value : '", "+", "argv", "[", "3", "]", ")", ";", "}", "}", ")", ";", "}", "else", "{", "var", "wss", "=", "'wss://'", "+", "uri", ".", "split", "(", "'/'", ")", "[", "2", "]", "+", "'/'", ";", "var", "s", "=", "new", "ws", "(", "wss", ",", "{", "origin", ":", "'http://websocket.org'", "}", ")", ";", "s", ".", "on", "(", "'open'", ",", "function", "open", "(", ")", "{", "s", ".", "send", "(", "'sub '", "+", "uri", ")", ";", "}", ")", ";", "s", ".", "on", "(", "'close'", ",", "function", "close", "(", ")", "{", "console", ".", "log", "(", "'disconnected'", ")", ";", "}", ")", ";", "s", ".", "on", "(", "'message'", ",", "function", "message", "(", "data", ",", "flags", ")", "{", "var", "a", "=", "data", ".", "split", "(", "' '", ")", ";", "if", "(", "a", ".", "length", "&&", "a", "[", "0", "]", "===", "'pub'", ")", "{", "util", ".", "getAll", "(", "a", "[", "1", "]", ",", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "}", "else", "{", "callback", "(", "null", ",", "res", "[", "res", ".", "length", "-", "1", "]", ".", "object", ".", "value", ")", ";", "}", "}", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "obj", "gets", "list", "of", "files", "for", "a", "given", "container" ]

[ "function", "bin", "(", "argv", ")", "{", "obj", "(", "argv", ",", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "}", "else", "{", "console", ".", "log", "(", "res", ")", ";", "}", "}", ")", ";", "}" ]

[ "obj", "as", "a", "command" ]

[ "function", "validateAttributes", "(", "modelName", ",", "attributes", "=", "{", "}", ",", "errors", "=", "[", "]", ")", "{", "if", "(", "!", "attributes", "||", "typeof", "attributes", "!==", "\"object\"", "||", "Array", ".", "isArray", "(", "attributes", ")", ")", "{", "throw", "new", "TypeError", "(", "\"definition of attributes must be object\"", ")", ";", "}", "const", "names", "=", "Object", ".", "keys", "(", "attributes", ")", ";", "const", "handlers", "=", "{", "}", ";", "for", "(", "let", "i", "=", "0", ",", "length", "=", "names", ".", "length", ";", "i", "<", "length", ";", "i", "++", ")", "{", "const", "name", "=", "names", "[", "i", "]", ";", "const", "attribute", "=", "attributes", "[", "name", "]", ";", "if", "(", "!", "attribute", ".", "type", ")", "{", "attribute", ".", "type", "=", "\"string\"", ";", "}", "const", "type", "=", "Types", ".", "selectByName", "(", "attribute", ".", "type", ")", ";", "if", "(", "!", "type", ")", "{", "throw", "new", "TypeError", "(", "`", "${", "attribute", ".", "type", "}", "${", "name", "}", "${", "modelName", "}", "`", ")", ";", "}", "if", "(", "type", ".", "checkDefinition", "(", "attribute", ",", "errors", ")", ")", "{", "handlers", "[", "name", "]", "=", "type", ";", "}", "}", "return", "handlers", ";", "}" ]

[ "Basically", "validates", "provided", "definitions", "of", "attributes", "." ]

[ "function", "compileCoercionMap", "(", "attributes", ")", "{", "if", "(", "!", "attributes", "||", "typeof", "attributes", "!==", "\"object\"", "||", "Array", ".", "isArray", "(", "attributes", ")", ")", "{", "throw", "new", "TypeError", "(", "\"definition of attributes must be object\"", ")", ";", "}", "const", "coercions", "=", "{", "}", ";", "const", "attributeNames", "=", "Object", ".", "keys", "(", "attributes", ")", ";", "for", "(", "let", "ai", "=", "0", ",", "aLength", "=", "attributeNames", ".", "length", ";", "ai", "<", "aLength", ";", "ai", "++", ")", "{", "const", "attributeName", "=", "attributeNames", "[", "ai", "]", ";", "const", "attribute", "=", "attributes", "[", "attributeName", "]", ";", "(", "function", "(", "name", ",", "handler", ",", "definition", ")", "{", "coercions", "[", "name", "]", "=", "value", "=>", "handler", ".", "coerce", "(", "value", ",", "definition", ")", ";", "}", ")", "(", "attributeName", ",", "Types", ".", "selectByName", "(", "attribute", ".", "type", ")", ",", "attribute", ")", ";", "}", "return", "coercions", ";", "}" ]

[ "Compiles", "coercion", "handlers", "per", "attribute", "of", "model", "." ]

[ "function", "compileCoercion", "(", "attributes", ")", "{", "if", "(", "!", "attributes", "||", "typeof", "attributes", "!==", "\"object\"", "||", "Array", ".", "isArray", "(", "attributes", ")", ")", "{", "throw", "new", "TypeError", "(", "\"definition of attributes must be object\"", ")", ";", "}", "const", "attributeNames", "=", "Object", ".", "keys", "(", "attributes", ")", ";", "const", "numAttributes", "=", "attributeNames", ".", "length", ";", "const", "coercion", "=", "[", "]", ";", "for", "(", "let", "ai", "=", "0", ";", "ai", "<", "numAttributes", ";", "ai", "++", ")", "{", "const", "attributeName", "=", "attributeNames", "[", "ai", "]", ";", "const", "attribute", "=", "attributes", "[", "attributeName", "]", ";", "const", "handler", "=", "Types", ".", "selectByName", "(", "attribute", ".", "type", ")", ";", "const", "{", "args", ",", "body", "}", "=", "extractBody", "(", "handler", ".", "coerce", ")", ";", "if", "(", "args", ".", "length", "<", "2", ")", "{", "throw", "new", "TypeError", "(", "`", "${", "attribute", ".", "type", "}", "`", ")", ";", "}", "coercion", "[", "ai", "]", "=", "`", "${", "args", "[", "0", "]", "}", "${", "attributeName", "}", "${", "args", "[", "1", "]", "}", "${", "attributeName", "}", "${", "body", ".", "replace", "(", "ptnTrailingReturn", ",", "(", "all", ",", "term", ")", "=>", "`", "${", "attributeName", "}", "${", "term", ".", "trim", "(", ")", "}", "`", ")", "}", "`", ";", "}", "// eslint-disable-next-line no-new-func", "return", "new", "Function", "(", "`", "${", "coercion", ".", "join", "(", "\"\"", ")", "}", "`", ")", ";", "}" ]

[ "Creates", "function", "coercing", "all", "attributes", "." ]

[ "function", "compileValidator", "(", "attributes", ")", "{", "if", "(", "!", "attributes", "||", "typeof", "attributes", "!==", "\"object\"", "||", "Array", ".", "isArray", "(", "attributes", ")", ")", "{", "throw", "new", "TypeError", "(", "\"definition of attributes must be object\"", ")", ";", "}", "const", "attributeNames", "=", "Object", ".", "keys", "(", "attributes", ")", ";", "const", "numAttributes", "=", "attributeNames", ".", "length", ";", "const", "validation", "=", "[", "]", ";", "for", "(", "let", "ai", "=", "0", ";", "ai", "<", "numAttributes", ";", "ai", "++", ")", "{", "const", "attributeName", "=", "attributeNames", "[", "ai", "]", ";", "const", "attribute", "=", "attributes", "[", "attributeName", "]", ";", "const", "handler", "=", "Types", ".", "selectByName", "(", "attribute", ".", "type", ")", ";", "const", "{", "args", ",", "body", "}", "=", "extractBody", "(", "handler", ".", "isValid", ")", ";", "if", "(", "args", ".", "length", "<", "4", ")", "{", "throw", "new", "TypeError", "(", "`", "${", "attribute", ".", "type", "}", "`", ")", ";", "}", "validation", "[", "ai", "]", "=", "`", "${", "args", "[", "0", "]", "}", "${", "attributeName", "}", "${", "args", "[", "1", "]", "}", "${", "attributeName", "}", "${", "args", "[", "2", "]", "}", "${", "attributeName", "}", "${", "args", "[", "3", "]", "}", "${", "body", "}", "`", ";", "}", "// eslint-disable-next-line no-new-func", "return", "new", "Function", "(", "`", "${", "validation", ".", "join", "(", "\"\"", ")", "}", "`", ")", ";", "}" ]

[ "Creates", "validator", "function", "assessing", "all", "defined", "attributes", "of", "a", "model", "." ]

[ "function", "compileDeserializer", "(", "attributes", ")", "{", "if", "(", "!", "attributes", "||", "typeof", "attributes", "!==", "\"object\"", "||", "Array", ".", "isArray", "(", "attributes", ")", ")", "{", "throw", "new", "TypeError", "(", "\"definition of attributes must be object\"", ")", ";", "}", "const", "attributeNames", "=", "Object", ".", "keys", "(", "attributes", ")", ";", "const", "numAttributes", "=", "attributeNames", ".", "length", ";", "const", "deserialization", "=", "new", "Array", "(", "2", "*", "numAttributes", ")", ";", "let", "write", "=", "0", ";", "for", "(", "let", "ai", "=", "0", ";", "ai", "<", "numAttributes", ";", "ai", "++", ")", "{", "const", "attributeName", "=", "attributeNames", "[", "ai", "]", ";", "const", "attribute", "=", "attributes", "[", "attributeName", "]", ";", "const", "handler", "=", "Types", ".", "selectByName", "(", "attribute", ".", "type", ")", ";", "let", "sourceName", ";", "// append deserialize() method of current attribute's type handler", "{", "const", "{", "args", ",", "body", "}", "=", "extractBody", "(", "handler", ".", "deserialize", ")", ";", "if", "(", "args", ".", "length", "<", "1", ")", "{", "throw", "new", "TypeError", "(", "`", "${", "attribute", ".", "type", "}", "`", ")", ";", "}", "if", "(", "body", ".", "replace", "(", "ptnTrailingReturn", ",", "\"\"", ")", ".", "trim", "(", ")", ".", "length", ")", "{", "sourceName", "=", "\"$$d\"", ";", "deserialization", "[", "write", "++", "]", "=", "`", "${", "args", "[", "0", "]", "}", "${", "attributeName", "}", "${", "body", ".", "replace", "(", "ptnTrailingReturn", ",", "(", "all", ",", "term", ")", "=>", "`", "${", "attributeName", "}", "${", "term", ".", "trim", "(", ")", "}", "`", ")", "}", "`", ";", "}", "else", "{", "sourceName", "=", "\"$$s\"", ";", "}", "}", "// append coerce() method of current attribute's type handler", "{", "const", "{", "args", ",", "body", "}", "=", "extractBody", "(", "handler", ".", "coerce", ")", ";", "if", "(", "args", ".", "length", "<", "2", ")", "{", "throw", "new", "TypeError", "(", "`", "${", "attribute", ".", "type", "}", "`", ")", ";", "}", "deserialization", "[", "write", "++", "]", "=", "`", "${", "args", "[", "0", "]", "}", "${", "sourceName", "}", "${", "attributeName", "}", "${", "args", "[", "1", "]", "}", "${", "attributeName", "}", "${", "body", ".", "replace", "(", "ptnTrailingReturn", ",", "(", "all", ",", "term", ")", "=>", "`", "${", "attributeName", "}", "${", "term", ".", "trim", "(", ")", "}", "`", ")", "}", "`", ";", "}", "}", "deserialization", ".", "splice", "(", "write", ")", ";", "// eslint-disable-next-line no-new-func", "return", "new", "Function", "(", "\"$$input\"", ",", "\"$$attrs\"", ",", "`", "${", "deserialization", ".", "join", "(", "\"\"", ")", "}", "`", ")", ";", "}" ]

[ "Creates", "function", "de", "-", "serializing", "and", "coercing", "all", "attributes", "in", "a", "provided", "record", "." ]

[ "function", "(", "editor", ")", "{", "var", "elementPath", "=", "editor", ".", "elementPath", "(", ")", ",", "activePath", "=", "elementPath", "&&", "elementPath", ".", "elements", ",", "pathMember", ",", "ret", ";", "// IE8: upon initialization if there is no path elementPath() returns null.\r", "if", "(", "elementPath", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "activePath", ".", "length", ";", "i", "++", ")", "{", "pathMember", "=", "activePath", "[", "i", "]", ";", "if", "(", "!", "ret", "&&", "pathMember", ".", "getName", "(", ")", "==", "'span'", "&&", "pathMember", ".", "hasAttribute", "(", "'dir'", ")", "&&", "pathMember", ".", "hasAttribute", "(", "'lang'", ")", ")", "ret", "=", "pathMember", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Gets", "the", "first", "language", "element", "for", "the", "current", "editor", "selection", "." ]

[ "function", "(", "actionName", ")", "{", "self", "[", "actionName", "]", "=", "function", "(", ")", "{", "var", "args", "=", "arguments", ";", "self", ".", "_stack", ".", "push", "(", "{", "action", ":", "actionName", ",", "args", ":", "args", "}", ")", ";", "return", "self", ";", "}", ";", "}" ]

[ "Kick", "the", "can", "down", "the", "road", "for", "app", "to", "pick", "it", "up", "later" ]

[ "function", "(", "actionName", ",", "action", ",", "resourcePath", ")", "{", "// prefix function to set rest values", "var", "identify", "=", "function", "(", "req", ",", "res", ",", "next", ")", "{", "res", ".", "set", "(", "'XX-Powered-By'", ",", "'Restpress'", ")", ";", "req", ".", "resource", "=", "self", ";", "req", ".", "actionName", "=", "actionName", ";", "req", ".", "action", "=", "action", ";", "next", "(", ")", ";", "}", ";", "self", "[", "actionName", "]", "=", "function", "(", ")", "{", "if", "(", "identify", ")", "{", "// insert identify as second argument", "// This is to be done only once", "[", "]", ".", "unshift", ".", "call", "(", "arguments", ",", "identify", ")", ";", "identify", "=", "null", ";", "}", "// insert actionPath as first argument", "[", "]", ".", "unshift", ".", "call", "(", "arguments", ",", "resourcePath", "+", "action", ".", "route", ")", ";", "// Hack for restify where 'delete' method is 'del'", "var", "appMethod", "=", "action", ".", "method", ";", "if", "(", "appMethod", "==", "'delete'", "&&", "typeof", "self", ".", "app", "[", "appMethod", "]", "!==", "'function'", "&&", "typeof", "self", ".", "app", "[", "'del'", "]", "===", "'function'", ")", "{", "appMethod", "=", "'del'", ";", "}", "// Call express app VERB function", "self", ".", "app", "[", "appMethod", "]", ".", "apply", "(", "self", ".", "app", ",", "arguments", ")", ";", "// return this for chaining", "return", "self", ";", "}", ";", "}" ]

[ "Re", "-", "Create", "methods", "working", "via", "app", "for", "known", "actions" ]

[ "function", "(", "req", ",", "res", ",", "next", ")", "{", "res", ".", "set", "(", "'XX-Powered-By'", ",", "'Restpress'", ")", ";", "req", ".", "resource", "=", "self", ";", "req", ".", "actionName", "=", "actionName", ";", "req", ".", "action", "=", "action", ";", "next", "(", ")", ";", "}" ]

[ "prefix", "function", "to", "set", "rest", "values" ]

[ "function", "populateStack", "(", "stack", ",", "rootPath", ",", "files", ",", "callback", ")", "{", "stack", ".", "unshift", "(", "...", "files", ".", "filter", "(", "file", "=>", "file", ".", "stats", ".", "isDirectory", "(", ")", ")", ".", "map", "(", "file", "=>", "path", ".", "join", "(", "rootPath", ",", "file", ".", "path", ")", ")", ")", ";", "async", ".", "nextTick", "(", "callback", ",", "null", ",", "files", ")", ";", "}" ]

[ "Add", "subdirectories", "to", "the", "given", "stack", "." ]

[ "function", "processStackItem", "(", "out", ",", "stack", ",", "rootPath", ",", "userFilter", ",", "readMode", ")", "{", "// Initialize a new file object.", "const", "initFile", "=", "(", "dirPath", ")", "=>", "{", "return", "(", "fileName", ",", "callback", ")", "=>", "{", "const", "filePath", "=", "path", ".", "join", "(", "dirPath", ",", "fileName", ")", ";", "fs", ".", "stat", "(", "filePath", ",", "(", "error", ",", "stats", ")", "=>", "{", "async", ".", "nextTick", "(", "callback", ",", "error", ",", "{", "path", ":", "path", ".", "relative", "(", "rootPath", ",", "filePath", ")", ",", "stats", ",", "}", ")", ";", "}", ")", ";", "}", ";", "}", ";", "// Filter supported files.", "const", "filterSupported", "=", "(", ")", "=>", "{", "return", "(", "file", ",", "callback", ")", "=>", "{", "const", "keep", "=", "file", ".", "stats", ".", "isFile", "(", ")", "||", "file", ".", "stats", ".", "isDirectory", "(", ")", ";", "async", ".", "nextTick", "(", "callback", ",", "null", ",", "keep", ")", ";", "}", ";", "}", ";", "// Filter output files.", "const", "filterOutput", "=", "(", ")", "=>", "{", "return", "(", "file", ",", "callback", ")", "=>", "{", "const", "keep", "=", "file", ".", "stats", ".", "isFile", "(", ")", "&&", "userFilter", "(", "file", ")", ";", "async", ".", "nextTick", "(", "callback", ",", "null", ",", "keep", ")", ";", "}", ";", "}", ";", "// Read a file's data.", "const", "readData", "=", "(", ")", "=>", "{", "return", "(", "file", ",", "callback", ")", "=>", "{", "const", "filePath", "=", "path", ".", "join", "(", "rootPath", ",", "file", ".", "path", ")", ";", "read", "(", "filePath", ",", "readMode", ",", "(", "error", ",", "data", ")", "=>", "{", "async", ".", "nextTick", "(", "callback", ",", "error", ",", "Object", ".", "assign", "(", "{", "}", ",", "file", ",", "{", "data", "}", ")", ")", ";", "}", ")", ";", "}", ";", "}", ";", "return", "(", "callback", ")", "=>", "{", "const", "dirPath", "=", "stack", ".", "shift", "(", ")", ";", "async", ".", "waterfall", "(", "[", "cb", "=>", "fs", ".", "readdir", "(", "dirPath", ",", "cb", ")", ",", "(", "fileNames", ",", "cb", ")", "=>", "async", ".", "map", "(", "fileNames", ",", "initFile", "(", "dirPath", ")", ",", "cb", ")", ",", "(", "files", ",", "cb", ")", "=>", "async", ".", "filter", "(", "files", ",", "filterSupported", "(", ")", ",", "cb", ")", ",", "(", "files", ",", "cb", ")", "=>", "populateStack", "(", "stack", ",", "rootPath", ",", "files", ",", "cb", ")", ",", "(", "files", ",", "cb", ")", "=>", "async", ".", "filter", "(", "files", ",", "filterOutput", "(", ")", ",", "cb", ")", ",", "(", "files", ",", "cb", ")", "=>", "async", ".", "map", "(", "files", ",", "readData", "(", ")", ",", "cb", ")", ",", "]", ",", "(", "error", ",", "result", ")", "=>", "{", "if", "(", "error", ")", "{", "async", ".", "nextTick", "(", "callback", ",", "error", ")", ";", "return", ";", "}", "out", ".", "push", "(", "...", "result", ")", ";", "async", ".", "nextTick", "(", "callback", ",", "null", ")", ";", "}", ")", ";", "}", ";", "}" ]

[ "Process", "a", "single", "stack", "item", "." ]

[ "function", "tween", "(", "a", ",", "b", ")", "{", "var", "string", "=", "[", "]", "var", "keys", "=", "[", "]", "var", "from", "=", "[", "]", "var", "to", "=", "[", "]", "var", "cursor", "=", "0", "var", "m", "while", "(", "m", "=", "number", ".", "exec", "(", "b", ")", ")", "{", "if", "(", "m", ".", "index", ">", "cursor", ")", "string", ".", "push", "(", "b", ".", "slice", "(", "cursor", ",", "m", ".", "index", ")", ")", "to", ".", "push", "(", "Number", "(", "m", "[", "0", "]", ")", ")", "keys", ".", "push", "(", "string", ".", "length", ")", "string", ".", "push", "(", "null", ")", "cursor", "=", "number", ".", "lastIndex", "}", "if", "(", "cursor", "<", "b", ".", "length", ")", "string", ".", "push", "(", "b", ".", "slice", "(", "cursor", ")", ")", "while", "(", "m", "=", "number", ".", "exec", "(", "a", ")", ")", "from", ".", "push", "(", "Number", "(", "m", "[", "0", "]", ")", ")", "return", "function", "frame", "(", "n", ")", "{", "var", "i", "=", "keys", ".", "length", "while", "(", "i", "--", ")", "string", "[", "keys", "[", "i", "]", "]", "=", "from", "[", "i", "]", "+", "(", "to", "[", "i", "]", "-", "from", "[", "i", "]", ")", "*", "n", "return", "string", ".", "join", "(", "''", ")", "}", "}" ]

[ "create", "a", "tween", "generator", "from", "a", "to", "b" ]

[ "function", "safeEndingTags", "(", "content", ")", "{", "var", "MJElements", "=", "[", "]", ".", "concat", "(", "WHITELISTED_GLOBAL_TAG", ")", ";", "(", "0", ",", "_forEach2", ".", "default", ")", "(", "_extends", "(", "{", "}", ",", "_MJMLElementsCollection2", ".", "default", ",", "_MJMLHead2", ".", "default", ")", ",", "function", "(", "element", ",", "name", ")", "{", "var", "tagName", "=", "element", ".", "tagName", "||", "name", ";", "MJElements", ".", "push", "(", "tagName", ")", ";", "}", ")", ";", "var", "safeContent", "=", "(", "0", ",", "_parseAttributes2", ".", "default", ")", "(", "MJElements", ",", "content", ".", "replace", "(", "/", "\\$", "/", "g", ",", "'&#36;'", ")", ")", ";", "(", "0", ",", "_concat2", ".", "default", ")", "(", "_MJMLElementsCollection", ".", "endingTags", ",", "_MJMLHead", ".", "endingTags", ")", ".", "forEach", "(", "function", "(", "tag", ")", "{", "safeContent", "=", "safeContent", ".", "replace", "(", "regexTag", "(", "tag", ")", ",", "_dom2", ".", "default", ".", "replaceContentByCdata", "(", "tag", ")", ")", ";", "}", ")", ";", "return", "safeContent", ";", "}" ]

[ "Avoid", "htmlparser", "to", "parse", "ending", "tags" ]

[ "function", "mjmlElementParser", "(", "elem", ",", "content", ")", "{", "if", "(", "!", "elem", ")", "{", "throw", "new", "_Error", ".", "NullElementError", "(", "'Null element found in mjmlElementParser'", ")", ";", "}", "var", "findLine", "=", "content", ".", "substr", "(", "0", ",", "elem", ".", "startIndex", ")", ".", "match", "(", "/", "\\n", "/", "g", ")", ";", "var", "lineNumber", "=", "findLine", "?", "findLine", ".", "length", "+", "1", ":", "1", ";", "var", "tagName", "=", "elem", ".", "tagName", ".", "toLowerCase", "(", ")", ";", "var", "attributes", "=", "(", "0", ",", "_mapValues2", ".", "default", ")", "(", "_dom2", ".", "default", ".", "getAttributes", "(", "elem", ")", ",", "function", "(", "val", ")", "{", "return", "decodeURIComponent", "(", "val", ")", ";", "}", ")", ";", "var", "element", "=", "{", "tagName", ":", "tagName", ",", "attributes", ":", "attributes", ",", "lineNumber", ":", "lineNumber", "}", ";", "if", "(", "_MJMLElementsCollection", ".", "endingTags", ".", "indexOf", "(", "tagName", ")", "!==", "-", "1", ")", "{", "var", "$local", "=", "_dom2", ".", "default", ".", "parseXML", "(", "elem", ")", ";", "element", ".", "content", "=", "(", "0", ",", "_removeCDATA2", ".", "default", ")", "(", "$local", "(", "tagName", ")", ".", "html", "(", ")", ".", "trim", "(", ")", ")", ";", "}", "else", "{", "var", "children", "=", "_dom2", ".", "default", ".", "getChildren", "(", "elem", ")", ";", "element", ".", "children", "=", "children", "?", "(", "0", ",", "_compact2", ".", "default", ")", "(", "(", "0", ",", "_filter2", ".", "default", ")", "(", "children", ",", "function", "(", "child", ")", "{", "return", "child", ".", "tagName", ";", "}", ")", ".", "map", "(", "function", "(", "child", ")", "{", "return", "mjmlElementParser", "(", "child", ",", "content", ")", ";", "}", ")", ")", ":", "[", "]", ";", "}", "return", "element", ";", "}" ]

[ "converts", "MJML", "body", "into", "a", "JSON", "representation" ]

[ "function", "runSauceLabs", "(", "location", ",", "remote", ",", "options", ")", "{", "var", "capabilities", "=", "options", ".", "capabilities", ";", "if", "(", "remote", "===", "'browserstack'", ")", "{", "var", "user", "=", "options", ".", "username", "||", "process", ".", "env", ".", "BROWSER_STACK_USERNAME", ";", "var", "key", "=", "options", ".", "accessKey", "||", "process", ".", "env", ".", "BROWSER_STACK_ACCESS_KEY", ";", "if", "(", "!", "user", "||", "!", "key", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'You must provide `username` and `accessKey` as options '", "+", "'or set \"BROWSER_STACK_USERNAME\" and \"BROWSER_STACK_ACCESS_KEY\" in your '", "+", "'environment variables.'", ")", ")", ";", "}", "remote", "=", "'http://hub-cloud.browserstack.com/wd/hub'", ";", "capabilities", "=", "function", "(", "platform", ")", "{", "var", "result", "=", "{", "}", ";", "Object", ".", "keys", "(", "options", ".", "capabilities", "||", "{", "}", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "result", "[", "key", "]", "=", "options", ".", "capabilities", "[", "key", "]", ";", "}", ")", ";", "Object", ".", "keys", "(", "platform", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "result", "[", "key", "]", "=", "platform", "[", "key", "]", ";", "}", ")", ";", "result", "[", "'browserstack.user'", "]", "=", "user", ";", "result", "[", "'browserstack.key'", "]", "=", "key", ";", "return", "result", ";", "}", ";", "}", "return", "(", "options", ".", "platforms", "?", "Promise", ".", "resolve", "(", "options", ".", "platforms", ")", ":", "getPlatforms", "(", "{", "filterPlatforms", ":", "options", ".", "filterPlatforms", ",", "choosePlatforms", ":", "options", ".", "choosePlatforms", "}", ")", ")", ".", "then", "(", "function", "(", "platforms", ")", "{", "return", "runBrowsers", "(", "location", ",", "remote", ",", "{", "name", ":", "options", ".", "name", ",", "parallel", ":", "options", ".", "parallel", "||", "3", ",", "platforms", ":", "platforms", ",", "throttle", ":", "options", ".", "throttle", ",", "capabilities", ":", "capabilities", ",", "debug", ":", "options", ".", "debug", ",", "httpDebug", ":", "options", ".", "httpDebug", ",", "jobInfo", ":", "options", ".", "jobInfo", ",", "allowExceptions", ":", "options", ".", "allowExceptions", ",", "testComplete", ":", "options", ".", "testComplete", ",", "testPassed", ":", "options", ".", "testPassed", ",", "bail", ":", "options", ".", "bail", ",", "timeout", ":", "options", ".", "timeout", ",", "onStart", ":", "options", ".", "onStart", ",", "onQueue", ":", "options", ".", "onQueue", ",", "onResult", ":", "options", ".", "onResult", ",", "onBrowserResults", ":", "options", ".", "onBrowserResults", "}", ")", ";", "}", ")", ";", "}" ]

[ "Run", "a", "test", "in", "a", "collection", "of", "browsers", "on", "sauce", "labs" ]

[ "function", "writeHeader", "(", "buffer", ",", "offset", ",", "size", ",", "opCode", ")", "{", "offset", "=", "binary", ".", "writeInt", "(", "buffer", ",", "offset", ",", "size", ")", "offset", "=", "binary", ".", "writeInt", "(", "buffer", ",", "offset", ",", "0", ")", "offset", "=", "binary", ".", "writeInt", "(", "buffer", ",", "offset", ",", "0", ")", "offset", "=", "binary", ".", "writeInt", "(", "buffer", ",", "offset", ",", "opCode", ")", "return", "offset", "}" ]

[ "header", "int32", "size", "int32", "request", "id", "int32", "0", "int32", "op", "code", "command" ]

[ "function", "(", "elem", ",", "offsetParent", ")", "{", "var", "offset", ",", "parentOffset", "if", "(", "window", ".", "jQuery", ")", "{", "if", "(", "!", "offsetParent", ")", "{", "return", "window", ".", "jQuery", "(", "elem", ")", ".", "position", "(", ")", "}", "offset", "=", "window", ".", "jQuery", "(", "elem", ")", ".", "offset", "(", ")", "parentOffset", "=", "window", ".", "jQuery", "(", "offsetParent", ")", ".", "offset", "(", ")", "// Get element offset relative to offsetParent", "return", "{", "top", ":", "offset", ".", "top", "-", "parentOffset", ".", "top", ",", "left", ":", "offset", ".", "left", "-", "parentOffset", ".", "left", "}", "}", "parentOffset", "=", "{", "top", ":", "0", ",", "left", ":", "0", "}", "// Fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent", "if", "(", "window", ".", "getComputedStyle", "(", "elem", ")", ".", "position", "===", "'fixed'", ")", "{", "// We assume that getBoundingClientRect is available when computed position is fixed", "offset", "=", "elem", ".", "getBoundingClientRect", "(", ")", "}", "else", "{", "if", "(", "!", "offsetParent", ")", "{", "// Get *real* offsetParent", "offsetParent", "=", "position", ".", "offsetParent", "(", "elem", ")", "}", "// Get correct offsets", "offset", "=", "offsetFunc", "(", "elem", ")", "if", "(", "offsetParent", ".", "nodeName", "!==", "'HTML'", ")", "{", "parentOffset", "=", "offsetFunc", "(", "offsetParent", ")", "}", "// Add offsetParent borders", "parentOffset", ".", "top", "+=", "parseInt", "(", "window", ".", "getComputedStyle", "(", "offsetParent", ")", ".", "borderTopWidth", ",", "10", ")", "parentOffset", ".", "left", "+=", "parseInt", "(", "window", ".", "getComputedStyle", "(", "offsetParent", ")", ".", "borderLeftWidth", ",", "10", ")", "}", "// Subtract parent offsets and element margins", "return", "{", "top", ":", "offset", ".", "top", "-", "parentOffset", ".", "top", "-", "parseInt", "(", "window", ".", "getComputedStyle", "(", "elem", ")", ".", "marginTop", ",", "10", ")", ",", "left", ":", "offset", ".", "left", "-", "parentOffset", ".", "left", "-", "parseInt", "(", "window", ".", "getComputedStyle", "(", "elem", ")", ".", "marginLeft", ",", "10", ")", "}", "}" ]

[ "Get", "elements", "position" ]

[ "function", "Definition", "(", "factoryName", ",", "factory", ")", "{", "var", "configDefaults", "=", "{", "}", "var", "deps", "=", "[", "]", "return", "{", "/**\n * Calls the factory for each arguments and returns\n * the list of tasks that just got created.\n *\n * @params {Object}\n * @returns {Array}\n */", "add", ":", "function", "add", "(", ")", "{", "var", "configs", "=", "_", "(", "arguments", ")", ".", "toArray", "(", ")", ".", "flatten", "(", "true", ")", ".", "value", "(", ")", "if", "(", "configs", ".", "length", "===", "0", ")", "{", "// by adding an empty object", "// we'll create a task that has no alias", "// that's useful for Definition that are not", "// really tasks creators (e.g the help task)", "configs", "=", "[", "{", "}", "]", "}", "var", "addedTasks", "=", "_", "(", "configs", ")", ".", "map", "(", "function", "(", "config", ")", "{", "return", "_", ".", "assign", "(", "{", "}", ",", "configDefaults", ",", "config", ")", "}", ")", ".", "map", "(", "function", "(", "config", ")", "{", "var", "taskName", "=", "name", "(", "factoryName", ",", "config", ".", "alias", ")", "var", "deps", "=", "_", "(", "factory", "(", "config", ",", "options", "(", ")", ")", ")", ".", "flatten", "(", "true", ")", ".", "filter", "(", "_", ".", "identity", ")", ".", "value", "(", ")", "var", "fn", "=", "_", ".", "isFunction", "(", "_", ".", "last", "(", "deps", ")", ")", "?", "deps", ".", "pop", "(", ")", ":", "_", ".", "noop", "gulp", ".", "task", "(", "taskName", ",", "deps", ",", "fn", ")", "return", "taskName", "}", ")", ".", "run", "(", ")", "if", "(", "gulp", ".", "tasks", "[", "factoryName", "]", "==", "null", "||", "gulp", ".", "tasks", "[", "factoryName", "]", ".", "$root", ")", "{", "gulp", ".", "task", "(", "factoryName", ",", "deps", ".", "concat", "(", "tasks", "(", "factoryName", "+", "':'", ")", ")", ")", "gulp", ".", "tasks", "[", "factoryName", "]", ".", "$root", "=", "true", "}", "return", "addedTasks", "}", ",", "/**\n * Sets the factory's default config.\n *\n * @param {Object} config\n * @returns {{add: add, defaults: defaults, before: before}}\n */", "defaults", ":", "function", "defaults", "(", "config", ")", "{", "configDefaults", "=", "config", "return", "this", "}", ",", "/**\n * Getter/setter that add tasks to run before any factory's task.\n *\n * @returns {*}\n */", "before", ":", "function", "before", "(", ")", "{", "if", "(", "arguments", ".", "length", ")", "{", "deps", "=", "arguments", "[", "0", "]", "return", "this", "}", "return", "deps", "}", "}", "}" ]

[ "Return", "a", "Definition", "object", "that", "s", "used", "to", "create", "tasks", "from", "a", "given", "factory", "." ]

[ "function", "main", "(", ")", "{", "var", "taskList", "=", "_", "(", "arguments", ")", ".", "toArray", "(", ")", ".", "flatten", "(", "true", ")", ".", "value", "(", ")", "gulp", ".", "task", "(", "'default'", ",", "taskList", ")", "return", "this", "}" ]

[ "Create", "gulp", "s", "default", "task", "that", "runs", "every", "tasks", "passed", "as", "arguments", "." ]

[ "function", "tasks", "(", "taskName", ")", "{", "var", "taskList", "=", "_", ".", "keys", "(", "gulp", ".", "tasks", ")", "if", "(", "taskName", "==", "null", ")", "{", "return", "taskList", "}", "return", "_", ".", "filter", "(", "taskList", ",", "function", "(", "task", ")", "{", "return", "_", ".", "startsWith", "(", "task", ",", "taskName", ")", "}", ")", "}" ]

[ "Returns", "every", "gulp", "tasks", "with", "a", "name", "that", "starts", "by", "taskName", "if", "provided", "otherwise", "returns", "all", "existing", "tasks", "." ]

[ "function", "(", ")", "{", "var", "deferred", "=", "Q", ".", "defer", "(", ")", ";", "try", "{", "request", ".", "get", "(", "getRepoUrl", "(", "'releases'", ")", ")", ".", "set", "(", "'Authorization'", ",", "'token '", "+", "config", ".", "token", ")", ".", "then", "(", "function", "(", "res", ")", "{", "logRequestSuccess", "(", "res", ")", ";", "deferred", ".", "resolve", "(", "res", ".", "body", ")", ";", "}", ",", "function", "(", "err", ")", "{", "logRequestError", "(", "err", ")", ";", "deferred", ".", "reject", "(", "err", ".", "message", ")", ";", "}", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "log", "(", "err", ")", ";", "deferred", ".", "reject", "(", "err", ".", "message", ")", ";", "}", "return", "deferred", ".", "promise", ";", "}" ]

[ "This", "returns", "a", "list", "of", "releases", "which", "does", "not", "include", "regular", "Git", "tags", "that", "have", "not", "been", "associated", "with", "a", "release", ".", "To", "get", "a", "list", "of", "Git", "tags", "use", "the", "Repository", "Tags", "API", ".", "Information", "about", "published", "releases", "are", "available", "to", "everyone", ".", "Only", "users", "with", "push", "access", "will", "receive", "listings", "for", "draft", "releases", "." ]

[ "function", "(", "query", ",", "excludeRoot", ",", "fromTop", ")", "{", "var", "evaluator", ";", "if", "(", "typeof", "query", "==", "'string'", ")", "evaluator", "=", "function", "(", "node", ")", "{", "return", "node", ".", "getName", "(", ")", "==", "query", ";", "}", ";", "if", "(", "query", "instanceof", "CKEDITOR", ".", "dom", ".", "element", ")", "evaluator", "=", "function", "(", "node", ")", "{", "return", "node", ".", "equals", "(", "query", ")", ";", "}", ";", "else", "if", "(", "CKEDITOR", ".", "tools", ".", "isArray", "(", "query", ")", ")", "evaluator", "=", "function", "(", "node", ")", "{", "return", "CKEDITOR", ".", "tools", ".", "indexOf", "(", "query", ",", "node", ".", "getName", "(", ")", ")", ">", "-", "1", ";", "}", ";", "else", "if", "(", "typeof", "query", "==", "'function'", ")", "evaluator", "=", "query", ";", "else", "if", "(", "typeof", "query", "==", "'object'", ")", "evaluator", "=", "function", "(", "node", ")", "{", "return", "node", ".", "getName", "(", ")", "in", "query", ";", "}", ";", "var", "elements", "=", "this", ".", "elements", ",", "length", "=", "elements", ".", "length", ";", "excludeRoot", "&&", "length", "--", ";", "if", "(", "fromTop", ")", "{", "elements", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "elements", ",", "0", ")", ";", "elements", ".", "reverse", "(", ")", ";", "}", "for", "(", "var", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "evaluator", "(", "elements", "[", "i", "]", ")", ")", "return", "elements", "[", "i", "]", ";", "}", "return", "null", ";", "}" ]

[ "Search", "the", "path", "elements", "that", "meets", "the", "specified", "criteria", "." ]

[ "function", "(", "tag", ")", "{", "var", "holder", ";", "// Check for block context.", "if", "(", "tag", "in", "CKEDITOR", ".", "dtd", ".", "$block", ")", "{", "// Indeterminate elements which are not subjected to be splitted or surrounded must be checked first.", "var", "inter", "=", "this", ".", "contains", "(", "CKEDITOR", ".", "dtd", ".", "$intermediate", ")", ";", "holder", "=", "inter", "||", "(", "this", ".", "root", ".", "equals", "(", "this", ".", "block", ")", "&&", "this", ".", "block", ")", "||", "this", ".", "blockLimit", ";", "return", "!", "!", "holder", ".", "getDtd", "(", ")", "[", "tag", "]", ";", "}", "return", "true", ";", "}" ]

[ "Check", "whether", "the", "elements", "path", "is", "the", "proper", "context", "for", "the", "specified", "tag", "name", "in", "the", "DTD", "." ]

[ "function", "isActive", "(", ")", "{", "try", "{", "var", "key", "=", "'___session is active___'", ";", "return", "session", ".", "get", "(", "key", ")", "||", "session", ".", "set", "(", "key", ",", "true", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "false", ";", "}", "}" ]

[ "Set", "a", "heuristic", "for", "determining", "if", "the", "session", "is", "actually", "active", "." ]

[ "function", "(", "event", ")", "{", "event", ".", "preventDefault", "(", ")", ";", "if", "(", "!", "currentElement", ")", "{", "return", ";", "}", "var", "newHeight", "=", "currentElement", ".", "data", "(", "'startHeight'", ")", "+", "(", "event", ".", "pageY", "-", "currentElement", ".", "data", "(", "'startY'", ")", ")", ";", "currentElement", ".", "parent", "(", ")", ".", "height", "(", "newHeight", ")", ";", "}" ]

[ "Use", "the", "elements", "startHeight", "stored", "Event", ".", "pageY", "and", "current", "Event", ".", "pageY", "to", "resize", "the", "panel", "." ]

[ "function", "assign", "(", ")", "{", "var", "result", "=", "{", "}", ";", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "args", ".", "length", ";", "i", "++", ")", "{", "var", "obj", "=", "args", "[", "i", "]", ";", "if", "(", "typeof", "obj", "!==", "'object'", ")", "{", "continue", ";", "}", "for", "(", "var", "key", "in", "obj", ")", "{", "if", "(", "obj", ".", "hasOwnProperty", "(", "key", ")", ")", "{", "result", "[", "key", "]", "=", "obj", "[", "key", "]", ";", "}", "}", "obj", "=", "void", "0", ";", "}", "return", "result", ";", "}" ]

[ "Merge", "multiple", "obects", "together" ]

[ "function", "(", "err", ",", "results", ")", "{", "if", "(", "options", ".", "headers", ")", "{", "// Set some headers so we can track what's going on", "var", "headers", "=", "{", "'X-Throttled'", ":", "results", ".", "throttled", ",", "'X-Throttle-Remaining'", ":", "Math", ".", "max", "(", "options", ".", "limit", "-", "results", ".", "count", ",", "0", ")", "}", ";", "if", "(", "results", ".", "expiresAt", ")", "{", "headers", "[", "'X-Throttle-Reset'", "]", "=", "results", ".", "expiresAt", ";", "}", "res", ".", "set", "(", "headers", ")", ";", "}", "if", "(", "err", ")", "{", "// Unknown error", "next", "(", "err", ")", ";", "return", ";", "}", "else", "if", "(", "results", ".", "throttled", ")", "{", "if", "(", "logger", ")", "{", "// Log it", "logger", ".", "warn", "(", "'%s - ResponseThrottled for %s seconds - %s requests exceeded %s within %s seconds'", ",", "ip", ",", "options", ".", "ban", ",", "results", ".", "count", ",", "options", ".", "limit", ",", "options", ".", "period", ")", ";", "}", "// Let the client know this is forbidden", "res", ".", "status", "(", "403", ")", ";", "// Create a human readable error", "var", "banLength", "=", "moment", ".", "duration", "(", "options", ".", "ban", ",", "'seconds'", ")", ".", "humanize", "(", ")", ";", "next", "(", "'Warning: Too many requests. You have been throttled for '", "+", "banLength", "+", "'. '", "+", "'Try again '", "+", "moment", "(", "results", ".", "expiresAt", ")", ".", "fromNow", "(", ")", ")", ";", "return", ";", "}", "else", "{", "// All is good", "next", "(", ")", ";", "return", ";", "}", "}" ]

[ "Now", "do", "something", "with", "all", "of", "this", "information" ]

[ "function", "(", "key", ",", "data", ")", "{", "var", "currentData", ";", "currentData", "=", "settings", "[", "key", "]", ";", "if", "(", "(", "currentData", "!=", "null", ")", "&&", "_", ".", "isObject", "(", "currentData", ")", ")", "{", "settings", "[", "key", "]", "=", "_", ".", "extend", "(", "data", ",", "settings", "[", "key", "]", ")", ";", "}", "else", "if", "(", "currentData", "==", "null", ")", "{", "settings", "[", "key", "]", "=", "data", ";", "}", "}" ]

[ "Used", "to", "initially", "set", "a", "setttings", "value", ".", "Convenient", "for", "settings", "defaults", "that", "wont", "overwrite", "already", "set", "actual", "values" ]

[ "function", "(", "key", ",", "data", ")", "{", "var", "currentData", ";", "currentData", "=", "settings", "[", "key", "]", "||", "{", "}", ";", "settings", "[", "key", "]", "=", "_", ".", "extend", "(", "currentData", ",", "data", ")", ";", "}" ]

[ "Merge", "a", "setting", "using", "underscore", "s", "extend", ".", "Only", "useful", "if", "the", "setting", "is", "an", "object" ]

[ "function", "(", "err", ")", "{", "var", "storage", "=", "getStorage", "(", ")", ";", "if", "(", "storage", "&&", "storage", ".", "errors", ")", "{", "storage", ".", "errors", ".", "push", "(", "err", ")", ";", "return", "localStorage", ".", "setItem", "(", "[", "config", ".", "nameSpace", "]", ",", "JSON", ".", "stringify", "(", "storage", ")", ")", ";", "}", "}" ]

[ "JSON", ".", "stringify", "the", "object", "and", "put", "back", "in", "localStorage" ]

[ "function", "searchArray", "(", "list", ",", "value", ")", "{", "var", "index", "=", "list", ".", "indexOf", "(", "value", ")", ";", "if", "(", "index", "===", "-", "1", ")", "return", "false", ";", "return", "value", ";", "}" ]

[ "search", "array", "and", "return", "the", "search", "argument", "or", "false", "if", "not", "found" ]

[ "function", "searchBase", "(", "base", ")", "{", "var", "basename", "=", "path", ".", "resolve", "(", "base", ",", "modulename", ")", ";", "// return no path", "var", "filename", "=", "searchArray", "(", "dirMap", ",", "basename", ")", ";", "if", "(", "filename", ")", "return", "filename", ";", "// return .js path", "filename", "=", "searchArray", "(", "dirMap", ",", "basename", "+", "'.js'", ")", ";", "if", "(", "filename", ")", "return", "filename", ";", "// return .json path", "filename", "=", "searchArray", "(", "dirMap", ",", "basename", "+", "'.json'", ")", ";", "if", "(", "filename", ")", "return", "filename", ";", "// if input was an path, do search more", "if", "(", "isPath", ")", "return", "false", ";", "// resolve and return /package.json path", "if", "(", "packageMap", "[", "basename", "]", ")", "{", "return", "packageMap", "[", "basename", "]", ";", "}", "return", "searchArray", "(", "dirMap", ",", "basename", "+", "'/index.js'", ")", ";", "}" ]

[ "search", "each", "query" ]

[ "function", "buildPackage", "(", "callback", ")", "{", "var", "dirMap", "=", "self", ".", "build", ".", "dirMap", ",", "i", "=", "dirMap", ".", "length", ",", "filepath", ",", "pkgName", "=", "'/package.json'", ",", "pkgLength", "=", "pkgName", ".", "length", ",", "list", "=", "[", "]", ";", "// search dirmap for package.json", "while", "(", "i", "--", ")", "{", "filepath", "=", "dirMap", "[", "i", "]", ";", "if", "(", "filepath", ".", "slice", "(", "filepath", ".", "length", "-", "pkgLength", ",", "filepath", ".", "length", ")", "===", "pkgName", ")", "{", "list", ".", "push", "(", "filepath", ")", ";", "}", "}", "function", "resolvePackage", "(", "filepath", ",", "callback", ")", "{", "var", "dirname", "=", "filepath", ".", "slice", "(", "0", ",", "filepath", ".", "length", "-", "pkgLength", ")", ";", "var", "fullpath", "=", "path", ".", "resolve", "(", "self", ".", "piccolo", ".", "get", "(", "'modules'", ")", ",", "'./'", "+", "filepath", ")", ";", "var", "response", "=", "{", "key", ":", "dirname", "}", ";", "fs", ".", "readFile", "(", "fullpath", ",", "'utf8'", ",", "function", "(", "error", ",", "content", ")", "{", "if", "(", "error", ")", "return", "callback", "(", "error", ",", "null", ")", ";", "// remove BOM", "content", "=", "removeBOM", "(", "content", ")", ";", "// use index if filepath is empty", "var", "filepath", ";", "if", "(", "content", "===", "''", ")", "{", "filepath", "=", "path", ".", "resolve", "(", "dirname", ",", "'index.js'", ")", ";", "}", "// read JSON file", "var", "result", ";", "try", "{", "result", "=", "JSON", ".", "parse", "(", "content", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "callback", "(", "e", ",", "null", ")", ";", "}", "if", "(", "result", ".", "main", ")", "{", "filepath", "=", "path", ".", "resolve", "(", "dirname", ",", "result", ".", "main", ")", ";", "}", "else", "{", "filepath", "=", "path", ".", "resolve", "(", "dirname", ",", "'./index.js'", ")", ";", "}", "// check that file exist", "var", "fullpath", "=", "path", ".", "resolve", "(", "self", ".", "piccolo", ".", "get", "(", "'modules'", ")", ",", "'./'", "+", "filepath", ")", ";", "fs", ".", "exists", "(", "fullpath", ",", "function", "(", "exist", ")", "{", "response", ".", "value", "=", "exist", "?", "filepath", ":", "false", ";", "callback", "(", "null", ",", "response", ")", ";", "}", ")", ";", "}", ")", ";", "}", "// read all package.json files and resolve the filepath", "async", ".", "map", "(", "list", ",", "resolvePackage", ",", "function", "(", "error", ",", "list", ")", "{", "if", "(", "error", ")", "return", "callback", "(", "error", ",", "null", ")", ";", "var", "final", "=", "{", "}", ";", "list", ".", "forEach", "(", "function", "(", "obj", ")", "{", "final", "[", "obj", ".", "key", "]", "=", "obj", ".", "value", ";", "}", ")", ";", "// save resolved packageMap", "self", ".", "build", ".", "packageMap", "=", "final", ";", "callback", "(", "null", ",", "null", ")", ";", "}", ")", ";", "}" ]

[ "scan", "and", "resolve", "all", "packages" ]

[ "function", "buildMap", "(", ")", "{", "var", "dependencies", "=", "self", ".", "build", ".", "dependencies", "=", "{", "}", ";", "var", "cacheTime", "=", "self", ".", "cache", ".", "stats", ";", "var", "buildTime", "=", "self", ".", "build", ".", "mtime", ";", "Object", ".", "keys", "(", "cacheTime", ")", ".", "forEach", "(", "function", "(", "filepath", ")", "{", "buildTime", "[", "filepath", "]", "=", "cacheTime", "[", "filepath", "]", ".", "getTime", "(", ")", ";", "}", ")", ";", "// deep resolve all dependencies", "self", ".", "build", ".", "dirMap", ".", "forEach", "(", "function", "(", "filename", ")", "{", "var", "list", "=", "[", "]", ";", "// the result array will be filled by his function", "deepResolve", "(", "self", ",", "filename", ",", "list", ")", ";", "// dry result array", "var", "result", "=", "dependencies", "[", "filename", "]", "=", "[", "]", ";", "var", "i", "=", "list", ".", "length", ";", "while", "(", "i", "--", ")", "{", "if", "(", "result", ".", "indexOf", "(", "list", "[", "i", "]", ")", "===", "-", "1", ")", "{", "result", ".", "push", "(", "list", "[", "i", "]", ")", ";", "}", "}", "}", ")", ";", "}" ]

[ "rebuild", "dependency", "tree" ]

[ "function", "(", ")", "{", "var", "cert", "=", "this", ".", "keychain", ".", "getCertPem", "(", ")", ";", "if", "(", "!", "cert", ")", "{", "throw", "new", "CError", "(", "'missing certificate'", ")", ".", "log", "(", ")", ";", "}", "var", "tmp", "=", "this", ".", "getDate", "(", ")", "+", "'::'", "+", "cert", "+", "'::'", "+", "SECRET_CLIENT", ";", "var", "hmac", "=", "forge", ".", "hmac", ".", "create", "(", ")", ";", "hmac", ".", "start", "(", "'sha256'", ",", "SECRET", ")", ";", "hmac", ".", "update", "(", "tmp", ")", ";", "return", "hmac", ".", "digest", "(", ")", ".", "toHex", "(", ")", ";", "}" ]

[ "Generate", "a", "valid", "token" ]

[ "function", "(", ")", "{", "if", "(", "this", ".", "getMode", "(", ")", "!==", "mode", ")", "{", "throw", "new", "CError", "(", "'unexpected mode'", ")", ".", "log", "(", ")", ";", "}", "var", "cert", ";", "try", "{", "cert", "=", "this", ".", "keychain", ".", "getCertPem", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "throw", "new", "CError", "(", "{", "body", ":", "{", "code", ":", "'ImATeapot'", ",", "message", ":", "'missing certificate'", ",", "cause", ":", "e", "}", "}", ")", ".", "log", "(", "'body'", ")", ";", "}", "if", "(", "!", "cert", ")", "{", "throw", "new", "CError", "(", "'missing certificate'", ")", ".", "log", "(", ")", ";", "}", "var", "out", "=", "{", "mode", ":", "this", ".", "getMode", "(", ")", ",", "cert", ":", "cert", "}", ";", "if", "(", "this", ".", "getSid", "(", ")", ")", "{", "out", ".", "sid", "=", "this", ".", "getSid", "(", ")", ";", "}", "return", "out", ";", "}" ]

[ "Get", "the", "payload", "property", "of", "the", "header" ]

[ "function", "blockFilter", "(", "isOutput", ",", "fillEmptyBlock", ")", "{", "return", "function", "(", "block", ")", "{", "// DO NOT apply the filler if it's a fragment node.", "if", "(", "block", ".", "type", "==", "CKEDITOR", ".", "NODE_DOCUMENT_FRAGMENT", ")", "return", ";", "cleanBogus", "(", "block", ")", ";", "var", "shouldFillBlock", "=", "typeof", "fillEmptyBlock", "==", "'function'", "?", "fillEmptyBlock", "(", "block", ")", ":", "fillEmptyBlock", ";", "if", "(", "shouldFillBlock", "!==", "false", "&&", "isEmptyBlockNeedFiller", "(", "block", ")", ")", "{", "block", ".", "add", "(", "createFiller", "(", "isOutput", ")", ")", ";", "}", "}", ";", "}" ]

[ "This", "text", "block", "filter", "remove", "any", "bogus", "and", "create", "the", "filler", "on", "demand", "." ]

[ "function", "brFilter", "(", "isOutput", ")", "{", "return", "function", "(", "br", ")", "{", "// DO NOT apply the filer if parent's a fragment node.", "if", "(", "br", ".", "parent", ".", "type", "==", "CKEDITOR", ".", "NODE_DOCUMENT_FRAGMENT", ")", "return", ";", "var", "attrs", "=", "br", ".", "attributes", ";", "// Dismiss BRs that are either bogus or eol marker.", "if", "(", "'data-cke-bogus'", "in", "attrs", "||", "'data-cke-eol'", "in", "attrs", ")", "{", "delete", "attrs", "[", "'data-cke-bogus'", "]", ";", "return", ";", "}", "// Judge the tail line-break BR, and to insert bogus after it.", "var", "next", "=", "getNext", "(", "br", ")", ",", "previous", "=", "getPrevious", "(", "br", ")", ";", "if", "(", "!", "next", "&&", "isBlockBoundary", "(", "br", ".", "parent", ")", ")", "append", "(", "br", ".", "parent", ",", "createFiller", "(", "isOutput", ")", ")", ";", "else", "if", "(", "isBlockBoundary", "(", "next", ")", "&&", "previous", "&&", "!", "isBlockBoundary", "(", "previous", ")", ")", "createFiller", "(", "isOutput", ")", ".", "insertBefore", "(", "next", ")", ";", "}", ";", "}" ]

[ "Append", "a", "filler", "right", "after", "the", "last", "line", "-", "break", "BR", "found", "at", "the", "end", "of", "block", "." ]

[ "function", "maybeBogus", "(", "node", ",", "atBlockEnd", ")", "{", "// BR that's not from IE<11 DOM, except for a EOL marker.", "if", "(", "!", "(", "isOutput", "&&", "!", "CKEDITOR", ".", "env", ".", "needsBrFiller", ")", "&&", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "node", ".", "name", "==", "'br'", "&&", "!", "node", ".", "attributes", "[", "'data-cke-eol'", "]", ")", "{", "return", "true", ";", "}", "var", "match", ";", "// NBSP, possibly.", "if", "(", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", "&&", "(", "match", "=", "node", ".", "value", ".", "match", "(", "tailNbspRegex", ")", ")", ")", "{", "// We need to separate tail NBSP out of a text node, for later removal.", "if", "(", "match", ".", "index", ")", "{", "(", "new", "CKEDITOR", ".", "htmlParser", ".", "text", "(", "node", ".", "value", ".", "substring", "(", "0", ",", "match", ".", "index", ")", ")", ")", ".", "insertBefore", "(", "node", ")", ";", "node", ".", "value", "=", "match", "[", "0", "]", ";", "}", "// From IE<11 DOM, at the end of a text block, or before block boundary.", "if", "(", "!", "CKEDITOR", ".", "env", ".", "needsBrFiller", "&&", "isOutput", "&&", "(", "!", "atBlockEnd", "||", "node", ".", "parent", ".", "name", "in", "textBlockTags", ")", ")", "return", "true", ";", "// From the output.", "if", "(", "!", "isOutput", ")", "{", "var", "previous", "=", "node", ".", "previous", ";", "// Following a line-break at the end of block.", "if", "(", "previous", "&&", "previous", ".", "name", "==", "'br'", ")", "return", "true", ";", "// Or a single NBSP between two blocks.", "if", "(", "!", "previous", "||", "isBlockBoundary", "(", "previous", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Determinate", "whether", "this", "node", "is", "potentially", "a", "bogus", "node", "." ]

[ "function", "cleanBogus", "(", "block", ")", "{", "var", "bogus", "=", "[", "]", ";", "var", "last", "=", "getLast", "(", "block", ")", ",", "node", ",", "previous", ";", "if", "(", "last", ")", "{", "// Check for bogus at the end of this block.", "// e.g. <p>foo<br /></p>", "maybeBogus", "(", "last", ",", "1", ")", "&&", "bogus", ".", "push", "(", "last", ")", ";", "while", "(", "last", ")", "{", "// Check for bogus at the end of any pseudo block contained.", "if", "(", "isBlockBoundary", "(", "last", ")", "&&", "(", "node", "=", "getPrevious", "(", "last", ")", ")", "&&", "maybeBogus", "(", "node", ")", ")", "{", "// Bogus must have inline proceeding, instead single BR between two blocks,", "// is considered as filler, e.g. <hr /><br /><hr />", "if", "(", "(", "previous", "=", "getPrevious", "(", "node", ")", ")", "&&", "!", "isBlockBoundary", "(", "previous", ")", ")", "bogus", ".", "push", "(", "node", ")", ";", "// Convert the filler into appropriate form.", "else", "{", "createFiller", "(", "isOutput", ")", ".", "insertAfter", "(", "node", ")", ";", "node", ".", "remove", "(", ")", ";", "}", "}", "last", "=", "last", ".", "previous", ";", "}", "}", "// Now remove all bogus collected from above.", "for", "(", "var", "i", "=", "0", ";", "i", "<", "bogus", ".", "length", ";", "i", "++", ")", "bogus", "[", "i", "]", ".", "remove", "(", ")", ";", "}" ]

[ "Removes", "all", "bogus", "inside", "of", "this", "block", "and", "to", "convert", "fillers", "into", "the", "proper", "form", "." ]

[ "function", "isEmptyBlockNeedFiller", "(", "block", ")", "{", "// DO NOT fill empty editable in IE<11.", "if", "(", "!", "isOutput", "&&", "!", "CKEDITOR", ".", "env", ".", "needsBrFiller", "&&", "block", ".", "type", "==", "CKEDITOR", ".", "NODE_DOCUMENT_FRAGMENT", ")", "return", "false", ";", "// 1. For IE version >=8, empty blocks are displayed correctly themself in wysiwiyg;", "// 2. For the rest, at least table cell and list item need no filler space. (#6248)", "if", "(", "!", "isOutput", "&&", "!", "CKEDITOR", ".", "env", ".", "needsBrFiller", "&&", "(", "document", ".", "documentMode", ">", "7", "||", "block", ".", "name", "in", "CKEDITOR", ".", "dtd", ".", "tr", "||", "block", ".", "name", "in", "CKEDITOR", ".", "dtd", ".", "$listItem", ")", ")", "{", "return", "false", ";", "}", "var", "last", "=", "getLast", "(", "block", ")", ";", "return", "!", "last", "||", "block", ".", "name", "==", "'form'", "&&", "last", ".", "name", "==", "'input'", ";", "}" ]

[ "Judge", "whether", "it", "s", "an", "empty", "block", "that", "requires", "a", "filler", "node", "." ]

[ "function", "isEmpty", "(", "node", ")", "{", "return", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", "&&", "!", "CKEDITOR", ".", "tools", ".", "trim", "(", "node", ".", "value", ")", "||", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "node", ".", "attributes", "[", "'data-cke-bookmark'", "]", ";", "}" ]

[ "Judge", "whether", "the", "node", "is", "an", "ghost", "node", "to", "be", "ignored", "when", "traversing", "." ]

[ "function", "isBlockBoundary", "(", "node", ")", "{", "return", "node", "&&", "(", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", "&&", "node", ".", "name", "in", "blockLikeTags", "||", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_DOCUMENT_FRAGMENT", ")", ";", "}" ]

[ "Judge", "whether", "the", "node", "is", "a", "block", "-", "like", "element", "." ]

[ "function", "(", "regex", ",", "text", ")", "{", "var", "nextIndex", "=", "0", ";", "var", "result", "=", "[", "]", ";", "var", "execResult", ";", "while", "(", "(", "execResult", "=", "regex", ".", "exec", "(", "text", ")", ")", "!==", "null", ")", "{", "result", ".", "push", "(", "{", "start", ":", "execResult", ".", "index", ",", "matchLength", ":", "execResult", "[", "0", "]", ".", "length", "}", ")", ";", "}", "return", "{", "next", ":", "function", "(", ")", "{", "return", "nextIndex", "<", "result", ".", "length", "?", "result", "[", "nextIndex", "++", "]", ":", "null", ";", "}", "}", ";", "}" ]

[ "this", "is", "a", "convenience", "regex", "matcher", "that", "iterates", "through", "the", "matches", "and", "returns", "each", "start", "index", "and", "length" ]

[ "function", "lambdaError", "(", "fn", ",", "settings", ")", "{", "var", "log", "=", "(", "settings", "&&", "settings", ".", "log", "===", "false", "?", "false", ":", "true", ")", ";", "var", "map", "=", "(", "settings", "&&", "settings", ".", "map", "?", "settings", ".", "map", ":", "undefined", ")", ";", "var", "exclude", "=", "(", "settings", "&&", "settings", ".", "exclude", "?", "settings", ".", "exclude", ":", "undefined", ")", ";", "return", "(", "event", ",", "context", ",", "callback", ")", "=>", "{", "fn", "(", "event", ",", "context", ",", "(", "err", ",", "result", ")", "=>", "{", "if", "(", "err", ")", "{", "if", "(", "log", ")", "{", "console", ".", "error", "(", "Errors", ".", "stack", "(", "err", ")", ")", ";", "}", "if", "(", "typeof", "err", "!==", "'object'", ")", "{", "console", ".", "error", "(", "'Error must be an object:'", ",", "err", ")", ";", "err", "=", "new", "InvalidErrorValue", "(", "err", ")", ";", "}", "return", "callback", "(", "Errors", ".", "json", "(", "err", ",", "false", ",", "map", ",", "exclude", ")", ")", ";", "}", "return", "callback", "(", "null", ",", "result", ")", ";", "}", ")", ";", "}", ";", "}" ]

[ "Wrap", "all", "API", "Gateway", "lambda", "handlers", "with", "this", "function", "." ]

[ "function", "asyncd", "(", "pw", ",", "evts", ",", "fname", ",", "args", ")", "{", "var", "es", "=", "Array", ".", "isArray", "(", "evts", ")", "?", "evts", ":", "[", "evts", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "es", ".", "length", ";", "i", "++", ")", "{", "if", "(", "es", "[", "i", "]", ")", "{", "defer", "(", "asyncCb", ".", "bind", "(", "es", "[", "i", "]", ")", ")", ";", "}", "}", "function", "asyncCb", "(", ")", "{", "var", "argsp", "=", "args", "&&", "args", ".", "length", "?", "[", "this", "]", ":", "null", ";", "if", "(", "argsp", ")", "{", "argsp", ".", "push", ".", "apply", "(", "argsp", ",", "args", ")", ";", "pw", "[", "fname", "]", ".", "apply", "(", "pw", ",", "argsp", ")", ";", "}", "else", "pw", "[", "fname", "]", "(", "this", ")", ";", "}", "return", "pw", ";", "}" ]

[ "Executes", "one", "or", "more", "events", "an", "asynchronously" ]

[ "function", "defer", "(", "cb", ")", "{", "if", "(", "!", "defer", ".", "nextLoop", ")", "{", "var", "ntv", "=", "typeof", "setImmediate", "===", "'function'", ";", "defer", ".", "nextLoop", "=", "ntv", "?", "setImmediate", ":", "function", "setImmediateShim", "(", "cb", ")", "{", "if", "(", "defer", ".", "obj", ")", "{", "if", "(", "!", "defer", ".", "cbs", ".", "length", ")", "{", "defer", ".", "obj", ".", "setAttribute", "(", "'cnt'", ",", "'inc'", ")", ";", "}", "defer", ".", "cbs", ".", "push", "(", "cb", ")", ";", "}", "else", "{", "setTimeout", "(", "cb", ",", "0", ")", ";", "}", "}", ";", "if", "(", "!", "ntv", "&&", "typeof", "MutationObserver", "===", "'object'", "&&", "typeof", "document", "===", "'object'", ")", "{", "defer", ".", "cbs", "=", "[", "]", ";", "defer", ".", "obj", "=", "document", ".", "createElement", "(", "'div'", ")", ";", "defer", ".", "ob", "=", "new", "MutationObserver", "(", "function", "mutations", "(", ")", "{", "for", "(", "var", "cbl", "=", "defer", ".", "cbs", ".", "slice", "(", ")", ",", "i", "=", "defer", ".", "cbs", ".", "length", "=", "0", ",", "l", "=", "cbl", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "cbl", "[", "i", "]", "(", ")", ";", "}", "}", ")", ".", "observe", "(", "defer", ".", "obj", ",", "{", "attributes", ":", "true", "}", ")", ";", "}", "}", "return", "defer", ".", "nextLoop", ".", "call", "(", "null", ",", "cb", ")", ";", "}" ]

[ "Defers", "a", "function", "s", "execution", "to", "the", "next", "iteration", "in", "the", "event", "loop" ]

[ "function", "merge", "(", "dest", ",", "src", ",", "ctyp", ",", "nou", ",", "non", ")", "{", "if", "(", "!", "src", "||", "typeof", "src", "!==", "'object'", ")", "return", "dest", ";", "var", "keys", "=", "Object", ".", "keys", "(", "src", ")", ";", "var", "i", "=", "keys", ".", "length", ",", "dt", ";", "while", "(", "i", "--", ")", "{", "if", "(", "isNaN", "(", "keys", "[", "i", "]", ")", "&&", "src", ".", "hasOwnProperty", "(", "keys", "[", "i", "]", ")", "&&", "(", "!", "nou", "||", "(", "nou", "&&", "typeof", "src", "[", "keys", "[", "i", "]", "]", "!==", "'undefined'", ")", ")", "&&", "(", "!", "non", "||", "(", "non", "&&", "src", "[", "keys", "[", "i", "]", "]", "!==", "null", ")", ")", ")", "{", "if", "(", "ctyp", "&&", "dest", "[", "keys", "[", "i", "]", "]", "!=", "null", "&&", "(", "dt", "=", "typeof", "dest", "[", "keys", "[", "i", "]", "]", ")", "!==", "'undefined'", "&&", "dt", "!==", "typeof", "src", "[", "keys", "[", "i", "]", "]", ")", "{", "continue", ";", "}", "dest", "[", "keys", "[", "i", "]", "]", "=", "src", "[", "keys", "[", "i", "]", "]", ";", "}", "}", "return", "dest", ";", "}" ]

[ "Merges", "an", "object", "with", "the", "properties", "of", "another", "object" ]

[ "function", "props", "(", "dest", ",", "pds", ",", "src", ",", "isrc", ",", "ndflt", ",", "nm", ",", "nmsrc", ")", "{", "var", "asrt", "=", "nm", "&&", "src", ";", "if", "(", "asrt", ")", "assert", ".", "ok", "(", "dest", ",", "'no '", "+", "nm", ")", ";", "var", "i", "=", "pds", ".", "length", ";", "while", "(", "i", "--", ")", "{", "if", "(", "asrt", ")", "prop", "(", "dest", ",", "pds", "[", "i", "]", ",", "src", ",", "isrc", ",", "ndflt", ",", "nm", ",", "nmsrc", ")", ";", "else", "prop", "(", "dest", ",", "pds", "[", "i", "]", ",", "src", ",", "isrc", ",", "ndflt", ")", ";", "}", "return", "dest", ";", "}" ]

[ "Assigns", "property", "values", "on", "a", "destination", "object", "or", "asserts", "that", "the", "destination", "object", "properties", "are", "within", "the", "defined", "boundaries", "when", "a", "source", "object", "is", "passed", "along", "with", "its", "name" ]

[ "function", "prop", "(", "dest", ",", "pd", ",", "src", ",", "isrc", ",", "ndflt", ",", "nm", ",", "nmsrc", ")", "{", "if", "(", "nm", "&&", "src", ")", "{", "assert", ".", "strictEqual", "(", "dest", "[", "pd", ".", "n", "]", ",", "src", "[", "pd", ".", "n", "]", ",", "(", "nm", "?", "nm", "+", "'.'", ":", "''", ")", "+", "pd", ".", "n", "+", "': '", "+", "dest", "[", "pd", ".", "n", "]", "+", "' !== '", "+", "(", "nmsrc", "?", "nmsrc", "+", "'.'", ":", "''", ")", "+", "pd", ".", "n", "+", "': '", "+", "src", "[", "pd", ".", "n", "]", ")", ";", "}", "else", "{", "var", "dtyp", "=", "(", "dest", "&&", "typeof", "dest", "[", "pd", ".", "n", "]", ")", "||", "''", ",", "vtyp", ",", "v", ",", "useObj", "=", "pd", ".", "v", "&&", "Array", ".", "isArray", "(", "pd", ".", "v", ")", ";", "if", "(", "dtyp", "===", "'undefined'", ")", "v", "=", "(", "src", "&&", "(", "isrc", "||", "pd", ".", "i", ")", "&&", "(", "!", "useObj", "||", "typeof", "src", "[", "pd", ".", "n", "]", "===", "'object'", ")", "?", "src", "[", "pd", ".", "n", "]", ":", "null", ")", "||", "(", "ndflt", "?", "undefined", ":", "pd", ".", "d", ")", ";", "else", "if", "(", "!", "useObj", "&&", "dtyp", "===", "'number'", ")", "v", "=", "typeof", "pd", ".", "l", "===", "'number'", "&&", "dest", "[", "pd", ".", "n", "]", "<", "pd", ".", "l", "?", "pd", ".", "l", ":", "typeof", "pd", ".", "h", "===", "'number'", "&&", "dest", "[", "pd", ".", "n", "]", ">", "pd", ".", "h", "?", "pd", ".", "h", ":", "undefined", ";", "else", "if", "(", "useObj", "&&", "dtyp", "===", "'object'", ")", "v", "=", "props", "(", "dest", "[", "pd", ".", "n", "]", ",", "pd", ".", "v", ",", "src", "[", "pd", ".", "n", "]", ",", "isrc", ",", "ndflt", ",", "nm", ",", "nmsrc", ")", ";", "if", "(", "(", "vtyp", "=", "typeof", "v", ")", "!==", "'undefined'", "&&", "(", "!", "pd", ".", "r", "||", "!", "!", "~", "pd", ".", "r", ".", "indexOf", "(", "v", ")", ")", ")", "{", "if", "(", "!", "pd", ".", "c", "||", "(", "vtyp", "===", "typeof", "pd", ".", "c", "&&", "Array", ".", "isArray", "(", "pd", ".", "c", ")", "===", "Array", ".", "isArray", "(", "v", ")", ")", ")", "dest", "[", "pd", ".", "n", "]", "=", "v", ";", "}", "}", "return", "dest", ";", "}" ]

[ "Assigns", "a", "property", "value", "on", "a", "destination", "object", "or", "asserts", "that", "the", "destination", "object", "property", "is", "within", "the", "defined", "boundaries", "when", "a", "source", "object", "is", "passed", "along", "with", "its", "name" ]

[ "function", "(", "el", ")", "{", "var", "self", "=", "this", ";", "var", "$input", "=", "$", "(", "'input.tokenSearch'", ",", "el", ")", ";", "var", "suggestions", "=", "new", "can", ".", "List", "(", "[", "]", ")", ";", "this", ".", "viewModel", ".", "attr", "(", "'searchInput'", ",", "$input", ")", ";", "// http://loopj.com/jquery-tokeninput/", "$input", ".", "tokenInput", "(", "suggestions", ",", "{", "theme", ":", "'facebook'", ",", "placeholder", ":", "'Search...'", ",", "preventDuplicates", ":", "true", ",", "allowFreeTagging", ":", "true", ",", "tokenLimit", ":", "3", ",", "allowTabOut", ":", "false", ",", "/**\n * onResult is used to pre-process suggestions.\n * In our case we want to show current item if there is no results.\n */", "onResult", ":", "function", "(", "item", ")", "{", "if", "(", "$", ".", "isEmptyObject", "(", "item", ")", ")", "{", "var", "tempObj", "=", "{", "id", ":", "$", "(", "'input:first'", ",", "el", ")", ".", "val", "(", ")", ",", "name", ":", "$", "(", "'input:first'", ",", "el", ")", ".", "val", "(", ")", "}", ";", "return", "[", "tempObj", "]", ";", "}", "else", "{", "return", "item", ";", "}", "}", ",", "/**\n * onAdd is used to maintain the suggestion dropdown box and the searchTerms in the scope. \n * It is called internally by the jquery.tokenInput plugin when either the enter key \n * is pressed in the input box or a selection is made in the suggestions dropdown.\n */", "onAdd", ":", "function", "(", "item", ")", "{", "// Check if it already exists in the suggestions list. Duplicates aren't allowed.", "var", "exists", "=", "false", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "suggestions", ".", "length", ";", "j", "++", ")", "{", "if", "(", "suggestions", "[", "j", "]", ".", "attr", "(", "'name'", ")", ".", "toLowerCase", "(", ")", "===", "item", ".", "name", ".", "toLowerCase", "(", ")", ")", "{", "exists", "=", "true", ";", "break", ";", "}", "}", "// If it didn't exist, add it to the list of suggestions and the searchTerms.", "if", "(", "!", "exists", ")", "{", "suggestions", ".", "push", "(", "item", ")", ";", "}", "// We are using searchTerms's setter to execute the filter, so have to set the property (not just update):", "var", "searchTerms", "=", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ")", ".", "attr", "(", ")", ".", "concat", "(", "item", ".", "name", ")", ";", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ",", "searchTerms", ")", ";", "}", ",", "/**\n * onDelete is used to remove items from searchTerms in the scope. It is called internally \n * by the jquery.tokenInput plugin when a tag gets removed from the input box.\n */", "onDelete", ":", "function", "(", "item", ")", "{", "var", "searchTerms", "=", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ")", ".", "attr", "(", ")", ",", "searchTerm", "=", "item", "&&", "(", "item", ".", "id", "||", "item", ".", "name", "||", "item", ")", ";", "searchTerms", ".", "splice", "(", "searchTerms", ".", "indexOf", "(", "searchTerm", ")", ",", "1", ")", ";", "// We are using searchTerms's setter to execute the filter, so have to set the property (not just update):", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ",", "searchTerms", ")", ";", "}", "}", ")", ";", "}" ]

[ "Run", "the", "jQuery", ".", "tokenizer", "plugin", "when", "the", "templated", "is", "inserted", ".", "When", "the", "input", "updates", "the", "tokenizer", "will", "update", "the", "searchTerms", "in", "the", "viewModel", "." ]

[ "function", "(", "item", ")", "{", "if", "(", "$", ".", "isEmptyObject", "(", "item", ")", ")", "{", "var", "tempObj", "=", "{", "id", ":", "$", "(", "'input:first'", ",", "el", ")", ".", "val", "(", ")", ",", "name", ":", "$", "(", "'input:first'", ",", "el", ")", ".", "val", "(", ")", "}", ";", "return", "[", "tempObj", "]", ";", "}", "else", "{", "return", "item", ";", "}", "}" ]

[ "onResult", "is", "used", "to", "pre", "-", "process", "suggestions", ".", "In", "our", "case", "we", "want", "to", "show", "current", "item", "if", "there", "is", "no", "results", "." ]

[ "function", "(", "item", ")", "{", "// Check if it already exists in the suggestions list. Duplicates aren't allowed.", "var", "exists", "=", "false", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "suggestions", ".", "length", ";", "j", "++", ")", "{", "if", "(", "suggestions", "[", "j", "]", ".", "attr", "(", "'name'", ")", ".", "toLowerCase", "(", ")", "===", "item", ".", "name", ".", "toLowerCase", "(", ")", ")", "{", "exists", "=", "true", ";", "break", ";", "}", "}", "// If it didn't exist, add it to the list of suggestions and the searchTerms.", "if", "(", "!", "exists", ")", "{", "suggestions", ".", "push", "(", "item", ")", ";", "}", "// We are using searchTerms's setter to execute the filter, so have to set the property (not just update):", "var", "searchTerms", "=", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ")", ".", "attr", "(", ")", ".", "concat", "(", "item", ".", "name", ")", ";", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ",", "searchTerms", ")", ";", "}" ]

[ "onAdd", "is", "used", "to", "maintain", "the", "suggestion", "dropdown", "box", "and", "the", "searchTerms", "in", "the", "scope", ".", "It", "is", "called", "internally", "by", "the", "jquery", ".", "tokenInput", "plugin", "when", "either", "the", "enter", "key", "is", "pressed", "in", "the", "input", "box", "or", "a", "selection", "is", "made", "in", "the", "suggestions", "dropdown", "." ]

[ "function", "(", "item", ")", "{", "var", "searchTerms", "=", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ")", ".", "attr", "(", ")", ",", "searchTerm", "=", "item", "&&", "(", "item", ".", "id", "||", "item", ".", "name", "||", "item", ")", ";", "searchTerms", ".", "splice", "(", "searchTerms", ".", "indexOf", "(", "searchTerm", ")", ",", "1", ")", ";", "// We are using searchTerms's setter to execute the filter, so have to set the property (not just update):", "self", ".", "viewModel", ".", "attr", "(", "'searchTerms'", ",", "searchTerms", ")", ";", "}" ]

[ "onDelete", "is", "used", "to", "remove", "items", "from", "searchTerms", "in", "the", "scope", ".", "It", "is", "called", "internally", "by", "the", "jquery", ".", "tokenInput", "plugin", "when", "a", "tag", "gets", "removed", "from", "the", "input", "box", "." ]

[ "function", "xPath", "(", "xPathString", ")", "{", "var", "xResult", "=", "document", ".", "evaluate", "(", "xPathString", ",", "document", ",", "null", ",", "0", ",", "null", ")", ";", "var", "xNodes", "=", "[", "]", ";", "var", "xRes", "=", "xResult", ".", "iterateNext", "(", ")", ";", "while", "(", "xRes", ")", "{", "xNodes", ".", "push", "(", "xRes", ")", ";", "xRes", "=", "xResult", ".", "iterateNext", "(", ")", ";", "}", "return", "xNodes", ";", "}" ]

[ "Evaluates", "xPath", "on", "a", "page" ]

[ "function", "execWaitReadyFunctions", "(", ")", "{", "if", "(", "isReady", "(", ")", ")", "{", "logger", ".", "info", "(", "'Page is ready. Executing '", "+", "callbacksOnReady", ".", "length", "+", "' functions that are waiting.'", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "callbacksOnReady", ".", "length", ";", "i", "++", ")", "{", "var", "callback", "=", "callbacksOnReady", "[", "i", "]", ";", "callback", "(", ")", ";", "}", "}", "}" ]

[ "Execute", "all", "the", "functions", "that", "are", "waiting", "for", "the", "page", "to", "finish", "loading" ]

[ "function", "whenReady", "(", "funcToExecute", ")", "{", "if", "(", "isReady", "(", ")", ")", "{", "logger", ".", "info", "(", "'Page is already loaded, instantly executing!'", ")", ";", "funcToExecute", "(", ")", ";", "return", ";", "}", "logger", ".", "info", "(", "'Waiting for page to be ready'", ")", ";", "callbacksOnReady", ".", "push", "(", "funcToExecute", ")", ";", "}" ]

[ "Returns", "a", "promise", "that", "resolves", "when", "the", "page", "is", "ready" ]

[ "function", "(", "adUnitSettings", ")", "{", "var", "containers", "=", "adUnitSettings", ".", "containers", ";", "var", "adContainers", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "containers", ".", "length", ";", "i", "++", ")", "{", "var", "container", "=", "containers", "[", "i", "]", ";", "var", "containerXPath", "=", "container", ".", "xPath", ";", "var", "adContainerElements", "=", "xPath", "(", "containerXPath", ")", ";", "if", "(", "!", "adContainerElements", ".", "length", ")", "{", "logger", ".", "warn", "(", "\"Ad container with xPath: \\\"\"", "+", "containerXPath", "+", "\"\\\" could not be found on page\"", ")", ";", "continue", ";", "}", "if", "(", "adContainerElements", ".", "length", ">", "1", ")", "{", "logger", ".", "warn", "(", "\"Ad container with xPath: \\\"\"", "+", "containerXPath", "+", "\"\\\" has multiple matches\"", ")", ";", "}", "adContainers", ".", "push", "(", "new", "AdContainer", "(", "container", ",", "adContainerElements", "[", "0", "]", ")", ")", ";", "}", "return", "adContainers", ";", "}" ]

[ "Gets", "the", "adcontainers", "on", "the", "page", "from", "the", "container", "xPath" ]

[ "function", "render", "(", "expr", ",", "traverse", ",", "path", ",", "state", ")", "{", "if", "(", "isString", "(", "expr", ")", ")", "{", "utils", ".", "append", "(", "expr", ",", "state", ")", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "expr", ")", ")", "{", "expr", ".", "forEach", "(", "function", "(", "w", ")", "{", "render", "(", "w", ",", "traverse", ",", "path", ",", "state", ")", ";", "}", ")", ";", "}", "else", "{", "utils", ".", "move", "(", "expr", ".", "range", "[", "0", "]", ",", "state", ")", ";", "traverse", "(", "expr", ",", "path", ",", "state", ")", ";", "utils", ".", "catchup", "(", "expr", ".", "range", "[", "1", "]", ",", "state", ")", ";", "}", "}" ]

[ "Render", "an", "expression" ]

[ "function", "renderExpressionMemoized", "(", "expr", ",", "traverse", ",", "path", ",", "state", ")", "{", "var", "evaluated", ";", "if", "(", "expr", ".", "type", "===", "Syntax", ".", "Identifier", ")", "{", "evaluated", "=", "expr", ".", "name", ";", "}", "else", "if", "(", "isString", "(", "expr", ")", ")", "{", "evaluated", "=", "expr", ";", "}", "else", "{", "evaluated", "=", "genID", "(", "'var'", ")", ";", "utils", ".", "append", "(", "evaluated", "+", "' = '", ",", "state", ")", ";", "render", "(", "expr", ",", "traverse", ",", "path", ",", "state", ")", ";", "utils", ".", "append", "(", "', '", ",", "state", ")", ";", "}", "return", "evaluated", ";", "}" ]

[ "Render", "expression", "into", "a", "variable", "declaration", "and", "return", "its", "id", "." ]

[ "function", "renderDesructuration", "(", "pattern", ",", "expr", ",", "traverse", ",", "path", ",", "state", ")", "{", "utils", ".", "catchupNewlines", "(", "pattern", ".", "range", "[", "1", "]", ",", "state", ")", ";", "var", "id", ";", "if", "(", "pattern", ".", "type", "===", "Syntax", ".", "ObjectPattern", "&&", "pattern", ".", "properties", ".", "length", "===", "1", ")", "{", "id", "=", "expr", ";", "}", "else", "if", "(", "pattern", ".", "type", "===", "Syntax", ".", "ArrayPattern", "&&", "pattern", ".", "elements", ".", "length", "===", "1", ")", "{", "id", "=", "expr", ";", "}", "else", "{", "id", "=", "renderExpressionMemoized", "(", "expr", ",", "traverse", ",", "path", ",", "state", ")", ";", "}", "if", "(", "pattern", ".", "type", "===", "Syntax", ".", "ObjectPattern", ")", "{", "pattern", ".", "properties", ".", "forEach", "(", "function", "(", "prop", ",", "idx", ")", "{", "var", "comma", "=", "(", "idx", "!==", "pattern", ".", "properties", ".", "length", "-", "1", ")", "?", "', '", ":", "''", ";", "if", "(", "isPattern", "(", "prop", ".", "value", ")", ")", "{", "renderDesructuration", "(", "prop", ".", "value", ",", "[", "id", ",", "'.'", ",", "prop", ".", "key", ".", "name", "]", ",", "traverse", ",", "path", ",", "state", ")", ";", "}", "else", "{", "utils", ".", "append", "(", "prop", ".", "value", ".", "name", "+", "' = '", ",", "state", ")", ";", "render", "(", "[", "id", ",", "'.'", "+", "prop", ".", "key", ".", "name", "]", ",", "traverse", ",", "path", ",", "state", ")", ";", "utils", ".", "append", "(", "comma", ",", "state", ")", ";", "}", "}", ")", ";", "}", "else", "{", "pattern", ".", "elements", ".", "forEach", "(", "function", "(", "elem", ",", "idx", ")", "{", "// null means skip", "if", "(", "elem", "===", "null", ")", "{", "return", ";", "}", "var", "comma", "=", "(", "idx", "!==", "pattern", ".", "elements", ".", "length", "-", "1", ")", "?", "', '", ":", "''", ";", "if", "(", "isPattern", "(", "elem", ")", ")", "{", "renderDesructuration", "(", "elem", ",", "[", "id", ",", "'['", "+", "idx", "+", "']'", "]", ",", "traverse", ",", "path", ",", "state", ")", ";", "}", "else", "if", "(", "elem", ".", "type", "===", "Syntax", ".", "SpreadElement", ")", "{", "utils", ".", "append", "(", "elem", ".", "argument", ".", "name", "+", "' = '", ",", "state", ")", ";", "render", "(", "[", "id", ",", "'.slice('", "+", "idx", "+", "')'", "]", ",", "traverse", ",", "path", ",", "state", ")", ";", "utils", ".", "append", "(", "comma", ",", "state", ")", ";", "}", "else", "{", "utils", ".", "append", "(", "elem", ".", "name", "+", "' = '", ",", "state", ")", ";", "render", "(", "[", "id", ",", "'['", "+", "idx", "+", "']'", "]", ",", "traverse", ",", "path", ",", "state", ")", ";", "utils", ".", "append", "(", "comma", ",", "state", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "Render", "destructuration", "of", "the", "expr", "using", "provided", "pattern", "." ]

[ "function", "(", "inPositions", ")", "{", "var", "p", "=", "inPositions", ";", "// yay math!, rad -> deg", "var", "a", "=", "Math", ".", "asin", "(", "p", ".", "y", "/", "p", ".", "h", ")", "*", "(", "180", "/", "Math", ".", "PI", ")", ";", "// fix for range limits of asin (-90 to 90)", "// Quadrants II and III", "if", "(", "p", ".", "x", "<", "0", ")", "{", "a", "=", "180", "-", "a", ";", "}", "// Quadrant IV", "if", "(", "p", ".", "x", ">", "0", "&&", "p", ".", "y", "<", "0", ")", "{", "a", "+=", "360", ";", "}", "return", "a", ";", "}" ]

[ "find", "rotation", "angle" ]

[ "function", "(", "inPositions", ")", "{", "// the least recent touch and the most recent touch determine the bounding box of the gesture event", "var", "p", "=", "inPositions", ";", "// center the first touch as 0,0", "return", "{", "magnitude", ":", "p", ".", "h", ",", "xcenter", ":", "Math", ".", "abs", "(", "Math", ".", "round", "(", "p", ".", "fx", "+", "(", "p", ".", "x", "/", "2", ")", ")", ")", ",", "ycenter", ":", "Math", ".", "abs", "(", "Math", ".", "round", "(", "p", ".", "fy", "+", "(", "p", ".", "y", "/", "2", ")", ")", ")", "}", ";", "}" ]

[ "find", "bounding", "box" ]

[ "function", "(", "inInfos", ",", "inCommonInfo", ")", "{", "if", "(", "inInfos", ")", "{", "var", "cs", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ",", "ci", ";", "(", "ci", "=", "inInfos", "[", "i", "]", ")", ";", "i", "++", ")", "{", "cs", ".", "push", "(", "this", ".", "_createComponent", "(", "ci", ",", "inCommonInfo", ")", ")", ";", "}", "return", "cs", ";", "}", "}" ]

[ "Creates", "Components", "as", "defined", "by", "the", "array", "of", "configurations", "_inInfo_", ".", "Each", "configuration", "in", "_inInfo_", "is", "combined", "with", "_inCommonInfo_", "as", "described", "in", "_createComponent_", "." ]

[ "function", "(", "inMethodName", ",", "inEvent", ",", "inSender", ")", "{", "var", "fn", "=", "inMethodName", "&&", "this", "[", "inMethodName", "]", ";", "if", "(", "fn", ")", "{", "return", "fn", ".", "call", "(", "this", ",", "inSender", "||", "this", ",", "inEvent", ")", ";", "}", "}" ]

[ "Dispatch", "the", "event", "to", "named", "delegate", "inMethodName", "if", "it", "exists", ".", "Sub", "-", "kinds", "may", "re", "-", "route", "dispatches", ".", "Note", "that", "both", "handlers", "events", "and", "events", "delegated", "from", "owned", "controls", "arrive", "here", ".", "If", "you", "need", "to", "handle", "these", "differently", "you", "may", "need", "to", "also", "override", "dispatchEvent", "." ]

[ "function", "(", "inMessageName", ",", "inMessage", ",", "inSender", ")", "{", "//this.log(inMessageName, (inSender || this).name, \"=>\", this.name);\r", "if", "(", "this", ".", "dispatchEvent", "(", "inMessageName", ",", "inMessage", ",", "inSender", ")", ")", "{", "return", "true", ";", "}", "this", ".", "waterfallDown", "(", "inMessageName", ",", "inMessage", ",", "inSender", "||", "this", ")", ";", "}" ]

[ "Sends", "a", "message", "to", "myself", "and", "my", "descendants", "." ]

[ "function", "restoreState", "(", "top_err", ")", "{", "if", "(", "previous_state", "===", "true", ")", "{", "that", ".", "pause", "(", "function", "madePaused", "(", "err", ")", "{", "// Ignore errors?", "callback", "(", "top_err", ")", ";", "}", ")", ";", "}", "else", "{", "callback", "(", "top_err", ")", ";", "}", "}" ]

[ "Function", "to", "restate", "paused", "state" ]

[ "function", "done", "(", "err", ")", "{", "that", ".", "_gcw", "=", "'done_get_creatures'", ";", "bomb", ".", "defuse", "(", ")", ";", "// Unsee the 'getting_creatures' event", "that", ".", "unsee", "(", "'getting_creatures'", ")", ";", "// Call next on the next tick (in case we call back with an error)", "Blast", ".", "nextTick", "(", "next", ")", ";", "if", "(", "err", ")", "{", "that", ".", "log", "(", "'error'", ",", "'Error getting creatures: '", "+", "err", ")", "callback", "(", "err", ")", ";", "}", "else", "{", "let", "result", "=", "[", "]", ";", "for", "(", "let", "id", "in", "that", ".", "creatures_by_id", ")", "{", "if", "(", "that", ".", "creatures_by_id", "[", "id", "]", ")", "{", "result", ".", "push", "(", "that", ".", "creatures_by_id", "[", "id", "]", ")", ";", "}", "}", "callback", "(", "null", ",", "result", ")", ";", "that", ".", "emit", "(", "'_got_creatures'", ",", "err", ",", "result", ")", ";", "}", "}" ]

[ "Function", "that", "ll", "call", "next", "on", "the", "queue", "&", "the", "callback" ]

[ "function", "flux", "(", "path", ")", "{", "return", "function", "(", "done", ")", "{", "fs", ".", "createReadStream", "(", "resolve", "(", "__dirname", ",", "path", ")", ")", ".", "pipe", "(", "docflux", "(", ")", ")", ".", "pipe", "(", "docflux", ".", "markdown", "(", "{", "depth", ":", "DEPTH", ",", "indent", ":", "INDENT", "}", ")", ")", ".", "pipe", "(", "concat", "(", "function", "(", "data", ")", "{", "done", "(", "null", ",", "data", ".", "toString", "(", ")", ")", "}", ")", ")", "}", "}" ]

[ "Return", "a", "docflux", "transformer", "function" ]

[ "function", "PushInitiator", "(", "applicationId", ",", "password", ",", "contentProviderId", ",", "evaluation", ")", "{", "this", ".", "applicationId", "=", "applicationId", ";", "this", ".", "authToken", "=", "new", "Buffer", "(", "applicationId", "+", "':'", "+", "password", ")", ".", "toString", "(", "'base64'", ")", ";", "this", ".", "contentProviderId", "=", "contentProviderId", ";", "this", ".", "isEvaluation", "=", "evaluation", "||", "false", ";", "}" ]

[ "Creats", "a", "new", "PushInitiator", "object", "that", "can", "be", "used", "to", "push", "messages", "to", "the", "Push", "Protocol", "Gateway", "." ]

[ "function", "findById", "(", "id", ",", "cb", ")", "{", "db", ".", "getClient", "(", "function", "(", "err", ",", "client", ",", "done", ")", "{", "client", ".", "query", "(", "SELECT_ID", ",", "[", "id", "]", ",", "function", "(", "err", ",", "r", ")", "{", "var", "result", "=", "r", "&&", "r", ".", "rows", "[", "0", "]", ";", "if", "(", "!", "err", "&&", "!", "result", ")", "err", "=", "new", "exceptions", ".", "NotFound", "(", ")", ";", "if", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "done", "(", "err", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "result", ")", ";", "done", "(", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Finds", "a", "tag", "by", "id" ]

[ "function", "create", "(", "body", ",", "cb", ")", "{", "var", "validates", "=", "Schema", "(", "body", ")", ";", "if", "(", "!", "validates", ")", "{", "return", "cb", "(", "new", "exceptions", ".", "BadRequest", "(", ")", ")", ";", "}", "body", ".", "slug", "=", "string", ".", "slugify", "(", "body", ".", "title", ")", ";", "var", "q", "=", "qb", ".", "insert", "(", "body", ")", ";", "db", ".", "getClient", "(", "function", "(", "err", ",", "client", ",", "done", ")", "{", "client", ".", "query", "(", "q", "[", "0", "]", ",", "q", "[", "1", "]", ",", "function", "(", "err", ",", "r", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", ".", "code", "==", "23505", ")", "{", "err", "=", "new", "exceptions", ".", "AlreadyExists", "(", ")", ";", "}", "cb", "(", "err", ")", ";", "done", "(", "err", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "r", ".", "rows", "[", "0", "]", ")", ";", "done", "(", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Creates", "a", "new", "tag", "." ]

[ "function", "all", "(", "options", ",", "cb", ")", "{", "var", "q", ",", "page", "=", "Number", "(", "options", ".", "page", ")", "||", "1", ",", "limit", "=", "Number", "(", "options", ".", "limit", ")", "||", "conf", ".", "objects_by_page", ",", "offset", "=", "(", "page", "-", "1", ")", "*", "limit", ";", "count", "(", "function", "(", "err", ",", "count", ")", "{", "if", "(", "err", ")", "{", "return", "cb", "(", "err", ")", ";", "}", "q", "=", "select", "(", "'LEFT JOIN'", ")", ";", "q", "+=", "' LIMIT '", "+", "limit", "+", "' OFFSET '", "+", "offset", ";", "db", ".", "getClient", "(", "function", "(", "err", ",", "client", ",", "done", ")", "{", "client", ".", "query", "(", "q", ",", "function", "(", "err", ",", "r", ")", "{", "if", "(", "err", ")", "{", "cb", "(", "err", ")", ";", "done", "(", "err", ")", ";", "}", "else", "{", "cb", "(", "null", ",", "{", "rows", ":", "r", ".", "rows", ",", "count", ":", "count", ",", "limit", ":", "limit", ",", "offset", ":", "offset", ",", "page", ":", "page", "}", ")", ";", "done", "(", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Finds", "all", "tags" ]

[ "function", "nodeJsGlobalResolverFn", "(", "normalizedId", ")", "{", "var", "globalId", "=", "normalizedId", ".", "id", ";", "var", "x", "=", "global", "[", "globalId", "]", ";", "if", "(", "!", "x", ")", "{", "var", "msg", "=", "'Could not find global Node module ['", "+", "globalId", "+", "']'", ";", "throw", "new", "Error", "(", "buildMissingDepMsg", "(", "msg", ",", "globalId", ",", "Object", ".", "keys", "(", "global", ")", ")", ")", ";", "}", "return", "x", ";", "}" ]

[ "Returns", "a", "variable", "that", "available", "in", "the", "list", "of", "globals" ]

[ "function", "nodeModulesResolverFn", "(", "normalizedId", ")", "{", "if", "(", "!", "nodeModulesAt", ")", "{", "throw", "new", "Error", "(", "'Before you can load external dependencies, you must specify where node_modules can be found by '", "+", "'setting the \\'nodeModulesAt\\' option when creating the context'", ")", ";", "}", "var", "extId", "=", "normalizedId", ".", "id", ";", "var", "modulePath", "=", "path", ".", "join", "(", "nodeModulesAt", ",", "extId", ")", ";", "if", "(", "!", "externalDepExists", "[", "modulePath", "]", ")", "{", "// yes I know the docs don't like this method.", "// But it's a little better user experience than trying to require a file that isn't there.", "if", "(", "fs", ".", "existsSync", "(", "modulePath", ")", ")", "{", "externalDepExists", "[", "modulePath", "]", "=", "true", ";", "// cache it so we avoid the lookup next time", "}", "else", "{", "var", "msg", "=", "'Could not find external dependency ['", "+", "extId", "+", "'] at path ['", "+", "modulePath", "+", "']'", ";", "throw", "new", "Error", "(", "buildMissingDepMsg", "(", "msg", ",", "extId", ",", "allExternalIds", "(", ")", ")", ")", ";", "}", "}", "return", "require", "(", "modulePath", ")", ";", "}" ]

[ "Requires", "modules", "from", "the", "node_modules", "directory" ]

[ "function", "idbReadableStream", "(", "db", ",", "storeName", ",", "opts", ")", "{", "if", "(", "typeof", "db", "!==", "'object'", ")", "throw", "new", "TypeError", "(", "'db must be an object'", ")", "if", "(", "typeof", "storeName", "!==", "'string'", ")", "throw", "new", "TypeError", "(", "'storeName must be a string'", ")", "if", "(", "opts", "==", "null", ")", "opts", "=", "{", "}", "if", "(", "typeof", "opts", "!==", "'object'", ")", "throw", "new", "TypeError", "(", "'opts must be an object'", ")", "// use transform stream for buffering and back pressure", "var", "transformer", "=", "new", "stream", ".", "Transform", "(", "xtend", "(", "opts", ",", "{", "objectMode", ":", "true", ",", "transform", ":", "function", "(", "obj", ",", "enc", ",", "cb", ")", "{", "cb", "(", "null", ",", "obj", ")", "}", "}", ")", ")", "opts", "=", "xtend", "(", "{", "snapshot", ":", "false", "}", ",", "opts", ")", "var", "lastIteratedKey", "=", "null", "transformer", ".", "_cursorsOpened", "=", "0", "function", "startCursor", "(", ")", "{", "var", "lower", ",", "upper", ",", "lowerOpen", ",", "upperOpen", "var", "direction", "=", "opts", ".", "direction", "||", "'next'", "var", "range", "=", "opts", ".", "range", "||", "{", "}", "lower", "=", "range", ".", "lower", "upper", "=", "range", ".", "upper", "lowerOpen", "=", "!", "!", "range", ".", "lowerOpen", "upperOpen", "=", "!", "!", "range", ".", "upperOpen", "// if this is not the first iteration, use lastIteratedKey", "if", "(", "lastIteratedKey", ")", "{", "if", "(", "direction", "===", "'next'", ")", "{", "lowerOpen", "=", "true", "// exclude the last iterated key itself", "lower", "=", "lastIteratedKey", "}", "else", "{", "upperOpen", "=", "true", "// exclude the last iterated key itself", "upper", "=", "lastIteratedKey", "}", "}", "var", "keyRange", "if", "(", "lower", "&&", "upper", ")", "keyRange", "=", "IDBKeyRange", ".", "bound", "(", "lower", ",", "upper", ",", "lowerOpen", ",", "upperOpen", ")", "else", "if", "(", "lower", ")", "keyRange", "=", "IDBKeyRange", ".", "lowerBound", "(", "lower", ",", "lowerOpen", ")", "else", "if", "(", "upper", ")", "keyRange", "=", "IDBKeyRange", ".", "upperBound", "(", "upper", ",", "upperOpen", ")", "var", "tx", "=", "db", ".", "transaction", "(", "storeName", ",", "'readonly'", ")", "var", "store", "=", "tx", ".", "objectStore", "(", "storeName", ")", "transformer", ".", "_cursorsOpened", "++", "var", "req", "=", "store", ".", "openCursor", "(", "keyRange", ",", "opts", ".", "direction", ")", "function", "proceed", "(", "cursor", ")", "{", "try", "{", "cursor", ".", "continue", "(", ")", "// throws a TransactionInactiveError if the cursor timed out", "}", "catch", "(", "err", ")", "{", "// either reopen a cursor or propagate the error", "if", "(", "err", ".", "name", "===", "'TransactionInactiveError'", "&&", "!", "opts", ".", "snapshot", ")", "startCursor", "(", ")", "// IndexedDB timed out the cursor", "else", "transformer", ".", "emit", "(", "'error'", ",", "err", ")", "}", "}", "req", ".", "onsuccess", "=", "function", "(", ")", "{", "var", "cursor", "=", "req", ".", "result", "if", "(", "cursor", ")", "{", "lastIteratedKey", "=", "cursor", ".", "key", "var", "go", "=", "transformer", ".", "write", "(", "{", "key", ":", "cursor", ".", "key", ",", "value", ":", "cursor", ".", "value", "}", ")", "if", "(", "opts", ".", "snapshot", "||", "go", ")", "proceed", "(", "cursor", ")", "else", "transformer", ".", "once", "(", "'drain'", ",", "function", "(", ")", "{", "proceed", "(", "cursor", ")", "}", ")", "}", "else", "transformer", ".", "end", "(", ")", "}", "tx", ".", "onabort", "=", "function", "(", ")", "{", "transformer", ".", "emit", "(", "'error'", ",", "tx", ".", "error", ")", "}", "tx", ".", "onerror", "=", "function", "(", ")", "{", "transformer", ".", "emit", "(", "'error'", ",", "tx", ".", "error", ")", "}", "}", "startCursor", "(", ")", "return", "transformer", "}" ]

[ "Iterate", "over", "an", "IndexedDB", "object", "store", "with", "a", "readable", "stream", "." ]

[ "function", "bin", "(", "argv", ")", "{", "var", "uri", "=", "argv", "[", "2", "]", "if", "(", "!", "uri", ")", "{", "console", ".", "error", "(", "'uri is required'", ")", "}", "shell", ".", "ls", "(", "uri", ",", "function", "(", "err", ",", "arr", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "arr", ".", "length", ";", "i", "++", ")", "{", "console", ".", "log", "(", "arr", "[", "i", "]", ")", "}", "}", ")", "}" ]

[ "list", "the", "contents", "of", "a", "directory" ]

[ "function", "fileExist", "(", "fileName", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "fs", ".", "stat", "(", "fileName", ",", "(", "err", ",", "stats", ")", "=>", "{", "if", "(", "err", "===", "null", "&&", "stats", ".", "isFile", "(", ")", ")", "{", "resolve", "(", "fileName", ")", ";", "}", "else", "{", "resolve", "(", "false", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}" ]

[ "Promisified", "file", "exist", "check" ]

[ "function", "SQL", "(", "strs", ")", "{", "for", "(", "var", "_len", "=", "arguments", ".", "length", ",", "args", "=", "Array", "(", "_len", ">", "1", "?", "_len", "-", "1", ":", "0", ")", ",", "_key", "=", "1", ";", "_key", "<", "_len", ";", "_key", "++", ")", "{", "args", "[", "_key", "-", "1", "]", "=", "arguments", "[", "_key", "]", ";", "}", "var", "values", "=", "[", "]", ";", "var", "text", "=", "strs", ".", "reduce", "(", "function", "(", "prev", ",", "curr", ",", "i", ")", "{", "var", "arg", "=", "args", "[", "i", "-", "1", "]", ";", "if", "(", "arg", "instanceof", "InsertValue", ")", "{", "return", "prev", "+", "arg", ".", "value", "+", "curr", ";", "}", "else", "{", "values", ".", "push", "(", "arg", ")", ";", "return", "prev", "+", "'$'", "+", "values", ".", "length", "+", "curr", ";", "}", "}", ")", ";", "return", "{", "text", ":", "text", ",", "values", ":", "values", "}", ";", "}" ]

[ "for", "postgres", "sql" ]

[ "function", "AsyncSimpleIterator", "(", "options", ")", "{", "if", "(", "!", "(", "this", "instanceof", "AsyncSimpleIterator", ")", ")", "{", "return", "new", "AsyncSimpleIterator", "(", "options", ")", "}", "this", ".", "defaultOptions", "(", "options", ")", "AppBase", ".", "call", "(", "this", ")", "this", ".", "on", "=", "utils", ".", "emitter", ".", "compose", ".", "call", "(", "this", ",", "'on'", ",", "this", ".", "options", ")", "this", ".", "off", "=", "utils", ".", "emitter", ".", "compose", ".", "call", "(", "this", ",", "'off'", ",", "this", ".", "options", ")", "this", ".", "once", "=", "utils", ".", "emitter", ".", "compose", ".", "call", "(", "this", ",", "'once'", ",", "this", ".", "options", ")", "this", ".", "emit", "=", "utils", ".", "emitter", ".", "compose", ".", "call", "(", "this", ",", "'emit'", ",", "this", ".", "options", ")", "}" ]

[ ">", "Initialize", "AsyncSimpleIterator", "with", "options", "." ]

[ "function", "checkMediaProfileSpecType", "(", "key", ",", "value", ")", "{", "if", "(", "typeof", "value", "!=", "'string'", ")", "throw", "SyntaxError", "(", "key", "+", "' param should be a String, not '", "+", "typeof", "value", ")", ";", "if", "(", "!", "value", ".", "match", "(", "'WEBM|MP4|WEBM_VIDEO_ONLY|WEBM_AUDIO_ONLY|MP4_VIDEO_ONLY|MP4_AUDIO_ONLY'", ")", ")", "throw", "SyntaxError", "(", "key", "+", "' param is not one of [WEBM|MP4|WEBM_VIDEO_ONLY|WEBM_AUDIO_ONLY|MP4_VIDEO_ONLY|MP4_AUDIO_ONLY] ('", "+", "value", "+", "')'", ")", ";", "}" ]

[ "Media", "Profile", ".", "Currently", "WEBM", "and", "MP4", "are", "supported", "." ]

[ "function", "createApplication", "(", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "var", "sapp", "=", "new", "Application", "(", ")", ";", "sapp", ".", "sycle", "=", "sycle", ";", "if", "(", "options", ".", "loadBuiltinModels", ")", "{", "sapp", ".", "phase", "(", "require", "(", "'./boot/builtin-models'", ")", "(", ")", ")", ";", "}", "return", "sapp", ";", "}" ]

[ "Create", "an", "sycle", "application", "." ]

[ "function", "enqueueAll", "(", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "count", "-", "1", ";", "i", "++", ")", "{", "enqueue", "(", ")", ";", "}", "return", "enqueue", "(", ")", ";", "function", "enqueue", "(", ")", "{", "return", "queue", ".", "enqueue", "(", "(", ")", "=>", "new", "Date", "(", ")", ")", ";", "}", "}" ]

[ "100000", "functions", "enqueued", "in", "798", "ms" ]

[ "function", "bakeFolder", "(", "source", ",", "dest", ")", "{", "var", "args", "=", "createArgs", "(", "source", ",", "dest", ",", "{", "}", ")", ";", "wrapFunction", "(", "'BakeFolder'", ",", "args", ",", "function", "(", ")", "{", "args", ".", "files", "=", "fs", ".", "readdirSync", "(", "args", ".", "source", ")", ";", "args", ".", "filters", "=", "[", "filterHidden", "]", ";", "wrapFunction", "(", "'FilterFiles'", ",", "args", ",", "function", "(", ")", "{", "args", ".", "filters", ".", "forEach", "(", "function", "(", "filter", ")", "{", "args", ".", "files", "=", "args", ".", "files", ".", "filter", "(", "filter", ")", ";", "}", ")", ";", "}", ")", ";", "delete", "args", ".", "filters", ";", "wrapFunction", "(", "'BakeFiles'", ",", "args", ",", "function", "(", ")", "{", "var", "files", "=", "[", "]", ",", "dirs", "=", "[", "]", ";", "// seperate the files from the directories", "args", ".", "files", ".", "forEach", "(", "function", "(", "file", ")", "{", "var", "stats", "=", "fs", ".", "statSync", "(", "path", ".", "join", "(", "args", ".", "source", ",", "file", ")", ")", ";", "if", "(", "stats", ".", "isDirectory", "(", ")", ")", "{", "dirs", ".", "push", "(", "file", ")", ";", "}", "else", "{", "files", ".", "push", "(", "file", ")", ";", "}", "}", ")", ";", "// process all the files first", "files", ".", "forEach", "(", "function", "(", "file", ")", "{", "bakeFile", "(", "path", ".", "join", "(", "args", ".", "source", ",", "file", ")", ",", "path", ".", "join", "(", "args", ".", "dest", ",", "file", ")", ")", ";", "}", ")", ";", "// and then process the sub directories", "dirs", ".", "forEach", "(", "function", "(", "file", ")", "{", "bakeFolder", "(", "path", ".", "join", "(", "args", ".", "source", ",", "file", ")", ",", "path", ".", "join", "(", "args", ".", "dest", ",", "file", ")", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ";", "function", "filterHidden", "(", "file", ")", "{", "return", "!", "(", "/", "^\\.|~$", "/", ")", ".", "test", "(", "file", ")", ";", "}", "}" ]

[ "processes", "all", "the", "files", "in", "a", "folder" ]

[ "function", "defaults", "(", "route", ",", "name", ",", "handle", ")", "{", "if", "(", "typeof", "route", "===", "'function'", ")", "{", "handle", "=", "route", ";", "name", "=", "handle", ".", "name", ";", "route", "=", "'/'", ";", "}", "else", "if", "(", "typeof", "name", "===", "'function'", ")", "{", "handle", "=", "name", ";", "name", "=", "handle", ".", "name", ";", "}", "// A name needs to be provided", "if", "(", "!", "name", ")", "throw", "new", "NameError", "(", ")", ";", "// wrap sub-apps", "if", "(", "'function'", "==", "typeof", "handle", ".", "handle", ")", "{", "var", "server", "=", "handle", ";", "handle", ".", "route", "=", "route", ";", "handle", "=", "function", "(", "req", ",", "res", ",", "next", ")", "{", "server", ".", "handle", "(", "req", ",", "res", ",", "next", ")", ";", "}", ";", "}", "// wrap vanilla http.Servers", "if", "(", "handle", "instanceof", "http", ".", "Server", ")", "{", "handle", "=", "handle", ".", "listeners", "(", "'request'", ")", "[", "0", "]", ";", "}", "// strip trailing slash", "if", "(", "'/'", "==", "route", "[", "route", ".", "length", "-", "1", "]", ")", "{", "route", "=", "route", ".", "slice", "(", "0", ",", "-", "1", ")", ";", "}", "return", "{", "route", ":", "route", ",", "name", ":", "name", ",", "handle", ":", "handle", "}", ";", "}" ]

[ "Default", "the", "parameters" ]

[ "function", "NameError", "(", "message", ")", "{", "Error", ".", "call", "(", "this", ")", ";", "Error", ".", "captureStackTrace", "(", "this", ",", "arguments", ".", "callee", ")", ";", "this", ".", "name", "=", "'Middleware Name Error'", ";", "this", ".", "message", "=", "message", "||", "'The argument must be a named function or supply a name'", ";", "}" ]

[ "errors", "Define", "an", "error", "for", "middleware", "not", "being", "named" ]

[ "function", "ExistsError", "(", "name", ",", "message", ")", "{", "Error", ".", "call", "(", "this", ")", ";", "Error", ".", "captureStackTrace", "(", "this", ",", "arguments", ".", "callee", ")", ";", "this", ".", "name", "=", "'Middleware Exists Error'", ";", "this", ".", "message", "=", "message", "||", "'Middleware named '", "+", "name", "+", "' already exists. Provide an alternative name.'", ";", "}" ]

[ "Define", "an", "error", "for", "middleware", "already", "in", "the", "stack" ]

[ "function", "NotFoundError", "(", "name", ")", "{", "Error", ".", "call", "(", "this", ")", ";", "Error", ".", "captureStackTrace", "(", "this", ",", "arguments", ".", "callee", ")", ";", "this", ".", "name", "=", "'Middleware Not Found Error'", ";", "this", ".", "message", "=", "name", "+", "' not found in the current stack'", ";", "}" ]

[ "Define", "an", "error", "for", "middleware", "not", "found", "in", "the", "stack" ]

[ "function", "Process", "(", "settings", ")", "{", "// save arguments", "this", ".", "settings", "=", "settings", ";", "// build args", "this", ".", "args", "=", "[", "settings", ".", "file", "]", ".", "concat", "(", "settings", ".", "args", "||", "[", "]", ")", ";", "// build env", "this", ".", "env", "=", "helpers", ".", "mergeObject", "(", "{", "}", ",", "settings", ".", "env", "||", "process", ".", "env", ")", ";", "if", "(", "settings", ".", "options", ")", "{", "this", ".", "env", ".", "spawnOptions", "=", "JSON", ".", "stringify", "(", "settings", ".", "options", ")", ";", "}", "// defaults properties", "this", ".", "closed", "=", "!", "!", "settings", ".", "close", ";", "this", ".", "suicide", "=", "false", ";", "this", ".", "pid", "=", "null", ";", "this", ".", "alive", "=", "false", ";", "// this streams will relay data from and to the process", "this", ".", "stderr", "=", "new", "streams", ".", "RelayStream", "(", "{", "paused", ":", "false", "}", ")", ";", "this", ".", "stdout", "=", "new", "streams", ".", "RelayStream", "(", "{", "paused", ":", "false", "}", ")", ";", "this", ".", "stdin", "=", "new", "streams", ".", "RelayStream", "(", "{", "paused", ":", "false", "}", ")", ";", "// relay io", "if", "(", "this", ".", "settings", ".", "ipc", "&&", "helpers", ".", "support", ".", "pipeFork", ")", "{", "this", ".", "send", "=", "function", "(", ")", "{", "this", ".", "process", ".", "send", ".", "apply", "(", "this", ".", "process", ",", "arguments", ")", ";", "}", ";", "this", ".", "flush", "=", "function", "(", ")", "{", "}", ";", "}", "}" ]

[ "this", "constrcutor", "will", "spawn", "a", "new", "process", "using", "a", "option", "object" ]

[ "function", "(", ")", "{", "var", "suicide", "=", "self", ".", "suicide", ";", "self", ".", "suicide", "=", "false", ";", "self", ".", "alive", "=", "false", ";", "self", ".", "emit", "(", "'stop'", ",", "suicide", ")", ";", "}" ]

[ "handle", "process", "stdio", "close", "event" ]

[ "function", "forceClose", "(", "channel", ")", "{", "if", "(", "!", "channel", ")", "return", ";", "var", "destroyer", "=", "setTimeout", "(", "function", "(", ")", "{", "channel", ".", "destroy", "(", ")", ";", "}", ",", "200", ")", ";", "channel", ".", "once", "(", "'close'", ",", "function", "(", ")", "{", "clearTimeout", "(", "destroyer", ")", ";", "}", ")", ";", "}" ]

[ "close", "all", "streams" ]