Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "makeChainedCallback", "(", "i", ",", "fns", ",", "results", ",", "cb", ")", "{", "return", "function", "(", "err", ",", "result", ")", "{", "if", "(", "err", ")", "{", "return", "cb", "(", "err", ")", ";", "}", "results", "[", "i", "]", "=", "result", ";", "if", "(", "fns", "[", "i", "+", "1", "]", ")", "{", "return", "fns", "[", "i", "+", "1", "]", "(", "makeChainedCallback", "(", "i", "+", "1", ",", "fns", ",", "results", ",", "cb", ")", ")", ";", "}", "else", "{", "return", "cb", "(", "null", ",", "results", ")", ";", "}", "}", ";", "}" ]

[ "Create", "a", "function", "that", "will", "call", "the", "next", "function", "in", "a", "chain", "when", "finished" ]

[ "function", "makeCountNCallback", "(", "n", ",", "cb", ")", "{", "var", "count", "=", "0", ",", "results", "=", "[", "]", ",", "error", ";", "return", "function", "(", "index", ",", "err", ",", "result", ")", "{", "results", "[", "index", "]", "=", "result", ";", "if", "(", "!", "error", "&&", "err", ")", "{", "error", "=", "err", ";", "return", "cb", "(", "err", ")", ";", "}", "if", "(", "!", "error", "&&", "++", "count", "==", "n", ")", "{", "cb", "(", "null", ",", "results", ")", ";", "}", "}", ";", "}" ]

[ "Create", "a", "function", "that", "will", "call", "a", "callback", "after", "n", "function", "calls" ]

[ "function", "logentriesRawStream", "(", "pathname", ",", "query", "=", "{", "}", ")", "{", "query", "=", "Object", ".", "assign", "(", "{", "}", ",", "query", ")", ";", "// If query format is not defined, we set it by default to JSON.", "if", "(", "!", "query", ".", "format", ")", "{", "query", ".", "format", "=", "'json'", ";", "}", "// Text format is default in Logentries, in this case we remove the parameter.", "if", "(", "query", ".", "format", "===", "'text'", ")", "{", "delete", "query", ".", "format", ";", "}", "// Put default start and/or end times, if not given.", "if", "(", "!", "query", ".", "start", "&&", "!", "query", ".", "end", ")", "{", "query", ".", "end", "=", "Date", ".", "now", "(", ")", ";", "query", ".", "start", "=", "query", ".", "end", "-", "15", "*", "60", "*", "1000", ";", "// 15 minutes", "}", "else", "if", "(", "!", "query", ".", "start", ")", "{", "query", ".", "start", "=", "query", ".", "end", "-", "15", "*", "60", "*", "1000", ";", "}", "else", "if", "(", "!", "query", ".", "end", ")", "{", "query", ".", "end", "=", "query", ".", "start", "+", "15", "*", "60", "*", "1000", ";", "}", "// Return raw stream using the download API.", "return", "request", ".", "get", "(", "{", "url", ":", "url", ".", "format", "(", "{", "protocol", ":", "'https:'", ",", "host", ":", "'pull.logentries.com'", ",", "pathname", ":", "pathname", ",", "query", ":", "query", "}", ")", ",", "gzip", ":", "true", ",", "timeout", ":", "30000", "// 30 seconds", "}", ")", ";", "}" ]

[ "Query", "and", "stream", "raw", "logs", "from", "Logentries", ".", "This", "is", "not", "returning", "an", "object", "stream", ".", "If", "you", "want", "JSON", "objects", "use", "the", "logentriesJsonStream", "function", "." ]

[ "function", "logentriesJsonStream", "(", "pathname", ",", "query", "=", "{", "}", ")", "{", "query", "=", "Object", ".", "assign", "(", "{", "}", ",", "query", ")", ";", "// Force query format to JSON.", "query", ".", "format", "=", "'json'", ";", "// Parse each array entry from raw stream and emit JSON objects.", "return", "pump", "(", "logentriesRawStream", "(", "pathname", ",", "query", ")", ",", "JSONStream", ".", "parse", "(", "'*'", ")", ")", ";", "}" ]

[ "Query", "and", "stream", "logs", "from", "Logentries", ".", "This", "returns", "a", "readable", "object", "stream", "emitting", "log", "record", "JSON", "objects", "." ]

[ "function", "logentriesConnect", "(", "options", "=", "{", "}", ")", "{", "// Define path to access specific account, log set and log.", "let", "pathname", "=", "'/'", "+", "encodeURIComponent", "(", "options", ".", "account", ")", "+", "'/hosts/'", "+", "encodeURIComponent", "(", "options", ".", "logset", ")", "+", "'/'", "+", "encodeURIComponent", "(", "options", ".", "log", ")", "+", "'/'", ";", "// Bind path argument in query functions.", "let", "json", "=", "logentriesJsonStream", ".", "bind", "(", "null", ",", "pathname", ")", ";", "let", "raw", "=", "logentriesRawStream", ".", "bind", "(", "null", ",", "pathname", ")", ";", "return", "Object", ".", "assign", "(", "json", ",", "{", "json", ":", "json", ",", "raw", ":", "raw", "}", ")", ";", "}" ]

[ "Setup", "connection", "to", "a", "specific", "account", "and", "log", ".", "Returns", "query", "function", "." ]

[ "function", "CacheModule", "(", "settings", ",", "cacheName", ",", "serviceHandler", ",", "serviceCallName", ")", "{", "if", "(", "serviceCallName", "==", "null", ")", "{", "serviceCallName", "=", "\"call\"", ";", "}", "settings", ".", "init", "(", "\"cacheModules\"", ",", "{", "expiration", ":", "{", "\"default\"", ":", "1800000", "}", "}", ")", ";", "this", ".", "settings", "=", "settings", ";", "this", ".", "cache", "=", "{", "data", ":", "{", "}", ",", "mtime", ":", "{", "}", ",", "name", ":", "cacheName", "}", ";", "this", ".", "service", "=", "serviceHandler", ";", "this", ".", "serviceCallName", "=", "serviceCallName", ";", "}" ]

[ "The", "class", "constructor", "." ]

[ "function", "addUser", "(", "db", ",", "username", ",", "password", ",", "options", ",", "callback", ")", "{", "const", "Db", "=", "require", "(", "'../db'", ")", ";", "// Did the user destroy the topology", "if", "(", "db", ".", "serverConfig", "&&", "db", ".", "serverConfig", ".", "isDestroyed", "(", ")", ")", "return", "callback", "(", "new", "MongoError", "(", "'topology was destroyed'", ")", ")", ";", "// Attempt to execute auth command", "executeAuthCreateUserCommand", "(", "db", ",", "username", ",", "password", ",", "options", ",", "(", "err", ",", "r", ")", "=>", "{", "// We need to perform the backward compatible insert operation", "if", "(", "err", "&&", "err", ".", "code", "===", "-", "5000", ")", "{", "const", "finalOptions", "=", "applyWriteConcern", "(", "Object", ".", "assign", "(", "{", "}", ",", "options", ")", ",", "{", "db", "}", ",", "options", ")", ";", "// Use node md5 generator", "const", "md5", "=", "crypto", ".", "createHash", "(", "'md5'", ")", ";", "// Generate keys used for authentication", "md5", ".", "update", "(", "username", "+", "':mongo:'", "+", "password", ")", ";", "const", "userPassword", "=", "md5", ".", "digest", "(", "'hex'", ")", ";", "// If we have another db set", "const", "db", "=", "options", ".", "dbName", "?", "new", "Db", "(", "options", ".", "dbName", ",", "db", ".", "s", ".", "topology", ",", "db", ".", "s", ".", "options", ")", ":", "db", ";", "// Fetch a user collection", "const", "collection", "=", "db", ".", "collection", "(", "CONSTANTS", ".", "SYSTEM_USER_COLLECTION", ")", ";", "// Check if we are inserting the first user", "count", "(", "collection", ",", "{", "}", ",", "finalOptions", ",", "(", "err", ",", "count", ")", "=>", "{", "// We got an error (f.ex not authorized)", "if", "(", "err", "!=", "null", ")", "return", "handleCallback", "(", "callback", ",", "err", ",", "null", ")", ";", "// Check if the user exists and update i", "const", "findOptions", "=", "Object", ".", "assign", "(", "{", "projection", ":", "{", "dbName", ":", "1", "}", "}", ",", "finalOptions", ")", ";", "collection", ".", "find", "(", "{", "user", ":", "username", "}", ",", "findOptions", ")", ".", "toArray", "(", "err", "=>", "{", "// We got an error (f.ex not authorized)", "if", "(", "err", "!=", "null", ")", "return", "handleCallback", "(", "callback", ",", "err", ",", "null", ")", ";", "// Add command keys", "finalOptions", ".", "upsert", "=", "true", ";", "// We have a user, let's update the password or upsert if not", "updateOne", "(", "collection", ",", "{", "user", ":", "username", "}", ",", "{", "$set", ":", "{", "user", ":", "username", ",", "pwd", ":", "userPassword", "}", "}", ",", "finalOptions", ",", "err", "=>", "{", "if", "(", "count", "===", "0", "&&", "err", ")", "return", "handleCallback", "(", "callback", ",", "null", ",", "[", "{", "user", ":", "username", ",", "pwd", ":", "userPassword", "}", "]", ")", ";", "if", "(", "err", ")", "return", "handleCallback", "(", "callback", ",", "err", ",", "null", ")", ";", "handleCallback", "(", "callback", ",", "null", ",", "[", "{", "user", ":", "username", ",", "pwd", ":", "userPassword", "}", "]", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ";", "return", ";", "}", "if", "(", "err", ")", "return", "handleCallback", "(", "callback", ",", "err", ")", ";", "handleCallback", "(", "callback", ",", "err", ",", "r", ")", ";", "}", ")", ";", "}" ]

[ "Add", "a", "user", "to", "the", "database", "." ]

[ "function", "morphic", "(", "options", ")", "{", "var", "optionsIn", "=", "options", "||", "{", "}", ";", "var", "Matcher", "=", "optionsIn", ".", "matcherCore", "||", "defaultMatcher", "var", "matcher", "=", "new", "Matcher", "(", "optionsIn", ")", ";", "var", "generateMatchers", "=", "optionsIn", ".", "generateMatchers", "||", "defaultGenerateMatchers", ";", "var", "generateNamedFieldExtractors", "=", "optionsIn", ".", "generateNamedFieldExtractors", "||", "defaultGenerateNamedFieldExtractors", ";", "var", "extractNamedFields", "=", "optionsIn", ".", "extractNamedFields", "||", "defaultExtractNamedFields", ";", "putRecord", "(", "matcher", ".", "useFallback", ".", "bind", "(", "matcher", ")", ",", "[", "]", ",", "function", "(", ")", "{", "throw", "new", "Error", "(", "\"No methods matched input \"", "+", "util", ".", "inspect", "(", "arguments", ")", ")", ";", "}", ")", ";", "var", "morphicFunction", "=", "function", "morphicFunction", "(", ")", "{", "var", "match", "=", "matcher", ".", "getRecordFromInput", "(", "arguments", ")", ";", "var", "extractedFields", "=", "extractNamedFields", "(", "match", ".", "namedFields", "||", "[", "]", ",", "arguments", ")", ";", "var", "args", "=", "[", "extractedFields", "]", ".", "concat", "(", "Array", ".", "from", "(", "arguments", ")", ")", ";", "var", "action", "=", "match", ".", "action", ";", "return", "action", ".", "apply", "(", "this", ",", "args", ")", ";", "}", ";", "morphicFunction", ".", "with", "=", "function", "(", ")", "{", "var", "generatedMatchers", "=", "generateMatchers", "(", "matchers", ",", "arguments", ")", ";", "var", "namedFields", "=", "generateNamedFieldExtractors", "(", "generatedMatchers", ")", ";", "return", "builder", "(", "putRecord", ".", "bind", "(", "undefined", ",", "matcher", ".", "addRecord", ".", "bind", "(", "matcher", ",", "generatedMatchers", ")", ",", "namedFields", ")", ")", ";", "}", ";", "morphicFunction", ".", "otherwise", "=", "function", "(", ")", "{", "return", "builder", "(", "putRecord", ".", "bind", "(", "undefined", ",", "matcher", ".", "useFallback", ".", "bind", "(", "matcher", ")", ",", "[", "]", ")", ")", ";", "}", ";", "return", "morphicFunction", ";", "}" ]

[ "This", "class", "is", "essentially", "syntactic", "sugar", "around", "the", "core", "matcher", "found", "in", "matcher", ".", "js" ]

[ "function", "LoopChain", "(", "cond", ",", "fns", ")", "{", "if", "(", "fns", "instanceof", "Array", ")", "Chain", ".", "apply", "(", "this", ",", "fns", ")", ";", "else", "Chain", ".", "apply", "(", "this", ",", "slice", ".", "call", "(", "arguments", ",", "1", ")", ")", ";", "this", ".", "cond", "=", "this", ".", "wrap", "(", "cond", ")", ";", "this", ".", "name", "=", "'(anonymous loop chain)'", ";", "}" ]

[ "A", "Loop", "Chain", "will", "iterate", "over", "its", "functions", "until", "the", "condition", "function", "specified", "returns", "false", "standardizing", "and", "simplifying", "the", "implementation", "for", "something", "that", "could", "already", "be", "done", "with", "standard", "serial", "Chains", "." ]

[ "function", "Branch", "(", "cond", ",", "t", ",", "f", ")", "{", "this", ".", "cond", "=", "this", ".", "wrap", "(", "cond", ")", ";", "this", ".", "if_true", "=", "this", ".", "wrap", "(", "t", ")", ";", "this", ".", "if_false", "=", "this", ".", "wrap", "(", "f", ")", ";", "this", ".", "name", "=", "'(Unnamed Branch)'", ";", "}" ]

[ "A", "branch", "is", "used", "to", "simplify", "multipath", "management", "when", "constructing", "Chains", ".", "It", "works", "just", "like", "a", "normal", "Chain", "except", "that", "it", "calls", "the", "asynchronous", "decision", "function", "and", "uses", "it", "to", "select", "between", "the", "A", "and", "B", "alternatives", "which", "are", "most", "useful", "when", "given", "as", "Chains", "." ]

[ "function", "__chain_inner", "(", "result", ")", "{", "var", "args", "=", "slice", ".", "call", "(", "arguments", ",", "1", ")", ";", "nextTick", "(", "function", "(", ")", "{", "try", "{", "if", "(", "result", ")", "{", "var", "params", "=", "that", ".", "handle_args", "(", "env", ",", "that", ".", "if_true", ",", "args", ")", ";", "params", ".", "unshift", "(", "env", ",", "after", ")", ";", "env", ".", "_fm", ".", "$push_call", "(", "helpers", ".", "fname", "(", "that", ".", "if_true", ",", "that", ".", "if_true", ".", "fn", ".", "name", ")", ")", ";", "that", ".", "if_true", ".", "fn", ".", "apply", "(", "null", ",", "params", ")", ";", "}", "else", "{", "var", "params", "=", "that", ".", "handle_args", "(", "env", ",", "that", ".", "if_false", ",", "args", ")", ";", "params", ".", "unshift", "(", "env", ",", "after", ")", ";", "env", ".", "_fm", ".", "$push_call", "(", "helpers", ".", "fname", "(", "that", ".", "if_false", ",", "that", ".", "if_false", ".", "fn", ".", "name", ")", ")", ";", "that", ".", "if_false", ".", "fn", ".", "apply", "(", "null", ",", "params", ")", ";", "}", "}", "catch", "(", "e", ")", "{", "env", ".", "$throw", "(", "e", ")", ";", "}", "}", ")", ";", "}" ]

[ "This", "closure", "handles", "the", "response", "from", "the", "condition", "function" ]

[ "function", "replaceWith", "(", "input", ",", "regex", ",", "content", ")", "{", "// Sanity check", "verifyParameterIsDefined", "(", "input", ",", "'input'", ",", "'replaceWith'", ")", ";", "verifyParameterIsDefined", "(", "regex", ",", "'regex'", ",", "'replaceWith'", ")", ";", "return", "replaceAt", "(", "normalizeValue", "(", "input", ")", ",", "normalizeRegExp", "(", "normalizeValue", "(", "regex", ")", ")", ",", "normalizeValue", "(", "content", ")", ")", ";", "}" ]

[ "Replaces", "content", "specified", "by", "a", "regular", "expression", "with", "specified", "content", "." ]

[ "function", "afterElementOpen", "(", "input", ",", "element", ",", "content", ")", "{", "// Sanity check", "verifyParameterIsDefined", "(", "input", ",", "'input'", ",", "'afterElementOpen'", ")", ";", "verifyParameterIsDefined", "(", "element", ",", "'element'", ",", "'afterElementOpen'", ")", ";", "return", "insertAfter", "(", "normalizeValue", "(", "input", ")", ",", "normalizeRegExp", "(", "`", "${", "normalizeValue", "(", "element", ")", "}", "\\>", "`", ")", ",", "normalizeValue", "(", "content", ")", ")", ";", "}" ]

[ "Inserts", "content", "into", "the", "input", "string", "after", "the", "first", "occurrence", "of", "the", "element", "has", "been", "opened", "." ]

[ "function", "beforeElementClose", "(", "input", ",", "element", ",", "content", ")", "{", "// Sanity check", "verifyParameterIsDefined", "(", "input", ",", "'input'", ",", "beforeElementClose", ".", "name", ")", ";", "verifyParameterIsDefined", "(", "element", ",", "'element'", ",", "beforeElementClose", ".", "name", ")", ";", "return", "insertBefore", "(", "normalizeValue", "(", "input", ")", ",", "normalizeRegExp", "(", "`", "\\/", "${", "normalizeValue", "(", "element", ")", "}", "\\>", "`", ")", ",", "normalizeValue", "(", "content", ")", ")", ";", "}" ]

[ "Inserts", "content", "into", "the", "input", "string", "before", "the", "first", "occurrence", "of", "the", "element", "close", "tag", "." ]

[ "function", "insertComment", "(", "input", ",", "element", ",", "comment", ")", "{", "// Sanity check", "verifyParameterIsDefined", "(", "input", ",", "'input'", ",", "insertComment", ".", "name", ")", ";", "verifyParameterIsDefined", "(", "element", ",", "'element'", ",", "insertComment", ".", "name", ")", ";", "return", "insertAfter", "(", "normalizeValue", "(", "input", ")", ",", "normalizeRegExp", "(", "`", "\\/", "${", "normalizeValue", "(", "element", ")", "}", "\\>", "`", ")", ",", "`", "${", "normalizeValue", "(", "comment", ")", "}", "`", ")", ";", "}" ]

[ "Inserts", "an", "HTML", "comment", "into", "the", "input", "string", "after", "the", "first", "occurrence", "of", "the", "element", "close", "tag", "." ]

[ "function", "insertAttribute", "(", "input", ",", "element", ",", "attributeName", ",", "attributeValue", ")", "{", "// Sanity check", "verifyParameterIsDefined", "(", "input", ",", "'input'", ",", "insertAttribute", ".", "name", ")", ";", "verifyParameterIsDefined", "(", "element", ",", "'element'", ",", "insertAttribute", ".", "name", ")", ";", "verifyParameterIsDefined", "(", "attributeName", ",", "'attributeName'", ",", "insertAttribute", ".", "name", ")", ";", "return", "insertAfter", "(", "normalizeValue", "(", "input", ")", ",", "normalizeRegExp", "(", "`", "${", "normalizeValue", "(", "element", ")", "}", "\\>", "`", ")", ",", "`", "${", "normalizeValue", "(", "attributeName", ")", "}", "${", "normalizeValue", "(", "attributeValue", ")", "}", "`", ")", ";", "}" ]

[ "Inserts", "an", "attribute", "into", "the", "input", "string", "within", "the", "first", "occurrence", "of", "the", "element", "open", "tag", "." ]

[ "function", "(", "keyname", ")", "{", "const", "_", "=", "Struct", ".", "PriProp", "(", "keyname", ")", ";", "if", "(", "_", ".", "__proto__", ")", "{", "_", ".", "__proto__", "=", "Struct", ".", "prototype", ";", "}", "else", "{", "Object", ".", "keys", "(", "Struct", ".", "prototype", ")", ".", "forEach", "(", "function", "(", "p", ")", "{", "Object", ".", "defineProperty", "(", "_", ",", "p", ",", "{", "value", ":", "Struct", ".", "prototype", "[", "p", "]", ",", "writable", ":", "false", "}", ")", ";", "}", ",", "this", ")", ";", "}", "var", "classFunction", ";", "Object", ".", "defineProperties", "(", "_", ",", "{", "requires", ":", "{", "value", ":", "{", "}", ",", "writable", ":", "false", "}", ",", "defaults", ":", "{", "value", ":", "{", "}", ",", "writable", ":", "false", "}", ",", "defaultFuncs", ":", "{", "value", ":", "{", "}", ",", "writable", ":", "false", "}", ",", "views", ":", "{", "value", ":", "{", "}", ",", "writable", ":", "false", "}", ",", "parentProps", ":", "{", "value", ":", "[", "]", ",", "writable", ":", "false", "}", ",", "enumerableDescs", ":", "{", "value", ":", "{", "}", ",", "writable", ":", "false", "}", ",", "classFunction", ":", "{", "get", ":", "function", "(", ")", "{", "return", "classFunction", ";", "}", ",", "set", ":", "function", "(", "v", ")", "{", "if", "(", "classFunction", "===", "undefined", ")", "{", "classFunction", "=", "v", ";", "}", "else", "if", "(", "classFunction", "!==", "v", ")", "{", "throw", "new", "Error", "(", "'cannot change classFunction.'", ")", ";", "}", "}", "}", ",", "Modifiers", ":", "{", "value", ":", "Struct", ".", "Modifiers", ",", "writable", ":", "false", "}", "}", ")", ";", "return", "_", ";", "}" ]

[ "Struct", ".", "js", "v0", ".", "0", ".", "1" ]

[ "function", "Model", "(", "collectionName", ",", "attributes", ",", "values", ")", "{", "this", ".", "collectionName", "=", "collectionName", ";", "this", ".", "idAttribute", "=", "Model", ".", "getId", "(", "attributes", ")", ";", "this", ".", "attributes", "=", "attributeValidator", ".", "validate", "(", "attributes", ")", ";", "this", ".", "values", "=", "{", "}", ";", "this", ".", "virtuals", "=", "{", "}", ";", "// initially add the null value from all attributes", "for", "(", "var", "key", "in", "this", ".", "attributes", ")", "{", "this", ".", "values", "[", "key", "]", "=", "undefined", ";", "}", "// prevents from modifying values and adding properties", "Object", ".", "freeze", "(", "this", ".", "attributes", ")", ";", "// prevents from adding new properties", "Object", ".", "seal", "(", "this", ".", "values", ")", ";", "// sets the initial values", "this", ".", "set", "(", "values", ")", ";", "}" ]

[ "An", "entity", "is", "a", "lightweight", "persistence", "domain", "object", "." ]

[ "function", "drop", "(", "n", ",", "array", ")", "{", "return", "(", "n", "<", "array", ".", "length", ")", "?", "slice", "(", "n", ",", "array", ".", "length", ",", "array", ")", ":", "[", "]", "}" ]

[ "Slice", "n", "items", "from", "array", "returning", "the", "sliced", "elements", "as", "a", "new", "array", "." ]

[ "function", "_getRequiredAdCountForAdUnit", "(", "adUnit", ")", "{", "var", "adContainers", "=", "page", ".", "getAdContainers", "(", "adUnit", ")", ";", "if", "(", "!", "adContainers", ".", "length", ")", "{", "return", "0", ";", "}", "var", "numberOfAdsToInsert", "=", "0", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "adContainers", ".", "length", ";", "i", "++", ")", "{", "var", "adContainer", "=", "adContainers", "[", "i", "]", ";", "numberOfAdsToInsert", "+=", "adContainer", ".", "getNumberOfAdsToInsert", "(", ")", ";", "}", "return", "numberOfAdsToInsert", ";", "}" ]

[ "Get", "the", "number", "of", "ads", "this", "unit", "needs", "to", "place", "all", "the", "ads", "on", "the", "page" ]

[ "function", "_buildImageFields", "(", "data", ")", "{", "var", "newUnits", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ",", "len", "=", "data", ".", "length", ";", "i", "<", "len", ";", "i", "++", ")", "{", "adUnit", "=", "data", "[", "i", "]", ";", "// todo: create adUnit object to encapsulate this logic", "if", "(", "'images'", "in", "adUnit", ")", "{", "if", "(", "'banner'", "in", "adUnit", ".", "images", ")", "{", "adUnit", ".", "campaign_banner_url", "=", "adUnit", ".", "images", ".", "banner", ".", "url", ";", "}", "if", "(", "'icon'", "in", "adUnit", ".", "images", ")", "{", "adUnit", ".", "campaign_icon_url", "=", "adUnit", ".", "images", ".", "icon", ".", "url", ";", "}", "if", "(", "'hq_icon'", "in", "adUnit", ".", "images", ")", "{", "adUnit", ".", "campaign_hq_icon_url", "=", "adUnit", ".", "images", ".", "hq_icon", ".", "url", ";", "}", "}", "newUnits", ".", "push", "(", "adUnit", ")", ";", "}", "return", "newUnits", ";", "}" ]

[ "Fills", "some", "image", "fields", "with", "JSON", "data" ]

[ "function", "requestAds", "(", "adUnit", ",", "callback", ")", "{", "var", "limit", "=", "_getRequiredAdCountForAdUnit", "(", "adUnit", ")", ";", "var", "token", "=", "page", ".", "getToken", "(", ")", ";", "var", "imageType", "=", "adUnit", ".", "imageType", ";", "if", "(", "typeof", "imageType", "==", "'undefined'", ")", "{", "imageType", "=", "\"hq_icon\"", ";", "}", "var", "requestQuery", "=", "{", "\"output\"", ":", "\"json\"", ",", "\"placement_key\"", ":", "adUnit", ".", "placementKey", ",", "\"limit\"", ":", "limit", ",", "\"token\"", ":", "token", ",", "\"auto_device\"", ":", "1", ",", "\"image_type\"", ":", "imageType", "}", ";", "//noinspection JSUnresolvedVariable", "var", "overrides", "=", "appSettings", ".", "overrides", ";", "if", "(", "overrides", "&&", "overrides", ".", "formFactor", "&&", "overrides", ".", "platform", "&&", "overrides", ".", "fullDeviceName", "&&", "overrides", ".", "version", ")", "{", "delete", "requestQuery", ".", "auto_device", ";", "requestQuery", ".", "os", "=", "overrides", ".", "platform", ";", "requestQuery", ".", "model", "=", "overrides", ".", "fullDeviceName", ";", "requestQuery", ".", "version", "=", "overrides", ".", "version", ";", "}", "ajax", ".", "get", "(", "{", "url", ":", "appSettings", ".", "adApiBaseUrl", ",", "query", ":", "requestQuery", ",", "success", ":", "function", "(", "data", ")", "{", "if", "(", "data", ".", "length", "!==", "limit", ")", "{", "logger", ".", "warn", "(", "\"Tried to fetch \"", "+", "limit", "+", "\" ads, but received \"", "+", "data", ".", "length", ")", ";", "}", "data", "=", "_buildImageFields", "(", "data", ")", ";", "callback", "(", "data", ")", ";", "}", ",", "error", ":", "function", "(", "e", ")", "{", "logger", ".", "wtf", "(", "'An error occurred trying to fetch ads'", ")", ";", "}", "}", ")", ";", "}" ]

[ "Request", "ads", "from", "the", "offerEngine" ]

[ "function", "clean", "(", "method", ")", "{", "for", "(", "let", "m", "of", "methods", ")", "{", "if", "(", "new", "RegExp", "(", "m", ",", "'i'", ")", ".", "test", "(", "method", ")", ")", "{", "return", "m", ";", "}", "}", "throw", "new", "Error", "(", "`", "${", "method", "}", "`", ")", ";", "}" ]

[ "Returns", "a", "clean", "lower", "-", "case", "method", "name", "." ]

[ "function", "middleware", "(", "req", ",", "res", ",", "next", ")", "{", "req", ".", "security", ".", "csrf", ".", "exclude", "=", "true", ";", "next", "(", ")", ";", "}" ]

[ "Default", "exclusion", "middleware", "." ]

[ "function", "onEachExcludedRoute", "(", "app", ",", "route", ")", "{", "const", "normalized", "=", "normalize", "(", "route", ")", ";", "debug", "(", "`", "${", "(", "normalized", ".", "method", "||", "'all'", ")", ".", "toUpperCase", "(", ")", "}", "${", "normalized", ".", "path", "}", "`", ")", ";", "const", "router", "=", "app", ".", "route", "(", "normalized", ".", "path", ")", ";", "if", "(", "is", ".", "array", "(", "normalized", ".", "method", ")", "&&", "normalized", ".", "method", ".", "length", ")", "{", "for", "(", "let", "i", "=", "0", ",", "l", "=", "normalized", ".", "method", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "exclude", "(", "router", ",", "normalized", ".", "method", "[", "i", "]", ")", ";", "}", "}", "if", "(", "is", ".", "string", "(", "normalized", ".", "method", ")", ")", "{", "exclude", "(", "router", ",", "normalized", ".", "method", ")", ";", "return", ";", "}", "/* Defaults to all */", "exclude", "(", "router", ",", "'all'", ")", ";", "}" ]

[ "Processes", "each", "excluded", "route", "." ]

[ "function", "block", "(", "w", ",", "h", ",", "d", ")", "{", "return", "function", "(", "cons", ",", "nil", ")", "{", "for", "(", "var", "z", "=", "-", "d", ";", "z", "<=", "d", ";", "++", "z", ")", "for", "(", "var", "y", "=", "-", "h", ";", "y", "<=", "h", ";", "++", "y", ")", "for", "(", "var", "x", "=", "-", "w", ";", "x", "<=", "w", ";", "++", "x", ")", "nil", "=", "cons", "(", "x", ",", "y", ",", "z", ")", ",", "nil", "=", "cons", "(", "x", ",", "y", ",", "z", ")", ";", "return", "nil", ";", "}", ";", "}" ]

[ "Number", "Number", "Number", "-", ">", "AtomsCList" ]

[ "function", "sphereVoxels", "(", "cx", ",", "cy", ",", "cz", ",", "r", ",", "col", ")", "{", "return", "function", "(", "cons", ",", "nil", ")", "{", "sphere", "(", "cx", ",", "cy", ",", "cz", ",", "r", ")", "(", "function", "(", "x", ",", "y", ",", "z", ",", "res", ")", "{", "return", "cons", "(", "x", ",", "y", ",", "z", ",", "col", ",", "res", ")", ";", "}", ",", "nil", ")", ";", "}", ";", "}" ]

[ "Number", "Number", "Number", "Number", "RGBA8", "-", ">", "Voxels" ]

[ "function", "dumpFiles", "(", "title", ",", "fn", ")", "{", "var", "matches", "=", "fn", "(", ")", ";", "if", "(", "matches", ".", "length", ")", "{", "log", ".", "info", "(", "\"\"", ")", ";", "log", ".", "info", "(", "(", "title", "+", "\":\"", ")", "[", "'green'", "]", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "matches", ".", "length", ";", "i", "++", ")", "{", "if", "(", "matches", "[", "i", "]", ".", "src", "===", "matches", "[", "i", "]", ".", "dst", ")", "{", "log", ".", "info", "(", "matches", "[", "i", "]", ".", "dst", ")", ";", "}", "else", "{", "log", ".", "info", "(", "matches", "[", "i", "]", ".", "dst", "+", "' (from '", "+", "matches", "[", "i", "]", ".", "src", "+", "')'", ")", ";", "}", "}", "}", "}" ]

[ "List", "files", "returned", "by", "the", "given", "listing", "function", "on", "screen", "." ]

[ "function", "FileSystemLoader", "(", "dir", ",", "options", ")", "{", "this", ".", "dir", "=", "dir", ".", "replace", "(", "/", "\\/$", "/", ",", "''", ")", ";", "this", ".", "options", "=", "options", "||", "(", "options", "=", "{", "}", ")", ";", "this", ".", "posts", "=", "[", "]", ";", "this", ".", "files", "=", "{", "}", ";", "this", ".", "ignore", "=", "{", "}", ";", "var", "self", "=", "this", ";", "(", "options", ".", "ignore", "||", "FileSystemLoader", ".", "ignore", ")", ".", "forEach", "(", "function", "(", "file", ")", "{", "self", ".", "ignore", "[", "file", "]", "=", "true", ";", "}", ")", ";", "process", ".", "nextTick", "(", "function", "(", ")", "{", "self", ".", "loadPosts", "(", ")", ";", "}", ")", ";", "}" ]

[ "Create", "a", "new", "file", "system", "loader", "." ]

[ "function", "Endpoint", "(", ")", "{", "var", "self", "=", "this", ";", "const", "subscriptions", "=", "{", "}", ";", "const", "ps", "=", "new", "Pubsub", "(", ")", ";", "this", ".", "_publish", "=", "ps", ".", "publish", ";", "this", ".", "_subscribe", "=", "ps", ".", "subscribe", ";", "this", ".", "active", "=", "false", ";", "this", ".", "connections", "=", "[", "]", ";", "/**\n * Publishes a new connection.\n * @function _newConnection\n * @private\n * @param {string} sID socket ID\n * @returns this\n */", "this", ".", "_newConnection", "=", "sId", "=>", "{", "self", ".", "connections", ".", "push", "(", "sId", "||", "'unknown'", ")", ";", "self", ".", "active", "=", "true", ";", "self", ".", "_publish", "(", "'change'", ",", "{", "count", ":", "self", ".", "connections", ".", "length", "}", ")", ";", "return", "this", ";", "}", ";", "/**\n * Records a lost connection.\n * @function _lostConnection\n * @private\n * @param {string} sID socket ID\n * @returns this\n */", "this", ".", "_lostConnection", "=", "sId", "=>", "{", "const", "index", "=", "this", ".", "connections", ".", "indexOf", "(", "sId", ")", ";", "this", ".", "connections", ".", "splice", "(", "index", ",", "1", ")", ";", "if", "(", "this", ".", "connections", ".", "length", "===", "0", ")", "{", "this", ".", "active", "=", "false", ";", "}", "self", ".", "_publish", "(", "'change'", ",", "{", "count", ":", "self", ".", "connections", ".", "length", "}", ")", ";", "return", "this", ";", "}", ";", "/**\n * Subscribe an action to perform when a message is received.\n * @function onmessage\n * @param {string} type\n * @param {messageResponse}\n * @param {boolean} [historical=false] Whether or not to call the listener if this message has been received before this listener was set.\n * @returns {subscription}\n */", "this", ".", "onmessage", "=", "(", "type", ",", "cb", ",", "historical", "=", "false", ")", "=>", "{", "return", "self", ".", "_subscribe", "(", "type", ",", "cb", ",", "historical", ")", ";", "}", ";", "/**\n * Subscribe an action to perform when the connection changes.\n * @function onchange\n * @param {changeCallback}\n * @returns {subscription}\n */", "this", ".", "onchange", "=", "cb", "=>", "{", "return", "self", ".", "_subscribe", "(", "'change'", ",", "cb", ")", ";", "}", ";", "/**\n * Remove all subscriptions to connection events.\n * @function clear\n */", "this", ".", "clear", "=", "ps", ".", "clear", ";", "}" ]

[ "Message", "response", "callback", "." ]

[ "function", "find", "(", "queue", ",", "name", ")", "{", "const", "out", "=", "queue", ".", "findIndex", "(", "e", "=>", "e", ".", "name", "===", "name", ")", ";", "if", "(", "out", "===", "-", "1", ")", "{", "throw", "new", "Error", "(", "`", "${", "name", "}", "`", ")", ";", "}", "return", "out", ";", "}" ]

[ "Find", "the", "index", "of", "a", "function", "." ]

[ "function", "insert", "(", "queue", ",", "index", ",", "fns", ",", "mode", "=", "InsertMode", ".", "REGULAR", ")", "{", "fns", ".", "forEach", "(", "(", "{", "fn", ",", "name", "}", ")", "=>", "{", "if", "(", "queue", ".", "findIndex", "(", "e", "=>", "e", ".", "name", "===", "name", ")", "!==", "-", "1", ")", "{", "throw", "new", "Error", "(", "`", "${", "name", "}", "`", ")", ";", "}", "else", "if", "(", "typeof", "fn", "!==", "'function'", ")", "{", "throw", "new", "Error", "(", "`", "${", "name", "}", "`", ")", ";", "}", "}", ")", ";", "const", "deleteCount", "=", "mode", "===", "InsertMode", ".", "REPLACE", "?", "1", ":", "0", ";", "queue", ".", "splice", "(", "index", ",", "deleteCount", ",", "...", "fns", ")", ";", "}" ]

[ "Insert", "a", "bunch", "of", "functions", "into", "a", "queue", "at", "a", "given", "index", "." ]

[ "function", "addElement", "(", "element", ",", "target", ",", "moveCurrent", ")", "{", "target", "=", "target", "||", "currentNode", "||", "root", ";", "// Current element might be mangled by fix body below,", "// save it for restore later.", "var", "savedCurrent", "=", "currentNode", ";", "// Ignore any element that has already been added.", "if", "(", "element", ".", "previous", "===", "undefined", ")", "{", "if", "(", "checkAutoParagraphing", "(", "target", ",", "element", ")", ")", "{", "// Create a <p> in the fragment.", "currentNode", "=", "target", ";", "parser", ".", "onTagOpen", "(", "fixingBlock", ",", "{", "}", ")", ";", "// The new target now is the <p>.", "element", ".", "returnPoint", "=", "target", "=", "currentNode", ";", "}", "removeTailWhitespace", "(", "element", ")", ";", "// Avoid adding empty inline.", "if", "(", "!", "(", "isRemoveEmpty", "(", "element", ")", "&&", "!", "element", ".", "children", ".", "length", ")", ")", "target", ".", "add", "(", "element", ")", ";", "if", "(", "element", ".", "name", "==", "'pre'", ")", "inPre", "=", "false", ";", "if", "(", "element", ".", "name", "==", "'textarea'", ")", "inTextarea", "=", "false", ";", "}", "if", "(", "element", ".", "returnPoint", ")", "{", "currentNode", "=", "element", ".", "returnPoint", ";", "delete", "element", ".", "returnPoint", ";", "}", "else", "{", "currentNode", "=", "moveCurrent", "?", "target", ":", "savedCurrent", ";", "}", "}" ]

[ "Beside", "of", "simply", "append", "specified", "element", "to", "target", "this", "function", "also", "takes", "care", "of", "other", "dirty", "lifts", "like", "forcing", "block", "in", "body", "trimming", "spaces", "at", "the", "block", "boundaries", "etc", "." ]

[ "function", "checkAutoParagraphing", "(", "parent", ",", "node", ")", "{", "// Check for parent that can contain block.", "if", "(", "(", "parent", "==", "root", "||", "parent", ".", "name", "==", "'body'", ")", "&&", "fixingBlock", "&&", "(", "!", "parent", ".", "name", "||", "CKEDITOR", ".", "dtd", "[", "parent", ".", "name", "]", "[", "fixingBlock", "]", ")", ")", "{", "var", "name", ",", "realName", ";", "if", "(", "node", ".", "attributes", "&&", "(", "realName", "=", "node", ".", "attributes", "[", "'data-cke-real-element-type'", "]", ")", ")", "name", "=", "realName", ";", "else", "name", "=", "node", ".", "name", ";", "// Text node, inline elements are subjected, except for <script>/<style>.", "return", "name", "&&", "name", "in", "CKEDITOR", ".", "dtd", ".", "$inline", "&&", "!", "(", "name", "in", "CKEDITOR", ".", "dtd", ".", "head", ")", "&&", "!", "node", ".", "isOrphan", "||", "node", ".", "type", "==", "CKEDITOR", ".", "NODE_TEXT", ";", "}", "}" ]

[ "Auto", "paragraphing", "should", "happen", "when", "inline", "content", "enters", "the", "root", "element", "." ]

[ "function", "possiblySibling", "(", "tag1", ",", "tag2", ")", "{", "if", "(", "tag1", "in", "CKEDITOR", ".", "dtd", ".", "$listItem", "||", "tag1", "in", "CKEDITOR", ".", "dtd", ".", "$tableContent", ")", "return", "tag1", "==", "tag2", "||", "tag1", "==", "'dt'", "&&", "tag2", "==", "'dd'", "||", "tag1", "==", "'dd'", "&&", "tag2", "==", "'dt'", ";", "return", "false", ";", "}" ]

[ "Judge", "whether", "two", "element", "tag", "names", "are", "likely", "the", "siblings", "from", "the", "same", "structural", "element", "." ]

[ "function", "(", "filter", ",", "context", ")", "{", "context", "=", "this", ".", "getFilterContext", "(", "context", ")", ";", "// Apply the root filter.", "filter", ".", "onRoot", "(", "context", ",", "this", ")", ";", "this", ".", "filterChildren", "(", "filter", ",", "false", ",", "context", ")", ";", "}" ]

[ "Filter", "this", "fragment", "s", "content", "with", "given", "filter", "." ]

[ "function", "(", "filter", ",", "filterRoot", ",", "context", ")", "{", "// If this element's children were already filtered", "// by current filter, don't filter them 2nd time.", "// This situation may occur when filtering bottom-up", "// (filterChildren() called manually in element's filter),", "// or in unpredictable edge cases when filter", "// is manipulating DOM structure.", "if", "(", "this", ".", "childrenFilteredBy", "==", "filter", ".", "id", ")", "return", ";", "context", "=", "this", ".", "getFilterContext", "(", "context", ")", ";", "// Filtering root if enforced.", "if", "(", "filterRoot", "&&", "!", "this", ".", "parent", ")", "filter", ".", "onRoot", "(", "context", ",", "this", ")", ";", "this", ".", "childrenFilteredBy", "=", "filter", ".", "id", ";", "// Don't cache anything, children array may be modified by filter rule.", "for", "(", "var", "i", "=", "0", ";", "i", "<", "this", ".", "children", ".", "length", ";", "i", "++", ")", "{", "// Stay in place if filter returned false, what means", "// that node has been removed.", "if", "(", "this", ".", "children", "[", "i", "]", ".", "filter", "(", "filter", ",", "context", ")", "===", "false", ")", "i", "--", ";", "}", "}" ]

[ "Filter", "this", "fragment", "s", "children", "with", "given", "filter", "." ]

[ "function", "(", "writer", ",", "filter", ",", "filterRoot", ")", "{", "var", "context", "=", "this", ".", "getFilterContext", "(", ")", ";", "// Filtering root if enforced.", "if", "(", "filterRoot", "&&", "!", "this", ".", "parent", "&&", "filter", ")", "filter", ".", "onRoot", "(", "context", ",", "this", ")", ";", "if", "(", "filter", ")", "this", ".", "filterChildren", "(", "filter", ",", "false", ",", "context", ")", ";", "for", "(", "var", "i", "=", "0", ",", "children", "=", "this", ".", "children", ",", "l", "=", "children", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "children", "[", "i", "]", ".", "writeHtml", "(", "writer", ")", ";", "}" ]

[ "Write", "and", "filtering", "the", "child", "nodes", "of", "this", "fragment", "." ]

[ "function", "mr", "(", "bundler", ")", "{", "var", "prevError", "=", "null", "var", "pending", "=", "null", "var", "buffer", "=", "null", "build", "(", ")", "// bundler.on('update', update)", "return", "handler", "/**\n * Build the CSS and pass it to `buffer`.\n *\n * @api private\n */", "function", "build", "(", ")", "{", "const", "p", "=", "pending", "=", "new", "Emitter", "(", ")", "buffer", "=", "bundler", ".", "toString", "(", ")", "if", "(", "p", "!==", "pending", ")", "return", "pending", ".", "emit", "(", "'ready'", ",", "null", ",", "pending", "=", "false", ")", "}", "/**\n * Response middleware. Sends `buffer` to\n * either `next()` or `res.body()`.\n *\n * @param {Request} req\n * @param {Response} res\n * @param {Function} next\n * @api private\n */", "function", "handler", "(", "req", ",", "res", ",", "next", ")", "{", "next", "=", "next", "||", "send", "if", "(", "pending", ")", "return", "pending", ".", "once", "(", "'ready'", ",", "function", "(", "err", ")", "{", "if", "(", "err", ")", "return", "next", "(", "err", ")", "return", "handler", "(", "req", ",", "res", ",", "next", ")", "}", ")", "if", "(", "prevError", ")", "return", "next", "(", "prevError", ")", "res", ".", "setHeader", "(", "'content-type'", ",", "'text/css'", ")", "return", "next", "(", "null", ",", "buffer", ")", "function", "send", "(", "err", ",", "body", ")", "{", "if", "(", "err", ")", "return", "res", ".", "emit", "(", "err", ")", "res", ".", "end", "(", "body", ")", "}", "}", "}" ]

[ "Respond", "myth", "in", "an", "http", "request", "." ]

[ "function", "build", "(", ")", "{", "const", "p", "=", "pending", "=", "new", "Emitter", "(", ")", "buffer", "=", "bundler", ".", "toString", "(", ")", "if", "(", "p", "!==", "pending", ")", "return", "pending", ".", "emit", "(", "'ready'", ",", "null", ",", "pending", "=", "false", ")", "}" ]

[ "Build", "the", "CSS", "and", "pass", "it", "to", "buffer", "." ]

[ "function", "deletePropertyAt", "(", "object", ",", "prop", ")", "{", "if", "(", "object", "==", "null", ")", "{", "return", "object", ";", "}", "var", "value", "=", "object", "[", "prop", "]", ";", "delete", "object", "[", "prop", "]", ";", "return", "value", ";", "}" ]

[ "Removes", "a", "property", "from", "an", "object", ";", "if", "no", "more", "references", "to", "the", "same", "property", "are", "held", "it", "is", "eventually", "released", "automatically", "." ]

[ "function", "DotCfg", "(", "namespace", ",", "scope", ",", "strategy", ")", "{", "if", "(", "instanceOf", "(", "DotCfg", ",", "this", ")", ")", "{", "if", "(", "exotic", "(", "namespace", ")", ")", "{", "strategy", "=", "scope", ";", "scope", "=", "namespace", ";", "namespace", "=", "undefined", ";", "}", "if", "(", "primitive", "(", "scope", ")", ")", "{", "scope", "=", "env", ";", "}", "if", "(", "string", "(", "namespace", ")", ")", "{", "scope", "[", "namespace", "]", "=", "scope", "[", "namespace", "]", "||", "{", "}", ";", "scope", "=", "scope", "[", "namespace", "]", ";", "}", "this", ".", "strategy", "=", "as", "(", "Function", ",", "strategy", ",", "dotDefault", ")", ";", "this", ".", "scope", "=", "normalize", "(", "scope", ",", "this", ".", "strategy", ",", "false", ")", ";", "this", ".", "extends", "=", "proxy", "(", "assign", "(", "this", ".", "strategy", ")", ",", "this", ",", "this", ".", "scope", ")", ";", "this", ".", "namespace", "=", "as", "(", "String", ",", "namespace", ",", "(", "\"dot\"", "+", "(", "guid", "+=", "1", ")", ")", ")", ";", "return", "this", ";", "}", "return", "new", "DotCfg", "(", "namespace", ",", "scope", ",", "strategy", ")", ";", "}" ]

[ "Create", "a", "instance", "of", "DotCfg", "." ]

[ "function", "set", "(", "notation", ",", "value", ",", "strategy", ")", "{", "var", "this$1", "=", "this", ";", "var", "fn", "=", "!", "undef", "(", "value", ")", "&&", "callable", "(", "strategy", ")", "?", "strategy", ":", "this", ".", "strategy", ";", "if", "(", "object", "(", "notation", ")", ")", "{", "var", "context", ";", "for", "(", "var", "key", "in", "notation", ")", "{", "if", "(", "ownProperty", "(", "notation", ",", "key", ")", ")", "{", "context", "=", "write", "(", "this$1", ".", "scope", ",", "key", ",", "notation", "[", "key", "]", ",", "fn", ")", ";", "}", "}", "return", "context", ";", "}", "write", "(", "this", ".", "scope", ",", "notation", ",", "value", ",", "fn", ")", ";", "return", "this", ";", "}" ]

[ "Write", "in", "scope", "." ]

[ "function", "get", "(", "notation", ",", "defaultValue", ")", "{", "var", "value", "=", "read", "(", "this", ".", "scope", ",", "notation", ")", ";", "return", "undef", "(", "value", ")", "?", "defaultValue", ":", "value", ";", "}" ]

[ "Read", "scope", "notation", "." ]

[ "function", "makeArrayOpt", "(", "opts", ",", "name", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "opts", "[", "name", "]", ")", ")", "{", "opts", "[", "name", "]", "=", "[", "opts", "[", "name", "]", "]", ";", "}", "return", "opts", "[", "name", "]", ";", "}" ]

[ "Convert", "opts", ".", "name", "to", "an", "array", "if", "not", "already", "." ]

[ "function", "rethrow", "(", "options", ")", "{", "var", "opts", "=", "lazy", ".", "extend", "(", "{", "before", ":", "3", ",", "after", ":", "3", "}", ",", "options", ")", ";", "return", "function", "(", "err", ",", "filename", ",", "lineno", ",", "str", ",", "expr", ")", "{", "if", "(", "!", "(", "err", "instanceof", "Error", ")", ")", "throw", "err", ";", "lineno", "=", "lineno", ">>", "0", ";", "var", "lines", "=", "str", ".", "split", "(", "'\\n'", ")", ";", "var", "before", "=", "Math", ".", "max", "(", "lineno", "-", "(", "+", "opts", ".", "before", ")", ",", "0", ")", ";", "var", "after", "=", "Math", ".", "min", "(", "lines", ".", "length", ",", "lineno", "+", "(", "+", "opts", ".", "after", ")", ")", ";", "// align line numbers", "var", "n", "=", "lazy", ".", "align", "(", "count", "(", "lines", ".", "length", "+", "1", ")", ")", ";", "lineno", "++", ";", "var", "pointer", "=", "errorMessage", "(", "err", ",", "opts", ")", ";", "// Error context", "var", "context", "=", "lines", ".", "slice", "(", "before", ",", "after", ")", ".", "map", "(", "function", "(", "line", ",", "i", ")", "{", "var", "num", "=", "i", "+", "before", "+", "1", ";", "var", "msg", "=", "style", "(", "num", ",", "lineno", ")", ";", "return", "msg", "(", "' > '", ",", "' '", ")", "+", "n", "[", "num", "]", "+", "'| '", "+", "line", "+", "' '", "+", "msg", "(", "expr", ",", "''", ")", ";", "}", ")", ".", "join", "(", "'\\n'", ")", ";", "// Alter exception message", "err", ".", "path", "=", "filename", ";", "err", ".", "message", "=", "(", "filename", "||", "'source'", ")", "+", "':'", "+", "lineno", "+", "'\\n'", "+", "context", "+", "'\\n\\n'", "+", "(", "pointer", "?", "(", "pointer", "+", "lazy", ".", "yellow", "(", "filename", ")", ")", ":", "styleMessage", "(", "err", ".", "message", ",", "opts", ")", ")", "+", "'\\n'", ";", "throw", "err", ".", "message", ";", "}", ";", "}" ]

[ "Re", "-", "throw", "the", "given", "err", "in", "context", "to", "the", "offending", "template", "expression", "in", "filename", "at", "the", "given", "lineno", "." ]

[ "function", "processRelativePath", "(", "cssPath", ",", "importCssPath", ",", "importCssText", ")", "{", "cssPath", "=", "cssPath", ".", "split", "(", "'\\\\'", ")", ";", "importCssPath", "=", "importCssPath", ".", "split", "(", "'/'", ")", ";", "var", "isSibling", "=", "importCssPath", ".", "length", "==", "1", ";", "return", "importCssText", ".", "replace", "(", "reg", ",", "function", "(", "css", ",", "before", ",", "imgPath", ",", "after", ")", "{", "if", "(", "/", "^http\\S", "/", ".", "test", "(", "imgPath", ")", "||", "/", "^\\/\\S", "/", ".", "test", "(", "imgPath", ")", "||", "isSibling", ")", "{", "//绝对路径or同级跳过", "return", "css", ";", "}", "imgPath", "=", "imgPath", ".", "split", "(", "'/'", ")", ";", "imgPath", "=", "getRelativePath", "(", "cssPath", ",", "importCssPath", ",", "imgPath", ")", ";", "return", "before", "+", "imgPath", "+", "after", ";", "}", ")", ";", "}" ]

[ "process", "relative", "image", "pathes", "in", "specified", "imported", "css" ]

[ "function", "getRelativePath", "(", "cssPath", ",", "importCssPath", ",", "imgPath", ")", "{", "var", "count1", "=", "0", ",", "count2", "=", "0", ",", "result", "=", "''", ";", "importCssPath", "=", "getFilePath", "(", "cssPath", ",", "importCssPath", ")", ";", "imgPath", "=", "getFilePath", "(", "importCssPath", ",", "imgPath", ")", ";", "for", "(", "var", "i", "=", "0", ",", "length", "=", "cssPath", ".", "length", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "cssPath", "[", "i", "]", "==", "imgPath", "[", "i", "]", ")", "{", "count1", "++", ";", "}", "else", "{", "break", ";", "}", "}", "count2", "=", "cssPath", ".", "length", "-", "count1", "-", "1", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "count2", ";", "i", "++", ")", "{", "result", "+=", "'../'", ";", "}", "result", "=", "result", "+", "imgPath", ".", "splice", "(", "count1", ")", ".", "join", "(", "'/'", ")", ";", "return", "result", ";", "}" ]

[ "get", "images", "relative", "path", "after", "css", "merging" ]

[ "function", "getFilePath", "(", "basePath", ",", "relativePath", ")", "{", "var", "count", "=", "0", ",", "array1", ",", "array2", ";", "for", "(", "var", "i", "=", "0", ",", "length", "=", "relativePath", ".", "length", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "relativePath", "[", "i", "]", "==", "'..'", ")", "{", "count", "++", ";", "}", "}", "array1", "=", "basePath", ".", "slice", "(", "0", ",", "basePath", ".", "length", "-", "1", "-", "count", ")", ";", "array2", "=", "relativePath", ".", "slice", "(", "count", ")", ";", "return", "array1", ".", "concat", "(", "array2", ")", ";", "}" ]

[ "get", "relative", "file", "path", "basing", "on", "its", "containing", "file", "path", "and", "its", "relative", "path" ]

[ "function", "copy", "(", "obj", ",", "map", ")", "{", "if", "(", "map", ".", "has", "(", "obj", ")", ")", "{", "return", "map", ".", "get", "(", "obj", ")", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "obj", ")", ")", "{", "const", "result", "=", "[", "]", ";", "map", ".", "set", "(", "obj", ",", "result", ")", ";", "obj", ".", "forEach", "(", "item", "=>", "{", "result", ".", "push", "(", "copy", "(", "item", ",", "map", ")", ")", ";", "}", ")", ";", "return", "result", ";", "}", "else", "if", "(", "typeof", "obj", "===", "'object'", "&&", "obj", ")", "{", "const", "result", "=", "{", "}", ";", "map", ".", "set", "(", "obj", ",", "result", ")", ";", "Object", ".", "keys", "(", "obj", ")", ".", "forEach", "(", "key", "=>", "{", "result", "[", "key", "]", "=", "copy", "(", "obj", "[", "key", "]", ",", "map", ")", ";", "}", ")", ";", "return", "result", ";", "}", "else", "{", "return", "obj", ";", "}", "}" ]

[ "Perform", "a", "deep", "copy", "of", "a", "value", "." ]

[ "function", "parseSearchResults", "(", "err", ",", "body", ")", "{", "if", "(", "err", ")", "{", "return", "tubesio", ".", "finish", "(", "err", ")", ";", "}", "var", "result", "=", "[", "]", ";", "jsdom", ".", "env", "(", "{", "html", ":", "body", ",", "scripts", ":", "[", "'http://code.jquery.com/jquery-1.5.min.js'", "]", "}", ",", "function", "(", "err", ",", "window", ")", "{", "if", "(", "err", ")", "{", "return", "tubesio", ".", "finish", "(", "err", ")", ";", "}", "var", "$", "=", "window", ".", "jQuery", ";", "$", "(", "'table.track-grid-top-100 tr'", ")", ".", "each", "(", "function", "(", "i", ")", "{", "if", "(", "i", "===", "0", ")", "{", "return", ";", "}", "// Skip header row", "var", "$row", "=", "$", "(", "this", ")", ";", "result", ".", "push", "(", "{", "position", ":", "parseInt", "(", "$row", ".", "find", "(", "'td:nth-child(1)'", ")", ".", "text", "(", ")", ")", ",", "trackName", ":", "$row", ".", "find", "(", "'td:nth-child(4) > a'", ")", ".", "text", "(", ")", ",", "artists", ":", "$row", ".", "find", "(", "'td:nth-child(5) > a'", ")", ".", "text", "(", ")", ",", "remixers", ":", "$row", ".", "find", "(", "'td:nth-child(6) > a'", ")", ".", "text", "(", ")", ",", "label", ":", "$row", ".", "find", "(", "'td:nth-child(7) > a'", ")", ".", "text", "(", ")", ",", "genre", ":", "$row", ".", "find", "(", "'td:nth-child(8) > a'", ")", ".", "text", "(", ")", ",", "releaseDate", ":", "Date", ".", "parse", "(", "$row", ".", "find", "(", "'td:nth-child(9)'", ")", ".", "text", "(", ")", ")", "}", ")", ";", "}", ")", ";", "return", "tubesio", ".", "finish", "(", "result", ")", ";", "}", ")", ";", "}" ]

[ "Parses", "search", "results", "into", "an", "array", "." ]

[ "function", "inherits", "(", "ctor", ",", "superCtor", ",", "staticInherit", ")", "{", "var", "v", "=", "(", "ctor", ".", "hasOwnProperty", "(", "'super_'", ")", "&&", "ctor", ".", "super_", ")", "||", "getPrototypeOf", "(", "ctor", ")", ";", "var", "mixinCtor", "=", "ctor", ".", "mixinCtor_", ";", "if", "(", "mixinCtor", "&&", "v", "===", "mixinCtor", ")", "{", "ctor", "=", "mixinCtor", ";", "v", "=", "(", "ctor", ".", "hasOwnProperty", "(", "'super_'", ")", "&&", "ctor", ".", "super_", ")", "||", "getPrototypeOf", "(", "ctor", ")", ";", "}", "var", "result", "=", "false", ";", "if", "(", "!", "isInheritedFrom", "(", "ctor", ",", "superCtor", ")", "&&", "!", "isInheritedFrom", "(", "superCtor", ",", "ctor", ")", ")", "{", "inheritsDirectly", "(", "ctor", ",", "superCtor", ",", "staticInherit", ")", ";", "// patch the missing prototype chain if exists ctor.super.", "while", "(", "v", "!=", "null", "&&", "v", "!==", "objectSuperCtor", "&&", "superCtor", "!==", "v", ")", "{", "ctor", "=", "superCtor", ";", "superCtor", "=", "v", ";", "inheritsDirectly", "(", "ctor", ",", "superCtor", ",", "staticInherit", ")", ";", "v", "=", "(", "ctor", ".", "hasOwnProperty", "(", "'super_'", ")", "&&", "ctor", ".", "super_", ")", "||", "getPrototypeOf", "(", "ctor", ")", ";", "}", "result", "=", "true", ";", "}", "return", "result", ";", "}" ]

[ "Inherit", "the", "prototype", "methods", "from", "one", "constructor", "into", "another", "." ]

[ "function", "(", "text", ")", "{", "if", "(", "this", ".", "$", ".", "text", "!=", "null", ")", "this", ".", "$", ".", "text", "+=", "text", ";", "else", "this", ".", "append", "(", "new", "CKEDITOR", ".", "dom", ".", "text", "(", "text", ")", ")", ";", "}" ]

[ "Append", "text", "to", "this", "element", "." ]

[ "function", "(", "parent", ")", "{", "var", "range", "=", "new", "CKEDITOR", ".", "dom", ".", "range", "(", "this", ".", "getDocument", "(", ")", ")", ";", "// We'll be extracting part of this element, so let's use our", "// range to get the correct piece.", "range", ".", "setStartAfter", "(", "this", ")", ";", "range", ".", "setEndAfter", "(", "parent", ")", ";", "// Extract it.", "var", "docFrag", "=", "range", ".", "extractContents", "(", ")", ";", "// Move the element outside the broken element.", "range", ".", "insertNode", "(", "this", ".", "remove", "(", ")", ")", ";", "// Re-insert the extracted piece after the element.", "docFrag", ".", "insertAfterNode", "(", "this", ")", ";", "}" ]

[ "Breaks", "one", "of", "the", "ancestor", "element", "in", "the", "element", "position", "moving", "this", "element", "between", "the", "broken", "parts", "." ]

[ "function", "(", ")", "{", "// http://help.dottoro.com/ljvmcrrn.php", "var", "rect", "=", "CKEDITOR", ".", "tools", ".", "extend", "(", "{", "}", ",", "this", ".", "$", ".", "getBoundingClientRect", "(", ")", ")", ";", "!", "rect", ".", "width", "&&", "(", "rect", ".", "width", "=", "rect", ".", "right", "-", "rect", ".", "left", ")", ";", "!", "rect", ".", "height", "&&", "(", "rect", ".", "height", "=", "rect", ".", "bottom", "-", "rect", ".", "top", ")", ";", "return", "rect", ";", "}" ]

[ "Retrieve", "the", "bounding", "rectangle", "of", "the", "current", "element", "in", "pixels", "relative", "to", "the", "upper", "-", "left", "corner", "of", "the", "browser", "s", "client", "area", "." ]

[ "function", "(", "otherElement", ")", "{", "// do shallow clones, but with IDs", "var", "thisEl", "=", "this", ".", "clone", "(", "0", ",", "1", ")", ",", "otherEl", "=", "otherElement", ".", "clone", "(", "0", ",", "1", ")", ";", "// Remove distractions.", "thisEl", ".", "removeAttributes", "(", "[", "'_moz_dirty'", ",", "'data-cke-expando'", ",", "'data-cke-saved-href'", ",", "'data-cke-saved-name'", "]", ")", ";", "otherEl", ".", "removeAttributes", "(", "[", "'_moz_dirty'", ",", "'data-cke-expando'", ",", "'data-cke-saved-href'", ",", "'data-cke-saved-name'", "]", ")", ";", "// Native comparison available.", "if", "(", "thisEl", ".", "$", ".", "isEqualNode", ")", "{", "// Styles order matters.", "thisEl", ".", "$", ".", "style", ".", "cssText", "=", "CKEDITOR", ".", "tools", ".", "normalizeCssText", "(", "thisEl", ".", "$", ".", "style", ".", "cssText", ")", ";", "otherEl", ".", "$", ".", "style", ".", "cssText", "=", "CKEDITOR", ".", "tools", ".", "normalizeCssText", "(", "otherEl", ".", "$", ".", "style", ".", "cssText", ")", ";", "return", "thisEl", ".", "$", ".", "isEqualNode", "(", "otherEl", ".", "$", ")", ";", "}", "else", "{", "thisEl", "=", "thisEl", ".", "getOuterHtml", "(", ")", ";", "otherEl", "=", "otherEl", ".", "getOuterHtml", "(", ")", ";", "// Fix tiny difference between link href in older IEs.", "if", "(", "CKEDITOR", ".", "env", ".", "ie", "&&", "CKEDITOR", ".", "env", ".", "version", "<", "9", "&&", "this", ".", "is", "(", "'a'", ")", ")", "{", "var", "parent", "=", "this", ".", "getParent", "(", ")", ";", "if", "(", "parent", ".", "type", "==", "CKEDITOR", ".", "NODE_ELEMENT", ")", "{", "var", "el", "=", "parent", ".", "clone", "(", ")", ";", "el", ".", "setHtml", "(", "thisEl", ")", ",", "thisEl", "=", "el", ".", "getHtml", "(", ")", ";", "el", ".", "setHtml", "(", "otherEl", ")", ",", "otherEl", "=", "el", ".", "getHtml", "(", ")", ";", "}", "}", "return", "thisEl", "==", "otherEl", ";", "}", "}" ]

[ "Compare", "this", "element", "s", "inner", "html", "tag", "name", "attributes", "etc", ".", "with", "other", "one", "." ]

[ "function", "(", ")", "{", "// CSS unselectable.", "this", ".", "setStyles", "(", "CKEDITOR", ".", "tools", ".", "cssVendorPrefix", "(", "'user-select'", ",", "'none'", ")", ")", ";", "// For IE/Opera which doesn't support for the above CSS style,", "// the unselectable=\"on\" attribute only specifies the selection", "// process cannot start in the element itself, and it doesn't inherit.", "if", "(", "CKEDITOR", ".", "env", ".", "ie", ")", "{", "this", ".", "setAttribute", "(", "'unselectable'", ",", "'on'", ")", ";", "var", "element", ",", "elements", "=", "this", ".", "getElementsByTag", "(", "'*'", ")", ";", "for", "(", "var", "i", "=", "0", ",", "count", "=", "elements", ".", "count", "(", ")", ";", "i", "<", "count", ";", "i", "++", ")", "{", "element", "=", "elements", ".", "getItem", "(", "i", ")", ";", "element", ".", "setAttribute", "(", "'unselectable'", ",", "'on'", ")", ";", "}", "}", "}" ]

[ "Makes", "the", "element", "and", "its", "children", "unselectable", "." ]

[ "function", "(", "alignToTop", ")", "{", "var", "parent", "=", "this", ".", "getParent", "(", ")", ";", "if", "(", "!", "parent", ")", "return", ";", "// Scroll the element into parent container from the inner out.", "do", "{", "// Check ancestors that overflows.", "var", "overflowed", "=", "parent", ".", "$", ".", "clientWidth", "&&", "parent", ".", "$", ".", "clientWidth", "<", "parent", ".", "$", ".", "scrollWidth", "||", "parent", ".", "$", ".", "clientHeight", "&&", "parent", ".", "$", ".", "clientHeight", "<", "parent", ".", "$", ".", "scrollHeight", ";", "// Skip body element, which will report wrong clientHeight when containing", "// floated content. (#9523)", "if", "(", "overflowed", "&&", "!", "parent", ".", "is", "(", "'body'", ")", ")", "this", ".", "scrollIntoParent", "(", "parent", ",", "alignToTop", ",", "1", ")", ";", "// Walk across the frame.", "if", "(", "parent", ".", "is", "(", "'html'", ")", ")", "{", "var", "win", "=", "parent", ".", "getWindow", "(", ")", ";", "// Avoid security error.", "try", "{", "var", "iframe", "=", "win", ".", "$", ".", "frameElement", ";", "iframe", "&&", "(", "parent", "=", "new", "CKEDITOR", ".", "dom", ".", "element", "(", "iframe", ")", ")", ";", "}", "catch", "(", "er", ")", "{", "}", "}", "}", "while", "(", "(", "parent", "=", "parent", ".", "getParent", "(", ")", ")", ")", ";", "}" ]

[ "Make", "any", "page", "element", "visible", "inside", "the", "browser", "viewport", "." ]

[ "function", "scrollBy", "(", "x", ",", "y", ")", "{", "// Webkit doesn't support \"scrollTop/scrollLeft\"", "// on documentElement/body element.", "if", "(", "/", "body|html", "/", ".", "test", "(", "parent", ".", "getName", "(", ")", ")", ")", "parent", ".", "getWindow", "(", ")", ".", "$", ".", "scrollBy", "(", "x", ",", "y", ")", ";", "else", "{", "parent", ".", "$", ".", "scrollLeft", "+=", "x", ";", "parent", ".", "$", ".", "scrollTop", "+=", "y", ";", "}", "}" ]

[ "Scroll", "the", "parent", "by", "the", "specified", "amount", "." ]

[ "function", "screenPos", "(", "element", ",", "refWin", ")", "{", "var", "pos", "=", "{", "x", ":", "0", ",", "y", ":", "0", "}", ";", "if", "(", "!", "(", "element", ".", "is", "(", "isQuirks", "?", "'body'", ":", "'html'", ")", ")", ")", "{", "var", "box", "=", "element", ".", "$", ".", "getBoundingClientRect", "(", ")", ";", "pos", ".", "x", "=", "box", ".", "left", ",", "pos", ".", "y", "=", "box", ".", "top", ";", "}", "var", "win", "=", "element", ".", "getWindow", "(", ")", ";", "if", "(", "!", "win", ".", "equals", "(", "refWin", ")", ")", "{", "var", "outerPos", "=", "screenPos", "(", "CKEDITOR", ".", "dom", ".", "element", ".", "get", "(", "win", ".", "$", ".", "frameElement", ")", ",", "refWin", ")", ";", "pos", ".", "x", "+=", "outerPos", ".", "x", ",", "pos", ".", "y", "+=", "outerPos", ".", "y", ";", "}", "return", "pos", ";", "}" ]

[ "Figure", "out", "the", "element", "position", "relative", "to", "the", "specified", "window", "." ]

[ "function", "(", "selector", ")", "{", "var", "removeTmpId", "=", "createTmpId", "(", "this", ")", ",", "list", "=", "new", "CKEDITOR", ".", "dom", ".", "nodeList", "(", "this", ".", "$", ".", "querySelectorAll", "(", "getContextualizedSelector", "(", "this", ",", "selector", ")", ")", ")", ";", "removeTmpId", "(", ")", ";", "return", "list", ";", "}" ]

[ "Returns", "list", "of", "elements", "within", "this", "element", "that", "match", "specified", "selector", "." ]

[ "function", "(", "selector", ")", "{", "var", "removeTmpId", "=", "createTmpId", "(", "this", ")", ",", "found", "=", "this", ".", "$", ".", "querySelector", "(", "getContextualizedSelector", "(", "this", ",", "selector", ")", ")", ";", "removeTmpId", "(", ")", ";", "return", "found", "?", "new", "CKEDITOR", ".", "dom", ".", "element", "(", "found", ")", ":", "null", ";", "}" ]

[ "Returns", "first", "element", "within", "this", "element", "that", "matches", "specified", "selector", "." ]

[ "function", "pushTo", "(", "array", ")", "{", "return", "map", "(", "function", "(", "file", ",", "cb", ")", "{", "array", ".", "push", "(", "file", ")", ";", "cb", "(", "null", ",", "file", ")", ";", "}", ")", ";", "}" ]

[ "pushes", "files", "from", "pipe", "to", "array" ]

[ "function", "processBundleFile", "(", "file", ",", "bundleExt", ",", "variables", ",", "bundleHandler", ",", "errorCallback", ")", "{", "// get bundle files", "var", "lines", "=", "file", ".", "contents", ".", "toString", "(", ")", ".", "split", "(", "'\\n'", ")", ";", "var", "resultFilePaths", "=", "[", "]", ";", "lines", ".", "forEach", "(", "function", "(", "line", ")", "{", "var", "filePath", "=", "getFilePathFromLine", "(", "file", ",", "line", ",", "variables", ")", ";", "if", "(", "filePath", ")", "resultFilePaths", ".", "push", "(", "filePath", ")", ";", "}", ")", ";", "if", "(", "!", "errorCallback", ")", "errorCallback", "=", "function", "(", ")", "{", "}", ";", "// find files and send to buffer", "var", "bundleSrc", "=", "fs", ".", "src", "(", "resultFilePaths", ")", ".", "on", "(", "'error'", ",", "errorCallback", ")", "// handle file not found errors", ".", "pipe", "(", "plumber", "(", "errorCallback", ")", ")", "// handle other errors inside pipeline ", ".", "pipe", "(", "recursiveBundle", "(", "bundleExt", ",", "variables", ",", "errorCallback", ")", ")", ";", "if", "(", "bundleHandler", "&&", "typeof", "bundleHandler", "===", "'function'", ")", "bundleSrc", "=", "bundleHandler", "(", "bundleSrc", ")", ";", "return", "bundleSrc", ".", "pipe", "(", "plumber", ".", "stop", "(", ")", ")", ";", "}" ]

[ "creates", "new", "pipe", "for", "files", "from", "bundle" ]

[ "function", "getFilePathFromLine", "(", "bundleFile", ",", "line", ",", "variables", ")", "{", "// handle variables", "var", "varRegex", "=", "/", "@{([^}]+)}", "/", ";", "var", "match", ";", "while", "(", "match", "=", "line", ".", "match", "(", "varRegex", ")", ")", "{", "var", "varName", "=", "match", "[", "1", "]", ";", "if", "(", "!", "variables", "||", "typeof", "(", "variables", "[", "varName", "]", ")", "===", "'undefined'", ")", "throw", "new", "gutil", ".", "PluginError", "(", "pluginName", ",", "bundleFile", ".", "path", "+", "': variable \"'", "+", "varName", "+", "'\" is not specified'", ")", ";", "var", "varValue", "=", "variables", "[", "varName", "]", ";", "line", "=", "line", ".", "substr", "(", "0", ",", "match", ".", "index", ")", "+", "varValue", "+", "line", ".", "substr", "(", "match", ".", "index", "+", "match", "[", "0", "]", ".", "length", ")", ";", "}", "if", "(", "line", "===", "''", ")", "return", "null", ";", "// handle `!` negated file paths", "var", "negative", "=", "line", "[", "0", "]", "===", "'!'", ";", "if", "(", "negative", ")", "line", "=", "line", ".", "substr", "(", "1", ")", ";", "// get file path for line", "var", "filePath", ";", "if", "(", "line", ".", "indexOf", "(", "'./'", ")", "===", "0", ")", "filePath", "=", "path", ".", "resolve", "(", "bundleFile", ".", "cwd", ",", "line", ")", ";", "else", "filePath", "=", "path", ".", "resolve", "(", "bundleFile", ".", "base", ",", "line", ")", ";", "// return path", "if", "(", "negative", ")", "return", "'!'", "+", "filePath", ";", "return", "filePath", ";", "}" ]

[ "parses", "file", "path", "from", "line", "in", "bundle", "file" ]

[ "function", "recursiveBundle", "(", "bundleExt", ",", "variables", ",", "errorCallback", ")", "{", "return", "through2", ".", "obj", "(", "function", "(", "file", ",", "enc", ",", "cb", ")", "{", "if", "(", "!", "checkFile", "(", "file", ",", "cb", ")", ")", "return", ";", "// standart file push to callback", "if", "(", "path", ".", "extname", "(", "file", ".", "path", ")", ".", "toLowerCase", "(", ")", "!=", "bundleExt", ")", "return", "cb", "(", "null", ",", "file", ")", ";", "// bundle file should be parsed", "processBundleFile", "(", "file", ",", "bundleExt", ",", "variables", ",", "null", ",", "errorCallback", ")", ".", "pipe", "(", "pushTo", "(", "this", ")", ")", ".", "on", "(", "'end'", ",", "cb", ")", ";", "}", ")", ";", "}" ]

[ "recursively", "processes", "files", "and", "unwraps", "bundle", "files" ]

[ "function", "(", "variables", ",", "bundleHandler", ")", "{", "// handle if bundleHandler specified in first argument", "if", "(", "!", "bundleHandler", "&&", "typeof", "(", "variables", ")", "===", "'function'", ")", "{", "bundleHandler", "=", "variables", ";", "variables", "=", "null", ";", "}", "return", "through2", ".", "obj", "(", "function", "(", "file", ",", "enc", ",", "cb", ")", "{", "if", "(", "!", "checkFile", "(", "file", ",", "cb", ")", ")", "return", ";", "var", "ext", "=", "path", ".", "extname", "(", "file", ".", "path", ")", ".", "toLowerCase", "(", ")", ";", "var", "resultFileName", "=", "path", ".", "basename", "(", "file", ".", "path", ",", "ext", ")", ";", "var", "bundleFiles", "=", "processBundleFile", "(", "file", ",", "ext", ",", "variables", ",", "bundleHandler", ",", "cb", ")", ";", "if", "(", "file", ".", "sourceMap", ")", "bundleFiles", "=", "bundleFiles", ".", "pipe", "(", "sourcemaps", ".", "init", "(", ")", ")", ";", "bundleFiles", ".", "pipe", "(", "concat", "(", "resultFileName", ")", ")", ".", "pipe", "(", "pushTo", "(", "this", ")", ")", ".", "on", "(", "'end'", ",", "cb", ")", ";", "}", ")", ";", "}" ]

[ "concatenates", "files", "from", "bundle", "and", "replaces", "bundle", "file", "in", "current", "pipe", "first", "parameter", "is", "function", "that", "handles", "source", "stream", "for", "each", "bundle" ]

[ "function", "DispatchError", "(", "message", ")", "{", "Error", ".", "call", "(", "this", ")", ";", "Error", ".", "captureStackTrace", "(", "this", ",", "arguments", ".", "callee", ")", ";", "this", ".", "name", "=", "'DispatchError'", ";", "this", ".", "message", "=", "message", ";", "}" ]

[ "DispatchError", "error", "." ]

[ "function", "delegateOptional", "(", "self", ")", "{", "if", "(", "hasOwn", "(", "self", ",", "'actual'", ")", "&&", "hasOwn", "(", "self", ",", "'expected'", ")", ")", "{", "var", "kindOf", "=", "tryRequire", "(", "'kind-of-extra'", ",", "'kind-error'", ")", "delegate", "(", "self", ",", "{", "orig", ":", "{", "actual", ":", "self", ".", "actual", ",", "expected", ":", "self", ".", "expected", "}", ",", "type", ":", "{", "actual", ":", "kindOf", "(", "self", ".", "actual", ")", ",", "expected", ":", "kindOf", "(", "self", ".", "expected", ")", "}", ",", "inspect", ":", "{", "actual", ":", "util", ".", "inspect", "(", "self", ".", "actual", ")", ",", "expected", ":", "util", ".", "inspect", "(", "self", ".", "expected", ")", "}", "}", ")", "if", "(", "typeof", "self", ".", "message", "===", "'function'", ")", "{", "self", ".", "message", "=", "self", ".", "message", ".", "call", "(", "self", ",", "self", ".", "type", ",", "self", ".", "inspect", ")", "// eslint-disable-line no-useless-call", "}", "}", "return", "self", "}" ]

[ ">", "Delegate", "additional", "optional", "properties", "to", "the", "KindError", "class", ".", "If", "actual", "and", "expected", "properties", "given", "in", "options", "object", "." ]

[ "function", "messageFormat", "(", "type", ",", "inspect", ")", "{", "var", "msg", "=", "this", ".", "detailed", "?", "'expect %s `%s`, but %s `%s` given'", ":", "'expect `%s`, but `%s` given'", "return", "this", ".", "detailed", "?", "util", ".", "format", "(", "msg", ",", "type", ".", "expected", ",", "inspect", ".", "expected", ",", "type", ".", "actual", ",", "inspect", ".", "actual", ")", ":", "util", ".", "format", "(", "msg", ",", "type", ".", "expected", ",", "type", ".", "actual", ")", "}" ]

[ ">", "Default", "message", "formatting", "function", "." ]

[ "function", "remap", "(", "map", ",", "str", ")", "{", "str", "=", "string", ".", "call", "(", "str", ")", "===", "'[object String]'", "?", "str", ":", "''", "for", "(", "var", "key", "in", "map", ")", "{", "if", "(", "str", ".", "match", "(", "new", "RegExp", "(", "key", ",", "'i'", ")", ")", ")", "return", "map", "[", "key", "]", "}", "return", "''", "}" ]

[ "Curried", "function", "which", "takes", "a", "map", "of", "RegExp", "string", "keys", "which", "when", "successfully", "matched", "given", "string", "resolves", "to", "mapped", "value", "." ]

[ "function", "add", "(", "a", ",", "b", ")", "{", "var", "fifths", "=", "a", "[", "0", "]", "+", "b", "[", "0", "]", "var", "octaves", "=", "a", "[", "1", "]", "===", "null", "||", "b", "[", "1", "]", "===", "null", "?", "null", ":", "a", "[", "1", "]", "+", "b", "[", "1", "]", "return", "[", "fifths", ",", "octaves", "]", "}" ]

[ "Add", "two", "pitches", ".", "Can", "be", "used", "to", "tranpose", "pitches", "." ]

[ "function", "subtract", "(", "a", ",", "b", ")", "{", "var", "fifths", "=", "b", "[", "0", "]", "-", "a", "[", "0", "]", "var", "octaves", "=", "a", "[", "1", "]", "!==", "null", "&&", "b", "[", "1", "]", "!==", "null", "?", "b", "[", "1", "]", "-", "a", "[", "1", "]", ":", "null", "return", "[", "fifths", ",", "octaves", "]", "}" ]

[ "Subtract", "two", "pitches", "or", "intervals", ".", "Can", "be", "used", "to", "find", "the", "distance", "between", "pitches", "." ]

[ "function", "nth", "(", "n", ",", "array", ")", "{", "return", "n", "<", "0", "?", "array", "[", "array", ".", "length", "+", "n", "]", ":", "array", "[", "n", "]", "}" ]

[ "Returns", "the", "n", "th", "element", "in", "the", "given", "array", "." ]

[ "function", "scanErr", "(", "err", ",", "pathname", ")", "{", "log", ".", "debug", "(", "err", ")", ";", "if", "(", "'ENOENT'", "===", "err", ".", "code", ")", "{", "callback", "(", "pathname", "+", "' does not exist.'", ")", ";", "}", "else", "{", "callback", "(", "'Unexpected error.'", ")", ";", "}", "// cli does process.exit() in callback, but unit tests don't.", "callback", "=", "function", "(", ")", "{", "}", ";", "}" ]

[ "scanfs", "error", "callback" ]

[ "async", "function", "getCurrentServerTimeAndBlock", "(", ")", "{", "await", "retrieveDynGlobProps", "(", ")", ";", "if", "(", "props", ".", "time", ")", "{", "lastCommitedBlock", "=", "props", ".", "last_irreversible_block_num", ";", "trace", "(", "\"lastCommitedBlock = \"", "+", "lastCommitedBlock", "+", "\", headBlock = \"", "+", "props", ".", "head_block_number", ")", ";", "return", "{", "time", ":", "Date", ".", "parse", "(", "props", ".", "time", ")", ",", "block", ":", "props", ".", "head_block_number", ",", "commited_block", ":", "props", ".", "last_irreversible_block_num", "}", ";", "}", "throw", "\"Current time could not be retrieved\"", ";", "}" ]

[ "time", "in", "milliseconds" ]

[ "function", "filter", "(", "obj", ")", "{", "var", "result", "=", "{", "}", ",", "fieldDefine", ",", "value", ";", "for", "(", "var", "field", "in", "options", ")", "{", "fieldDefine", "=", "options", "[", "field", "]", ";", "value", "=", "obj", "[", "field", "]", ";", "if", "(", "!", "fieldDefine", ".", "private", "&&", "value", "!==", "undefined", ")", "{", "result", "[", "field", "]", "=", "value", ";", "}", "}", "return", "result", ";", "}" ]

[ "filter", "private", "fields" ]

[ "function", "Container", "(", "name", ",", "token", ",", "url", ")", "{", "this", ".", "_name", "=", "name", ";", "this", ".", "_url", "=", "url", ";", "this", ".", "_token", "=", "token", ";", "this", ".", "isNew", "=", "false", ";", "}" ]

[ "Create", "a", "new", "container", "." ]

[ "function", "waitForJobToFinish", "(", "driver", ",", "options", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "var", "start", "=", "Date", ".", "now", "(", ")", ";", "var", "timingOut", "=", "false", ";", "function", "check", "(", ")", "{", "var", "checkedForExceptions", ";", "if", "(", "options", ".", "allowExceptions", ")", "{", "checkedForExceptions", "=", "Promise", ".", "resolve", "(", "null", ")", ";", "}", "else", "{", "checkedForExceptions", "=", "driver", ".", "browser", "(", ")", ".", "activeWindow", "(", ")", ".", "execute", "(", "'return window.ERROR_HAS_OCCURED;'", ")", ".", "then", "(", "function", "(", "errorHasOcucured", ")", "{", "if", "(", "!", "errorHasOcucured", ")", "return", ";", "return", "driver", ".", "browser", "(", ")", ".", "activeWindow", "(", ")", ".", "execute", "(", "'return window.FIRST_ERROR;'", ")", ".", "then", "(", "function", "(", "err", ")", "{", "var", "loc", "=", "location", ".", "getOriginalLocation", "(", "err", ".", "url", ",", "err", ".", "line", ")", ";", "var", "clientError", "=", "new", "Error", "(", "err", ".", "msg", "+", "' ('", "+", "loc", ".", "source", "+", "' line '", "+", "loc", ".", "line", "+", "')'", ")", ";", "clientError", ".", "isClientError", "=", "true", ";", "throw", "clientError", ";", "}", ",", "function", "(", ")", "{", "throw", "new", "Error", "(", "'Unknown error was thrown and not caught in the browser.'", ")", ";", "}", ")", ";", "}", ",", "function", "(", ")", "{", "}", ")", ";", "}", "checkedForExceptions", ".", "then", "(", "function", "(", ")", "{", "return", "retry", "(", "function", "(", ")", "{", "if", "(", "typeof", "options", ".", "testComplete", "===", "'string'", ")", "{", "return", "driver", ".", "browser", "(", ")", ".", "activeWindow", "(", ")", ".", "execute", "(", "options", ".", "testComplete", ")", ";", "}", "else", "{", "return", "Promise", ".", "resolve", "(", "options", ".", "testComplete", "(", "driver", ")", ")", ";", "}", "}", ",", "5", ",", "'500ms'", ",", "{", "debug", ":", "options", ".", "debug", "}", ")", ";", "}", ")", ".", "done", "(", "function", "(", "complete", ")", "{", "if", "(", "complete", ")", "resolve", "(", ")", ";", "else", "{", "if", "(", "timingOut", ")", "return", "reject", "(", "new", "Error", "(", "'Test timed out'", ")", ")", ";", "if", "(", "Date", ".", "now", "(", ")", "-", "start", ">", "ms", "(", "''", "+", "(", "options", ".", "timeout", "||", "'20s'", ")", ")", ")", "timingOut", "=", "true", ";", "setTimeout", "(", "check", ",", "500", ")", ";", "}", "}", ",", "reject", ")", ";", "}", "check", "(", ")", ";", "}", ")", ";", "}" ]

[ "Wait", "for", "a", "driver", "that", "has", "a", "running", "job", "to", "finish", "its", "job" ]

[ "function", "Range", "(", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Range", ")", ")", "{", "return", "new", "Range", "(", ")", ";", "}", "// maximize int.", "var", "max", "=", "Math", ".", "pow", "(", "2", ",", "32", ")", "-", "1", ";", "// default options.", "this", ".", "options", "=", "{", "min", ":", "-", "max", ",", "max", ":", "max", ",", "res", ":", "{", "range", ":", "/", "^[\\s\\d\\-~,]+$", "/", ",", "blank", ":", "/", "\\s+", "/", "g", ",", "number", ":", "/", "^\\-?\\d+$", "/", ",", "min2num", ":", "/", "^~\\-?\\d+$", "/", ",", "num2max", ":", "/", "^\\-?\\d+~$", "/", ",", "num2num", ":", "/", "^\\-?\\d+~\\-?\\d+$", "/", "}", "}", ";", "Object", ".", "freeze", "(", "this", ".", "options", ")", ";", "}" ]

[ "Range", "parser", "." ]

[ "function", "(", "s", ",", "opts", ")", "{", "var", "r", "=", "s", ".", "split", "(", "'~'", ")", ".", "map", "(", "function", "(", "d", ")", "{", "return", "parseFloat", "(", "d", ")", ";", "}", ")", ";", "// number at position 1 must greater than position 0.", "if", "(", "r", "[", "0", "]", ">", "r", "[", "1", "]", ")", "{", "return", "r", ".", "reverse", "(", ")", ";", "}", "return", "r", ";", "}" ]

[ "String", "like", "1~2", "5~8", "it", "means", "a", "range", "from", "a", "specific", "number", "to", "another", "." ]

[ "function", "rename", "(", "node", ",", "it", ",", "to", ")", "{", "switch", "(", "node", ".", "type", ")", "{", "case", "'VariableDeclaration'", ":", "return", "node", ".", "declarations", ".", "forEach", "(", "function", "(", "dec", ")", "{", "if", "(", "dec", ".", "id", ".", "name", "==", "it", ")", "dec", ".", "id", ".", "name", "=", "to", "if", "(", "dec", ".", "init", ")", "rename", "(", "dec", ".", "init", ",", "it", ",", "to", ")", "}", ")", "case", "'FunctionDeclaration'", ":", "if", "(", "node", ".", "id", ".", "name", "==", "it", ")", "node", ".", "id", ".", "name", "=", "to", "// falls through", "case", "'FunctionExpression'", ":", "var", "isIt", "=", "function", "(", "id", ")", "{", "return", "id", ".", "name", "==", "it", "}", "return", "isIt", "(", "node", ".", "id", ")", "||", "node", ".", "params", ".", "some", "(", "isIt", ")", "||", "freshVars", "(", "node", ".", "body", ")", ".", "some", "(", "isIt", ")", "||", "rename", "(", "node", ".", "body", ",", "it", ",", "to", ")", "case", "'CatchClause'", ":", "if", "(", "node", ".", "param", ".", "name", "==", "it", ")", "return", "return", "rename", "(", "node", ".", "body", ",", "it", ",", "to", ")", "case", "'Identifier'", ":", "return", "node", ".", "name", "==", "it", "&&", "(", "node", ".", "name", "=", "to", ")", "}", "children", "(", "node", ")", ".", "forEach", "(", "function", "(", "child", ")", "{", "rename", "(", "child", ",", "it", ",", "to", ")", "}", ")", "return", "node", "}" ]

[ "rename", "all", "references", "to", "it", "in", "or", "below", "nodes", "s", "scope", "to", "to" ]

[ "function", "freshVars", "(", "node", ")", "{", "switch", "(", "node", ".", "type", ")", "{", "case", "'VariableDeclaration'", ":", "return", "node", ".", "declarations", ".", "map", "(", "function", "(", "n", ")", "{", "return", "n", ".", "id", "}", ")", "case", "'FunctionExpression'", ":", "return", "[", "]", "// early exit", "case", "'FunctionDeclaration'", ":", "return", "[", "node", ".", "id", "]", "}", "return", "children", "(", "node", ")", ".", "map", "(", "freshVars", ")", ".", "reduce", "(", "concat", ",", "[", "]", ")", "}" ]

[ "get", "all", "declared", "variables", "within", "node", "s", "scope" ]

[ "function", "(", "filename", ")", "{", "var", "resume", "=", "filename", "===", "true", ";", "// should only ever be set by resume calls", "var", "fd", "=", "this", ".", "_fd", "=", "resume", "?", "this", ".", "_fd", ":", "fs", ".", "openSync", "(", "filename", ",", "'r'", ")", ";", "var", "buffer", "=", "new", "Buffer", "(", "4096", ")", ";", "var", "bytesRead", ";", "var", "current", "=", "''", ";", "var", "remainder", "=", "resume", "?", "this", ".", "_remainder", ":", "''", ";", "while", "(", "!", "this", ".", "_paused", "&&", "(", "bytesRead", "=", "fs", ".", "readSync", "(", "fd", ",", "buffer", ",", "0", ",", "buffer", ".", "length", ")", ")", ")", "{", "current", "=", "buffer", ".", "toString", "(", "'utf-8'", ")", ";", "if", "(", "current", ".", "length", ">", "bytesRead", ")", "{", "current", "=", "current", ".", "slice", "(", "0", ",", "bytesRead", ")", ";", "}", "remainder", "=", "this", ".", "_remainder", "=", "this", ".", "_parseLines", "(", "remainder", "+", "current", ")", ";", "}", "// The loop will end either when EOF is reached, or pause was called.", "// In the former case, close the file; in the latter case, leave it", "// open with the expectation that we'll pick up where we left off.", "if", "(", "!", "this", ".", "_paused", ")", "{", "fs", ".", "closeSync", "(", "fd", ")", ";", "}", "}" ]

[ "Parses", "the", "given", "log", "file", "." ]

[ "function", "init", "(", ")", "{", "//modules load", "terminal", ".", "colors", ".", "default", "=", "chalk", ".", "white", ".", "bold", ";", "terminal", ".", "default", "=", "\"\"", ";", "//set the colors of the terminal", "checkUserColors", "(", "terminal", ".", "colors", ")", ";", "bool", "=", "true", ";", "//to control the view properties and colors", "properties", "=", "Object", ".", "getOwnPropertyNames", "(", "terminal", ")", ";", "colors", "=", "Object", ".", "getOwnPropertyNames", "(", "terminal", ".", "colors", ")", ";", "}" ]

[ "to", "reinit", "the", "audrey", "view", "when", "is", "updated" ]

[ "function", "fertilise", "(", "objectName", ",", "value", ",", "color", ",", "blockPos", ")", "{", "if", "(", "!", "blockPos", ")", "throw", "new", "Error", "(", "\"incorrect call to fertilise method\"", ")", ";", "var", "name", "=", "objectName", ".", "slice", "(", "2", ")", ";", "terminal", "[", "name", "]", "=", "value", ";", "terminal", ".", "colors", "[", "name", "]", "=", "color", ";", "setOnBlock", "(", "objectName", ",", "blockPos", ")", ";", "checkUserColors", "(", "terminal", ".", "colors", ")", ";", "init", "(", ")", ";", "}" ]

[ "by", "name", "value", "color", "block" ]

[ "function", "checkUserColors", "(", "colorUser", ")", "{", "if", "(", "terminal", ".", "colors", ")", "{", "for", "(", "var", "name", "in", "colorUser", ")", "{", "colorUser", "[", "name", "]", "=", "setUserColor", "(", "colorUser", "[", "name", "]", ")", ";", "}", "}", "else", "{", "throw", "new", "Error", "(", "\"There is no colors object defined\"", ")", ";", "}", "}" ]

[ "FUNCTIONS", "FOR", "THE", "CLI", "RESPONSE", "..", "check", "if", "there", "is", "defined", "object", "colors", "if", "not", "throw", "error" ]

[ "function", "setOnBlock", "(", "objectName", ",", "blockPos", ")", "{", "switch", "(", "blockPos", ")", "{", "//check where to add in the structure", "case", "'header'", ":", "terminal", ".", "header", ".", "push", "(", "objectName", ")", ";", "break", ";", "case", "'body'", ":", "terminal", ".", "body", ".", "push", "(", "objectName", ")", ";", "break", ";", "case", "'footer'", ":", "terminal", ".", "footer", ".", "push", "(", "objectName", ")", ";", "break", ";", "}", "}" ]

[ "adds", "new", "object", "to", "list", "of", "print" ]

[ "function", "checkColors", "(", "name", ")", "{", "var", "colors", "=", "Object", ".", "getOwnPropertyNames", "(", "terminal", ".", "colors", ")", ";", "var", "bul", "=", "false", ";", "// boolean to control if its defined the property", "for", "(", "var", "i", "=", "0", ";", "i", "<", "colors", ".", "length", ";", "i", "++", ")", "{", "//iterate over prop names", "if", "(", "colors", "[", "i", "]", "===", "name", ")", "{", "//if it is", "bul", "=", "true", ";", "}", "}", "if", "(", "bul", "!==", "true", ")", "{", "//if its finded the statement of the tag", "terminal", ".", "colors", "[", "name", "]", "=", "terminal", ".", "colors", ".", "default", ";", "}", "}" ]

[ "checks", "the", "colors", "in", "printBrand" ]

[ "function", "checkProperties", "(", "name", ")", "{", "var", "bul", "=", "false", ";", "// boolean to control if its defined the property", "for", "(", "var", "i", "=", "0", ";", "i", "<", "properties", ".", "length", ";", "i", "++", ")", "{", "//iterate over prop names", "if", "(", "properties", "[", "i", "]", "===", "name", ")", "{", "//if it is", "bul", "=", "true", ";", "}", "}", "if", "(", "bul", "!==", "true", ")", "{", "// it isn't finded the statement of the tag", "throw", "new", "Error", "(", "'Not defined '", "+", "name", ")", ";", "}", "}" ]

[ "control", "if", "the", "view", "has", "the", "correct", "properties", "if", "not", "throw", "error" ]

[ "function", "aError", "(", "errorObject", ")", "{", "if", "(", "!", "terminal", ".", "symbolProgress", ")", "terminal", ".", "symbolProgress", "=", "\"? \"", ";", "if", "(", "errorObject", ".", "aux", ")", "{", "if", "(", "!", "terminal", ".", "colors", ".", "aux", ")", "terminal", ".", "colors", ".", "aux", "=", "chalk", ".", "white", ";", "console", ".", "log", "(", "terminal", ".", "colors", ".", "error", "(", "terminal", ".", "symbolProgress", "+", "\" Error: \"", "+", "errorObject", ".", "message", ")", "+", "\" \"", "+", "terminal", ".", "colors", ".", "aux", "(", "errorObject", ".", "aux", ")", ")", ";", "console", ".", "log", "(", ")", ";", "}", "else", "{", "console", ".", "log", "(", "terminal", ".", "colors", ".", "error", "(", "terminal", ".", "symbolProgress", "+", "\" Error: \"", "+", "errorObject", ".", "message", ")", ")", ";", "console", ".", "log", "(", ")", ";", "}", "}" ]

[ "FUNCTIONS", "FOR", "PRINTING", "ON", "SCREEN", "print", "error", "message", "for", "debug" ]

[ "function", "aSuccess", "(", "errorObject", ")", "{", "if", "(", "!", "terminal", ".", "symbolProgress", ")", "terminal", ".", "symbolProgress", "=", "\"? \"", ";", "if", "(", "errorObject", ".", "aux", ")", "{", "if", "(", "!", "terminal", ".", "colors", ".", "aux", ")", "terminal", ".", "colors", ".", "aux", "=", "chalk", ".", "white", ";", "console", ".", "log", "(", "terminal", ".", "colors", ".", "success", "(", "terminal", ".", "symbolProgress", "+", "\" Success: \"", "+", "errorObject", ".", "message", ")", "+", "\" \"", "+", "terminal", ".", "colors", ".", "aux", "(", "errorObject", ".", "aux", ")", ")", ";", "console", ".", "log", "(", ")", ";", "}", "else", "{", "console", ".", "log", "(", "terminal", ".", "colors", ".", "success", "(", "terminal", ".", "symbolProgress", "+", "\" Success: \"", "+", "errorObject", ".", "message", ")", ")", ";", "console", ".", "log", "(", ")", ";", "}", "}" ]

[ "print", "success", "error", "for", "debug" ]

[ "function", "aWarning", "(", "errorObject", ")", "{", "if", "(", "!", "terminal", ".", "symbolProgress", ")", "terminal", ".", "symbolProgress", "=", "\"? \"", ";", "if", "(", "errorObject", ".", "aux", ")", "{", "if", "(", "!", "terminal", ".", "colors", ".", "aux", ")", "terminal", ".", "colors", ".", "aux", "=", "chalk", ".", "white", ";", "console", ".", "log", "(", "terminal", ".", "colors", ".", "warning", "(", "terminal", ".", "symbolProgress", "+", "\" Warning: \"", "+", "errorObject", ".", "message", ")", "+", "\" \"", "+", "terminal", ".", "colors", ".", "aux", "(", "errorObject", ".", "aux", ")", ")", ";", "console", ".", "log", "(", ")", ";", "}", "else", "{", "console", ".", "log", "(", "terminal", ".", "colors", ".", "warning", "(", "terminal", ".", "symbolProgress", "+", "\" Warning: \"", "+", "errorObject", ".", "message", ")", ")", ";", "console", ".", "log", "(", ")", ";", "}", "}" ]

[ "print", "warning", "error", "for", "debug" ]

[ "function", "addStaticAssetRoute", "(", "server", ",", "scaffold", ")", "{", "assert", "(", "scaffold", ".", "path", ",", "`", "`", ")", ";", "const", "contentFolder", "=", "scaffold", ".", "folder", "||", "path", ".", "sep", ";", "const", "serveStatic", "=", "scaffold", ".", "serveStatic", "||", "restify", ".", "plugins", ".", "serveStatic", ";", "const", "defaultAsset", "=", "scaffold", ".", "defaultAsset", "||", "'index.html'", ";", "const", "appendRequestPath", "=", "(", "scaffold", ".", "appendRequestPath", "===", "false", "?", "false", ":", "true", ")", ";", "// default true", "// When we are running tests, the path to our assets will be different. ", "// We create the path using NODE_ENV which should be set to TESTING.", "let", "directory", "=", "path", ".", "join", "(", "__dirname", ",", "'..'", ",", "'..'", ",", "'..'", ",", "'..'", ",", "contentFolder", ")", ";", "if", "(", "(", "process", ".", "env", ".", "NODE_ENV", "||", "''", ")", ".", "toUpperCase", "(", ")", "===", "'TESTING'", ")", "{", "directory", "=", "path", ".", "join", "(", "__dirname", ",", "\"..\"", ",", "contentFolder", ")", ";", "}", "debug", "(", "`", "${", "scaffold", ".", "path", "}", "${", "directory", "}", "`", ")", ";", "server", ".", "get", "(", "scaffold", ".", "path", ",", "serveStatic", "(", "{", "directory", ",", "appendRequestPath", ",", "default", ":", "defaultAsset", "}", ")", ")", ";", "}" ]

[ "Add", "a", "GET", "route", "to", "the", "server", "to", "handle", "static", "assets", "." ]

[ "function", "addRedirectRoute", "(", "server", ",", "scaffold", ")", "{", "assert", "(", "scaffold", ".", "path", "&&", "scaffold", ".", "target", ",", "`", "`", ")", ";", "server", ".", "get", "(", "scaffold", ".", "path", ",", "function", "(", "req", ",", "res", ",", "next", ")", "{", "res", ".", "redirect", "(", "scaffold", ".", "target", ",", "next", ")", ";", "}", ")", ";", "}" ]

[ "Add", "a", "GET", "route", "that", "redirects", "to", "another", "URI", "." ]

[ "function", "addTemplateRoute", "(", "server", ",", "scaffold", ")", "{", "server", ".", "get", "(", "scaffold", ".", "path", ",", "function", "(", "req", ",", "res", ",", "next", ")", "{", "const", "transomTemplate", "=", "server", ".", "registry", ".", "get", "(", "scaffold", ".", "templateHandler", ")", ";", "const", "contentType", "=", "scaffold", ".", "contentType", "||", "'text/html'", ";", "const", "p", "=", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "// Push request headers and params into the data going to the template.", "const", "data", "=", "scaffold", ".", "data", "||", "{", "}", ";", "data", ".", "headers", "=", "req", ".", "headers", ";", "data", ".", "params", "=", "req", ".", "params", ";", "resolve", "(", "transomTemplate", ".", "renderHtmlTemplate", "(", "scaffold", ".", "templateName", ",", "data", ")", ")", ";", "}", ")", ".", "then", "(", "function", "(", "pageData", ")", "{", "res", ".", "setHeader", "(", "'content-type'", ",", "contentType", ")", ";", "res", ".", "end", "(", "pageData", ")", ";", "next", "(", "false", ")", ";", "// false stops the chain.", "}", ")", ".", "catch", "(", "function", "(", "err", ")", "{", "next", "(", "err", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Add", "a", "GET", "route", "that", "is", "handled", "with", "a", "template", "." ]

[ "function", "resolveNodeSkel", "(", "index", ",", "nodeName", ")", "{", "var", "idx", "=", "+", "graph", ".", "nameToIndex", "[", "nodeName", "]", ";", "argh", "=", "[", "idx", ",", "+", "index", "]", "if", "(", "Number", ".", "isNaN", "(", "idx", ")", ")", "{", "throw", "\"Unable to get index for node '\"", "+", "nodeName", "+", "\"'. (Is the node name misspelled?)\"", ";", "}", "if", "(", "index", "!==", "undefined", "&&", "idx", ">", "+", "index", ")", "{", "throw", "\"Unable to get index for node '\"", "+", "nodeName", "+", "\"'. (Are the nodes out of order?)\"", ";", "}", "if", "(", "index", "!==", "undefined", "&&", "idx", "==", "+", "index", ")", "{", "throw", "\"Unable to get index for node '\"", "+", "nodeName", "+", "\"'. (Is the node trying to reference itself?)\"", ";", "}", "return", "(", "dataContext", ")", "=>", "dataContext", ".", "values", "[", "idx", "]", ";", "}" ]

[ "Helper", "function", "to", "lookup", "a", "node" ]

[ "function", "resolveValueOrNodeSkel", "(", "index", ",", "val", ",", "valDefault", ")", "{", "switch", "(", "typeof", "(", "val", ")", ")", "{", "case", "\"string\"", ":", "return", "resolveNodeSkel", "(", "index", ",", "val", ")", ";", "case", "\"undefined\"", ":", "if", "(", "valDefault", "===", "undefined", ")", "{", "throw", "\"Unable to get value'\"", "+", "val", "+", "\"'\"", ";", "}", "return", "(", ")", "=>", "valDefault", ";", "default", ":", "return", "(", ")", "=>", "val", ";", "}", "}" ]

[ "Helper", "function", "for", "getting", "either", "a", "value", "or", "data", "from", "another", "node", "or", "return", "the", "default" ]

[ "function", "initialize", "(", ")", "{", "var", "scene", "=", "ds", "=", "exports", ".", "ds", "=", "{", "\"time\"", ":", "0", ",", "\"song\"", ":", "null", ",", "\"graph\"", ":", "null", ",", "\"shaders\"", ":", "{", "}", ",", "\"textures\"", ":", "{", "}", ",", "\"texturesToLoad\"", ":", "0", ",", "\"audio\"", ":", "{", "\"loaded\"", ":", "false", ",", "\"playing\"", ":", "false", "}", ",", "\"isLoaded\"", ":", "function", "(", ")", "{", "return", "this", ".", "graph", "!==", "null", "&&", "this", ".", "texturesToLoad", "===", "0", "&&", "this", ".", "audio", ".", "loaded", "===", "true", ";", "}", ",", "\"next\"", ":", "null", "}", ";", "scene", ".", "gl", "=", "initializeWebGL", "(", ")", ";", "initAudio", "(", "scene", ".", "audio", ")", ";", "initUI", "(", "scene", ")", ";", "scene", ".", "shaders", ".", "sprite", "=", "createGlslProgram", "(", "scene", ".", "gl", ",", "\"vertexShaderSprite\"", ",", "\"fragmentShaderSprite\"", ")", ";", "scene", ".", "shaders", ".", "particle", "=", "createGlslProgram", "(", "scene", ".", "gl", ",", "\"vertexShaderParticle\"", ",", "\"fragmentShaderParticle\"", ")", ";", "window", ".", "requestAnimationFrame", "(", "animationFrame", ".", "bind", "(", "null", ",", "scene", ")", ")", ";", "}" ]

[ "Scene", "object", "for", "debugging" ]

[ "function", "sumObjectValues", "(", "object", ",", "depth", ",", "level", "=", "1", ")", "{", "let", "sum", "=", "0", ";", "for", "(", "const", "i", "in", "object", ")", "{", "const", "value", "=", "object", "[", "i", "]", ";", "if", "(", "isNumber", "(", "value", ")", ")", "{", "sum", "+=", "parseFloat", "(", "value", ")", ";", "}", "else", "if", "(", "isObject", "(", "value", ")", "&&", "(", "depth", "<", "1", "||", "depth", ">", "level", ")", ")", "{", "sum", "+=", "sumObjectValues", "(", "value", ",", "depth", ",", "++", "level", ")", ";", "--", "level", ";", "}", "}", "return", "sum", ";", "}" ]

[ "Recursive", "function", "that", "computes", "the", "sum", "of", "all", "numeric", "values", "in", "an", "object" ]