Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "publish", "(", "channel", ",", "...", "args", ")", "{", "_publishStream", ".", "emit", "(", "'message'", ",", "channel", ",", "uniqueId", "(", "`", "${", "node", ".", "name", "}", "`", ")", ",", "...", "args", ")", "}" ]

[ "takes", "a", "list", "of", "strings|buffers", "to", "publish", "as", "message", "s", "frames", "in", "the", "channel", "passed", "as", "first", "argument", ";", "decorates", "each", "message", "with", "a", "uid" ]

[ "function", "Tributary", "(", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "stream", ".", "Transform", ".", "call", "(", "this", ",", "{", "encoding", ":", "options", ".", "encoding", "}", ")", ";", "this", ".", "getStream", "=", "options", ".", "getStream", "||", "function", "(", "filename", ",", "cb", ")", "{", "return", "cb", "(", ")", ";", "}", ";", "this", ".", "_matcher", "=", "new", "Matcher", "(", "options", ".", "placeholderStart", "||", "'<!-- include '", ",", "options", ".", "placeholderEnd", "!==", "undefined", "?", "options", ".", "placeholderEnd", ":", "' -->'", ",", "options", ".", "maxPathLength", ",", "options", ".", "delimiter", ")", ";", "this", ".", "_tributaryState", "=", "{", "chunk", ":", "null", ",", "cursor", ":", "0", ",", "contentStart", ":", "0", ",", "contentEnd", ":", "-", "1", ",", "remainder", ":", "0", "}", ";", "}" ]

[ "Include", "one", "stream", "in", "another" ]

[ "function", "MysqlTransit", "(", "dbOriginal", ",", "dbTemp", ",", "connectionParameters", ")", "{", "this", ".", "dbOriginal", "=", "dbOriginal", ";", "this", ".", "dbTemp", "=", "dbTemp", ";", "this", ".", "connectionParameters", "=", "connectionParameters", ";", "this", ".", "queryQueue", "=", "[", "]", ";", "this", ".", "tablesToDrop", "=", "[", "]", ";", "this", ".", "tablesToCreate", "=", "[", "]", ";", "this", ".", "interactive", "=", "true", ";", "return", "this", ".", "_init", "(", ")", ";", "}" ]

[ "Initialize", "the", "MysqlTransit", "object" ]

[ "function", "joint", "(", "streams", ")", "{", "if", "(", "!", "(", "streams", "instanceof", "Array", ")", ")", "{", "streams", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "}", "return", "streams", ".", "reduce", "(", "function", "(", "thru", ",", "stream", ")", "{", "if", "(", "stream", ")", "{", "thru", ".", "pipe", "(", "stream", ")", ";", "}", "return", "thru", ";", "}", ",", "through", "(", ")", ")", ";", "}" ]

[ "Take", "all", "incoming", "streams", "combine", "them", "into", "a", "single", "through", "stream", ".", "Writing", "to", "the", "returned", "stream", "will", "write", "to", "all", "streams", "passed", "in", "." ]

[ "function", "createNamedClass", "(", "name", ",", "klass", ",", "baseKlass", ",", "superFunc", ")", "{", "if", "(", "!", "superFunc", ")", "{", "superFunc", "=", "function", "(", ")", "{", "baseKlass", ".", "call", "(", "this", ")", ";", "}", ";", "}", "return", "new", "Function", "(", "'klass'", ",", "'superFunc'", ",", "'return function '", "+", "name", "+", "' () {'", "+", "'superFunc.apply(this, arguments);'", "+", "'klass.apply(this, arguments);'", "+", "'};'", ")", "(", "klass", ",", "superFunc", ")", ";", "}" ]

[ "Create", "named", "class", "with", "extends" ]

[ "function", "afterExtends", "(", "klass", ",", "baseKlass", ",", "superFunc", ")", "{", "var", "newKlass", "=", "createNamedClass", "(", "klass", ".", "name", ",", "klass", ",", "baseKlass", ",", "superFunc", ")", ";", "newKlass", ".", "prototype", "=", "createPrototype", "(", "klass", ",", "baseKlass", ",", "newKlass", ")", ";", "return", "newKlass", ";", "}" ]

[ "TypeScript", "extends", "later" ]

[ "function", "processMethodOutTag", "(", "tag", ",", "typeMarkdown", ")", "{", "var", "md", "=", "\"\"", ";", "if", "(", "tag", ".", "type", ")", "{", "md", "+=", "applyMarkdown", "(", "tag", ".", "type", ",", "settings", ".", "get", "(", "typeMarkdown", ")", ")", "+", "\" \"", ";", "}", "md", "+=", "tag", ".", "comment", ";", "return", "md", ";", "}" ]

[ "Process", "either", "a", "return", "or", "throws", "tag", "." ]

[ "function", "encode", "(", "batch", ",", "id", ",", "ver", ")", "{", "//producerId min 2 digits", "let", "producerId", "=", "b36", ".", "int2Str36", "(", "batch", ".", "producerId", ")", ".", "padStart", "(", "2", ",", "'0'", ")", ";", "//producerId min 3 digits", "let", "batchId", "=", "b36", ".", "int2Str36", "(", "batch", ".", "id", ")", ".", "padStart", "(", "3", ",", "'0'", ")", ";", "//id min 2 digits", "id", "=", "b36", ".", "int2Str36", "(", "id", ")", ".", "padStart", "(", "3", ",", "'0'", ")", ";", "let", "msg", "=", "composeCode", "(", "producerId", ",", "batchId", ",", "id", ")", ";", "let", "sign", "=", "sign2Str36", "(", "dsa", ".", "doSign", "(", "batch", ".", "dsa", ",", "batch", ".", "privateKey", ",", "msg", ",", "hash", ".", "vsHash", ")", ")", ";", "let", "codeDescr", "=", "generateCodeDescr", "(", "producerId", ",", "batchId", ",", "id", ",", "sign", ",", "ver", ")", ";", "return", "codeDescr", "?", "(", "codeDescr", "+", "msg", "+", "sign", ")", ":", "''", ";", "}" ]

[ "creates", "alphanum", "representation", "of", "marking", "code" ]

[ "function", "build", "(", "writable", ",", "options", ")", "{", "return", "writable", "&&", "writable", ".", "_ansi2", "||", "(", "writable", ".", "_ansi2", "=", "new", "Ansi", "(", "writable", ",", "options", ")", ")", "}" ]

[ "return", "one", "we", "already", "made", "or", "make", "a", "new", "one" ]

[ "function", "loadAndParseFile", "(", "filename", ",", "settings", ")", "{", "Augmented", ".", "ajax", "(", "{", "url", ":", "filename", ",", "async", ":", "true", ",", "cache", ":", "settings", ".", "cache", ",", "contentType", ":", "'text/plain;charset='", "+", "settings", ".", "encoding", ",", "dataType", ":", "'text'", ",", "success", ":", "function", "(", "data", ",", "status", ")", "{", "logger", ".", "debug", "(", "\"message bundel ajax call - success\"", ")", ";", "parseData", "(", "data", ",", "settings", ".", "mode", ")", ";", "}", ",", "error", ":", "function", "(", "data", ",", "status", ")", "{", "logger", ".", "debug", "(", "\"message bundel ajax call - fail \"", "+", "data", ")", ";", "}", "}", ")", ";", "}" ]

[ "Load", "and", "parse", ".", "properties", "files" ]

[ "function", "(", "array", ")", "{", "var", "sarr", "=", "[", "]", ";", "var", "i", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "array", ".", "length", ";", "i", "++", ")", "{", "var", "a", "=", "array", "[", "i", "]", ";", "var", "o", "=", "{", "}", ";", "o", ".", "name", "=", "a", ".", "name", ";", "o", ".", "value", "=", "a", ".", "value", ";", "o", ".", "type", "=", "a", ".", "type", ";", "if", "(", "a", ".", "type", "===", "\"checkbox\"", ")", "{", "o", ".", "value", "=", "(", "a", ".", "checked", ")", "?", "\"on\"", ":", "\"off\"", ";", "}", "sarr", ".", "push", "(", "o", ")", ";", "}", "return", "sarr", ";", "}" ]

[ "Get", "form", "data", "." ]

[ "function", "success", "(", "domain", ")", "{", "if", "(", "auth0", ")", "{", "//if auth0 then we don't have user storage", "connection", ".", "user", "=", "new", "DomainWrapper", "(", "domain", ")", ";", "connection", ".", "user", ".", "join", "(", ")", ";", "sessionPromise", ".", "then", "(", "resolve", ")", ";", "}", "else", "{", "//if auth1 use user class to wrap domain and implement user storage and load user data", "connection", ".", "user", "=", "new", "User", "(", "self", ",", "domain", ")", ";", "connection", ".", "user", ".", "join", "(", ")", ";", "sessionPromise", ".", "then", "(", "load", ")", ";", "}", "}" ]

[ "if", "we", "get", "success", "from", "the", "registrar", "on", "login", "continue", "depending", "on", "auth", "level" ]

[ "function", "applyModelMethods", "(", "model", ",", "definition", ")", "{", "for", "(", "var", "i", "in", "definition", ".", "methods", ")", "{", "if", "(", "i", "===", "'definition'", ")", "{", "throw", "new", "Error", "(", "'Invalid model definition provided. \"definition\" is a reserved word'", ")", ";", "}", "model", ".", "prototype", "[", "i", "]", "=", "definition", ".", "methods", "[", "i", "]", ";", "}", "}" ]

[ "Used", "in", "setModel" ]

[ "function", "(", "patterns", ",", "options", ")", "{", "var", "self", "=", "this", ";", "if", "(", "!", "(", "typeof", "patterns", "==", "'object'", ")", ")", "{", "throw", "new", "Error", "(", "'ObsRouter constructor expects patterns object as first argument'", ")", "}", "options", "=", "options", "||", "{", "}", ";", "EventEmitter", ".", "call", "(", "self", ")", ";", "if", "(", "process", ".", "browser", ")", "{", "//bind to window by default\r", "self", ".", "_bindToWindow", "=", "'bindToWindow'", "in", "options", "?", "options", ".", "bindToWindow", ":", "true", ";", "if", "(", "self", ".", "_bindToWindow", ")", "{", "// add to module-scoped list of routers\r", "routers", ".", "push", "(", "self", ")", ";", "// override any url input with window location\r", "options", ".", "url", "=", "window", ".", "document", ".", "location", ".", "pathname", "+", "window", ".", "document", ".", "location", ".", "search", ";", "}", "}", "// initialise state\r", "self", ".", "patterns", "=", "patterns", ";", "self", ".", "name", "=", "null", ";", "self", ".", "params", "=", "{", "}", ";", "self", ".", "routes", "=", "{", "}", ";", "_", ".", "forEach", "(", "_", ".", "keys", "(", "self", ".", "patterns", ")", ",", "function", "(", "route", ")", "{", "self", ".", "routes", "[", "route", "]", "=", "null", ";", "}", ")", ";", "// normalise state\r", "self", ".", "_update", "(", "options", ".", "url", "||", "''", ",", "false", ")", ";", "// implement initialEmit option\r", "if", "(", "options", ".", "initialEmit", ")", "{", "var", "cancel", "=", "cancellableNextTick", "(", "function", "(", ")", "{", "self", ".", "_emit", "(", ")", ";", "}", ")", ";", "self", ".", "once", "(", "'url'", ",", "cancel", ")", ";", "}", "}" ]

[ "Mutable", "observable", "abstraction", "of", "url", "as", "route", "with", "parameters" ]

[ "function", "(", "object", ",", "options", ")", "{", "var", "self", "=", "this", ";", "return", "deep", ".", "when", "(", "getSchema", "(", "this", ")", ")", ".", "done", "(", "function", "(", "schema", ")", "{", "return", "deep", ".", "Arguments", "(", "[", "object", ",", "options", "]", ")", ";", "}", ")", ";", "}" ]

[ "retrieve", "Schema", "if" ]

[ "function", "handleConnectionCallback", "(", "err", ",", "resolve", ",", "reject", ",", "key", ",", "connection", ")", "{", "debug", "(", "'handleConnectionCallback'", ",", "'start'", ")", ";", "//error, remove cached entry, reject the promise", "if", "(", "err", ")", "{", "debug", "(", "'handleConnectionCallback'", ",", "'error'", ",", "err", ")", ";", "delete", "promises", "[", "key", "]", ";", "return", "reject", "(", "err", ")", ";", "}", "//patch close method for caching", "shadowClose", "(", "connection", ")", ";", "//create a reference to the original connection for cleanup", "connection", ".", "_mssqlngKey", "=", "key", ";", "//add connection to the pool", "connections", "[", "connection", ".", "_mssqlngKey", "]", "=", "connection", ";", "//resolve the promise", "debug", "(", "'handleConnectionCallback'", ",", "'success'", ")", ";", "return", "resolve", "(", "connection", ")", ";", "}" ]

[ "handle", "promise", "resolution", "for", "connection", "callback" ]

[ "function", "load", "(", "mod", ")", "{", "if", "(", "typeof", "(", "mod", ".", "factory", ")", "===", "\"function\"", ")", "{", "return", "require", "(", "mod", ".", "deps", ",", "mod", ".", "factory", ")", ";", "}", "return", "mod", ".", "factory", ";", "}" ]

[ "Load", "the", "module", "by", "calling", "its", "factory", "with", "the", "appropriate", "dependencies", "if", "at", "all", "possible" ]

[ "function", "handle", "(", "filePath", ")", "{", "var", "file", "=", "toVFile", "(", "filePath", ")", "var", "result", "=", "test", "(", "file", ")", "if", "(", "mask", "(", "result", ",", "INCLUDE", ")", ")", "{", "if", "(", "one", ")", "{", "callback", "(", "null", ",", "file", ")", "return", "true", "}", "results", ".", "push", "(", "file", ")", "}", "if", "(", "mask", "(", "result", ",", "BREAK", ")", ")", "{", "callback", "(", "null", ",", "one", "?", "null", ":", "results", ")", "return", "true", "}", "}" ]

[ "Test", "a", "file", "and", "check", "what", "should", "be", "done", "with", "the", "resulting", "file", "." ]

[ "function", "once", "(", "child", ")", "{", "if", "(", "handle", "(", "current", ")", "===", "true", ")", "{", "return", "}", "readdir", "(", "current", ",", "onread", ")", "function", "onread", "(", "error", ",", "entries", ")", "{", "var", "length", "=", "entries", "?", "entries", ".", "length", ":", "0", "var", "index", "=", "-", "1", "var", "entry", "if", "(", "error", ")", "{", "entries", "=", "[", "]", "}", "while", "(", "++", "index", "<", "length", ")", "{", "entry", "=", "entries", "[", "index", "]", "if", "(", "entry", "!==", "child", "&&", "handle", "(", "resolve", "(", "current", ",", "entry", ")", ")", "===", "true", ")", "{", "return", "}", "}", "child", "=", "current", "current", "=", "dirname", "(", "current", ")", "if", "(", "current", "===", "child", ")", "{", "callback", "(", "null", ",", "one", "?", "null", ":", "results", ")", "return", "}", "once", "(", "basename", "(", "child", ")", ")", "}", "}" ]

[ "Check", "one", "directory", "." ]

[ "function", "generateTransactionRequest", "(", "signer", ",", "transaction", ",", "options", ")", "{", "let", "iou", "=", "{", "amt", ":", "transaction", ".", "amount", ",", "cur", ":", "transaction", ".", "currency", ",", "sub", ":", "signer", ".", "address", ",", "aud", ":", "transaction", ".", "destination", ",", "nce", ":", "String", "(", "Math", ".", "floor", "(", "Math", ".", "random", "(", ")", "*", "1000000000", ")", ")", "}", ";", "return", "createTransactionRequestStatement", "(", "signer", ",", "iou", ",", "options", ")", ";", "}" ]

[ "Generates", "a", "transaction", "request", "document", "in", "the", "form", "of", "an", "IOU" ]

[ "function", "registerWalletAddress", "(", "url", ",", "body", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "url", "=", "resolveURL", "(", "url", ",", "'/address'", ")", ";", "return", "new", "P", "(", "function", "(", "resolve", ",", "reject", ")", "{", "request", "(", "{", "url", ":", "url", ",", "method", ":", "options", ".", "method", "||", "'POST'", ",", "body", ":", "body", ",", "json", ":", "true", ",", "headers", ":", "options", ".", "headers", "}", ",", "function", "(", "err", ",", "res", ",", "body", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "return", "resolve", "(", "body", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Sends", "a", "wallet", "address", "registration", "request", "to", "the", "supplied", "URL" ]

[ "function", "checkAddressBalance", "(", "url", ",", "address", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "let", "path", "=", "'/address/.../balance'", ".", "replace", "(", "'...'", ",", "address", ")", ";", "url", "=", "resolveURL", "(", "url", ",", "path", ")", ";", "return", "new", "P", "(", "function", "(", "resolve", ",", "reject", ")", "{", "request", "(", "{", "url", ":", "url", ",", "method", ":", "'GET'", ",", "headers", ":", "options", ".", "headers", "}", ",", "function", "(", "err", ",", "res", ",", "body", ")", "{", "if", "(", "err", ")", "return", "reject", "(", "err", ")", ";", "return", "resolve", "(", "body", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Checks", "the", "balance", "of", "a", "wallet", "address" ]

[ "function", "generateKeyPair", "(", "scheme", ")", "{", "let", "keypair", ";", "let", "keys", ";", "switch", "(", "scheme", ")", "{", "case", "'ed25519'", ":", "case", "'secp256k1'", ":", "keypair", "=", "schemes", "[", "scheme", "]", ".", "genKeyPair", "(", ")", ";", "keys", "=", "{", "scheme", ":", "scheme", ",", "private", ":", "keypair", ".", "getPrivate", "(", "'hex'", ")", ",", "public", ":", "keypair", ".", "getPublic", "(", "'hex'", ")", "}", ";", "break", ";", "default", ":", "throw", "new", "Error", "(", "'invalid-scheme'", ")", ";", "break", ";", "}", "return", "keys", ";", "}" ]

[ "Generates", "a", "pair", "of", "cryptographic", "keys" ]

[ "function", "deriveWalletAddress", "(", "publicKey", ",", "type", ")", "{", "let", "keyBuffer", "=", "new", "Buffer", "(", "publicKey", ",", "'hex'", ")", ";", "let", "firstHash", "=", "crypto", ".", "createHash", "(", "'sha256'", ")", ".", "update", "(", "keyBuffer", ")", ".", "digest", "(", ")", ";", "let", "secondHash", "=", "ripemd160", "(", "firstHash", ")", ";", "let", "extendedHash", "=", "(", "type", "===", "'issuer'", "?", "'57'", ":", "'87'", ")", "+", "secondHash", ".", "toString", "(", "'hex'", ")", ";", "let", "base58Public", "=", "bs58check", ".", "encode", "(", "new", "Buffer", "(", "extendedHash", ",", "'hex'", ")", ")", ";", "return", "base58Public", ";", "}" ]

[ "Derives", "a", "wallet", "address", "from", "a", "public", "key" ]

[ "function", "createAddressRegistrationStatement", "(", "address", ",", "keys", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "/* Create an extended JSON Web Signatures object */", "let", "jws", "=", "{", "hash", ":", "{", "type", ":", "(", "hashes", ".", "indexOf", "(", "options", ".", "hash", ")", ">", "-", "1", ")", "?", "options", ".", "hash", ":", "'sha256'", ",", "value", ":", "''", "}", ",", "payload", ":", "{", "address", ":", "address", ",", "keys", ":", "[", "keys", ".", "public", "]", ",", "threshold", ":", "1", "}", ",", "signatures", ":", "[", "{", "header", ":", "{", "alg", ":", "keys", ".", "scheme", ",", "kid", ":", "'0'", "}", ",", "signature", ":", "''", "}", "]", "}", ";", "/* Generate a cryptogrphic hash of the payload */", "jws", ".", "hash", ".", "value", "=", "crypto", ".", "createHash", "(", "jws", ".", "hash", ".", "type", ")", ".", "update", "(", "JSON", ".", "stringify", "(", "jws", ".", "payload", ")", ")", ".", "digest", "(", "'hex'", ")", ";", "/* Sign the hash of the payload */", "jws", ".", "signatures", "[", "0", "]", ".", "signature", "=", "schemes", "[", "keys", ".", "scheme", "]", ".", "sign", "(", "jws", ".", "hash", ".", "value", ",", "keys", ".", "private", ",", "'hex'", ")", ".", "toDER", "(", "'hex'", ")", ";", "return", "jws", ";", "}" ]

[ "Creates", "and", "signs", "a", "statement", "to", "be", "sent", "for", "registering", "an", "address" ]

[ "function", "resolveURL", "(", "url", ",", "path", ")", "{", "if", "(", "typeof", "url", "!==", "'string'", "||", "typeof", "path", "!==", "'string'", ")", "{", "return", "new", "Error", "(", "'url-and-path-required'", ")", ";", "}", "/* Remove leading and duplicate slashes */", "url", "=", "url", ".", "replace", "(", "/", "\\/{2,}", "/", "g", ",", "'/'", ")", ".", "replace", "(", "/", "^\\/", "/", ",", "''", ")", ".", "replace", "(", "':/'", ",", "'://'", ")", ";", "let", "parsedUrl", "=", "urlModule", ".", "parse", "(", "url", ")", ";", "if", "(", "protocols", ".", "indexOf", "(", "parsedUrl", ".", "protocol", ")", "<", "0", "||", "!", "parsedUrl", ".", "host", ")", "{", "return", "new", "Error", "(", "'invalid-url'", ")", ";", "}", "let", "resolvedUrl", "=", "urlModule", ".", "resolve", "(", "parsedUrl", ".", "href", ",", "path", ")", ";", "return", "resolvedUrl", ";", "}" ]

[ "Resolves", "a", "URL", "given", "a", "path" ]

[ "function", "merge", "(", "target", ",", "source", ")", "{", "if", "(", "source", "===", "null", ")", "{", "return", "target", "}", "var", "props", "=", "Object", ".", "getOwnPropertyNames", "(", "target", ")", "props", ".", "forEach", "(", "function", "(", "name", ")", "{", "var", "s", "=", "gettype", "(", "source", "[", "name", "]", ")", "if", "(", "s", "!==", "'undefined'", ")", "{", "var", "t", "=", "gettype", "(", "target", "[", "name", "]", ")", "if", "(", "t", "!==", "s", ")", "{", "throw", "new", "Error", "(", "`", "${", "t", "}", "${", "s", "}", "${", "name", "}", "`", ")", "}", "if", "(", "t", "===", "'object'", ")", "{", "merge", "(", "target", "[", "name", "]", ",", "source", "[", "name", "]", ")", "}", "else", "{", "target", "[", "name", "]", "=", "source", "[", "name", "]", "}", "}", "}", ")", "return", "target", "}" ]

[ "Merges", "the", "source", "with", "the", "target", ".", "The", "target", "is", "modified", "and", "returned", "." ]

[ "function", "findIndexInArray", "(", "array", ",", "callback", ")", "{", "var", "_length", "=", "array", ".", "length", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "_length", ";", "i", "++", ")", "{", "if", "(", "callback", "(", "array", "[", "i", "]", ")", ")", "return", "i", ";", "}", "return", "-", "1", ";", "}" ]

[ "Find", "position", "of", "an", "array", "element", "when", "callback", "function", "return", "true", "." ]

[ "function", "replaceInArray", "(", "array", ",", "indexToReplace", ",", "indexToInsert", ")", "{", "var", "_removedArray", "=", "array", ".", "splice", "(", "indexToReplace", ",", "1", ")", ";", "array", ".", "splice", "(", "indexToInsert", ",", "0", ",", "_removedArray", "[", "0", "]", ")", ";", "return", "array", ";", "}" ]

[ "Remove", "item", "by", "its", "index", "and", "place", "it", "to", "another", "position" ]

[ "function", "getArrayOfPartials", "(", ")", "{", "var", "_partialsArr", "=", "[", "]", ";", "for", "(", "var", "file", "in", "mainPartialList", ")", "{", "if", "(", "mainPartialList", ".", "hasOwnProperty", "(", "file", ")", ")", "{", "_partialsArr", ".", "push", "(", "file", ")", ";", "}", "}", "return", "_partialsArr", ";", "}" ]

[ "Get", "array", "of", "partial", "names", "from", "mainPartialList" ]

[ "function", "parseFile", "(", "importKeyword", ",", "requiresKeyword", ",", "filePath", ")", "{", "var", "_lines", "=", "grunt", ".", "file", ".", "read", "(", "filePath", ")", ".", "split", "(", "NEW_LINE", ")", ",", "_values", "=", "{", "imports", ":", "{", "}", ",", "requires", ":", "{", "}", "}", ";", "// Search for keywords in file", "for", "(", "var", "i", "=", "_lines", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "var", "line", "=", "_lines", "[", "i", "]", ";", "if", "(", "line", ".", "indexOf", "(", "importKeyword", ")", "!==", "-", "1", ")", "{", "// get import value", "var", "_importValue", "=", "line", ".", "match", "(", "/", "(\"|')(.*?)(\"|')", "/", ")", "[", "2", "]", ";", "// Create full path to help looking for file and minimalize", "// errors if there are duplicated filenames", "_importValue", "=", "Path", ".", "join", "(", "Path", ".", "dirname", "(", "filePath", ")", ",", "_importValue", ".", "sassToPath", "(", ")", ")", ";", "// Windows support. Replace backslashes into slashes.", "_importValue", "=", "_importValue", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "\"/\"", ")", ";", "// Append new import value to list", "_values", ".", "imports", "[", "'import'", "+", "i", "]", "=", "_importValue", ";", "}", "if", "(", "line", ".", "indexOf", "(", "requiresKeyword", ")", "!==", "-", "1", ")", "{", "// get require value", "var", "_requireValue", "=", "line", ".", "match", "(", "/", "(\"|')(.*?)(\"|')", "/", ")", "[", "2", "]", ";", "// Create new dependency object", "var", "_requireObject", "=", "{", "requires", ":", "_requireValue", ".", "sassToPath", "(", ")", ",", "fileName", ":", "filePath", "}", ";", "// Append new require value to list", "_values", ".", "requires", "[", "'require'", "+", "i", "]", "=", "_requireObject", ";", "}", "}", "return", "_values", ";", "}" ]

[ "Parses", "the", "given", "file", "for", "import", "keywords", "and", "DI", "keywords" ]

[ "function", "orderByDependency", "(", "partialsArray", ")", "{", "var", "_doPass", "=", "true", ",", "_reqCache", "=", "{", "}", ";", "// repeat sorting operation until", "// there is no replacing procedure during", "// one pass (bubble sorting).", "while", "(", "_doPass", ")", "{", "_doPass", "=", "false", ";", "// Iterate through every partial in the list and check its", "// dependency (requirements)", "partialsArray", ".", "forEach", "(", "function", "(", "partialName", ",", "partialIndex", ")", "{", "// Get require list for current partial", "var", "_requireList", "=", "mainPartialList", "[", "partialName", "]", ".", "requires", ";", "// for each requirement in require object do...", "for", "(", "var", "rKey", "in", "_requireList", ")", "{", "// Check if current key is _requireList property", "if", "(", "!", "_requireList", ".", "hasOwnProperty", "(", "rKey", ")", ")", "{", "// if not go to next iteration", "continue", ";", "}", "// Current partial filename without root folder", "var", "_fileName", "=", "mainPartialList", "[", "partialName", "]", ".", "removedRoot", ",", "// Index of current partial in partialsArray, -1 if not found.", "_requireIndex", "=", "findIndexInArray", "(", "partialsArray", ",", "function", "(", "partialName", ")", "{", "return", "(", "partialName", ".", "match", "(", "_requireList", "[", "rKey", "]", ".", "requires", ")", "!==", "null", ")", ";", "}", ")", ",", "_requireObject", "=", "_requireList", "[", "rKey", "]", ";", "// Check require cache for dependency loop", "if", "(", "_reqCache", "[", "_requireObject", ".", "requires", "+", "_fileName", "]", ")", "{", "// dependency loop detected, throw an error and break program", "grunt", ".", "fail", ".", "fatal", "(", "'Dependency loop detected!!! \\nFiles that have dependency loop: \\n'", "+", "mainPartialList", "[", "partialsArray", "[", "_requireIndex", "]", "]", ".", "fileName", "+", "'\\n'", "+", "_requireObject", ".", "fileName", ")", ";", "}", "// If requirement is found and its position is incorrect", "if", "(", "_requireIndex", ">", "-", "1", "&&", "_requireIndex", ">", "partialIndex", ")", "{", "// Remove partial from current index and insert", "// it before partial that requires it.", "partialsArray", "=", "replaceInArray", "(", "partialsArray", ",", "_requireIndex", ",", "partialIndex", ")", ";", "// Replacing procedure occured so do one more pass.", "_doPass", "=", "true", ";", "// add requirement to require cache for dependency loop handling", "_reqCache", "[", "_fileName", "+", "_requireObject", ".", "requires", "]", "=", "true", ";", "}", "else", "if", "(", "_requireIndex", "===", "-", "1", ")", "{", "// invalid requirement, throw a warning", "grunt", ".", "log", ".", "warn", "(", "'File: '", "+", "mainPartialList", "[", "partialName", "]", ".", "fileName", "+", "' is depending on non existing partial \"'", "+", "_requireObject", ".", "requires", "+", "'\"'", ")", ";", "}", "}", "// end for", "}", ")", ";", "// end for each", "}", "// end while", "// Return reordered file list", "return", "partialsArray", ";", "}" ]

[ "Reorders", "partials", "in", "a", "given", "list", "by", "their", "dependencies", ".", "Dependencies", "are", "taken", "from", "mainPartialList", "which", "has", "to", "be", "generated", "first", "." ]

[ "function", "generateBootstrapContent", "(", "partialsArray", ",", "lineDelimiter", ")", "{", "var", "_bootstrapContent", "=", "''", ",", "_folderGroup", "=", "''", ";", "partialsArray", ".", "forEach", "(", "function", "(", "partialName", ")", "{", "var", "_sassPath", "=", "mainPartialList", "[", "partialName", "]", ".", "removedRoot", ",", "_currentRoot", "=", "_sassPath", ".", "parseRootFolder", "(", ")", ";", "if", "(", "options", ".", "useRelativePaths", ")", "{", "// if useRelativePaths option is set to true the result file will use paths relative to bootstrap file", "// in this case filterRootPaths option is not used", "_sassPath", "=", "Path", ".", "relative", "(", "Path", ".", "dirname", "(", "options", ".", "bootstrapFile", ")", ",", "mainPartialList", "[", "partialName", "]", ".", "fileName", ".", "toSassFormat", "(", ")", ")", ";", "// remove file extension", "_sassPath", "=", "_sassPath", ".", "replace", "(", "Path", ".", "extname", "(", "_sassPath", ")", ",", "''", ")", ";", "// Windows support. Replace backslashes into slashes.", "_sassPath", "=", "_sassPath", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "\"/\"", ")", ";", "}", "else", "{", "_sassPath", "=", "_sassPath", ".", "toSassFormat", "(", ")", ";", "}", "// if current root folder has changed, write new root folder", "// as a comment and set new current folder", "if", "(", "_folderGroup", "!=", "_currentRoot", ")", "{", "_bootstrapContent", "+=", "NEW_LINE", "+", "'// '", "+", "_currentRoot", "+", "NEW_LINE", ";", "_folderGroup", "=", "_currentRoot", ";", "}", "// append import line", "_bootstrapContent", "+=", "options", ".", "importKeyword", "+", "' \"'", "+", "_sassPath", "+", "'\"'", "+", "lineDelimiter", "+", "NEW_LINE", ";", "}", ")", ";", "return", "_bootstrapContent", ";", "}" ]

[ "Generate", "content", "for", "bootstrap", "file" ]

[ "function", "StartableModel", "(", "model", ",", "instance", ")", "{", "if", "(", "!", "model", ")", "{", "throw", "new", "Error", "(", "'model is required'", ")", "}", "if", "(", "!", "instance", ")", "{", "throw", "new", "Error", "(", "'instance is required'", ")", "}", "if", "(", "!", "(", "this", "instanceof", "StartableModel", ")", ")", "{", "return", "new", "StartableModel", "(", "model", ",", "instance", ",", "index", ")", "}", "this", ".", "model", "=", "model", "this", ".", "key", "=", "model", ".", "key", "this", ".", "instance", "=", "instance", "this", ".", "fn", "=", "instance", "[", "model", ".", "startable", "]", "if", "(", "!", "this", ".", "fn", ")", "{", "throw", "new", "Error", "(", "'The instance of '", "+", "this", ".", "key", "+", "' does not have a method '", "+", "model", ".", "startable", "+", "' which is required for starting this service.'", ")", "}", "this", ".", "inject", "=", "(", "this", ".", "fn", ".", "inject", "||", "[", "]", ")", "this", ".", "hasDeps", "=", "(", "this", ".", "inject", ".", "length", ">", "0", ")", "}" ]

[ "Encapsulate", "a", "startable", "function", "description" ]

[ "function", "fail", "(", "err", ",", "status", "=", "1", ")", "{", "console", ".", "log", "(", "process", ".", "env", ".", "DEBUG", "?", "err", ".", "stack", ":", "err", ".", "message", ")", ";", "process", ".", "exit", "(", "status", ")", ";", "}" ]

[ "Print", "error", "and", "exit", "." ]

[ "function", "autoSpliceLaunchArray", "(", "LaunchArray", ",", "TypeKey", ")", "{", "var", "indFirstElement", "=", "currentPromiseArrays", "[", "TypeKey", "]", ".", "indexOf", "(", "LaunchArray", "[", "0", "]", ")", ";", "var", "indLastElement", "=", "currentPromiseArrays", "[", "TypeKey", "]", ".", "indexOf", "(", "LaunchArray", "[", "LaunchArray", ".", "length", "-", "1", "]", ")", ";", "Promise", ".", "all", "(", "LaunchArray", ".", "map", "(", "e", "=>", "{", "return", "e", ".", "result", "}", ")", ")", ".", "then", "(", "(", ")", "=>", "{", "currentPromiseArrays", "[", "TypeKey", "]", ".", "splice", "(", "indFirstElement", ",", "indLastElement", ")", ";", "}", ",", "err", "=>", "{", "currentPromiseArrays", "[", "TypeKey", "]", ".", "splice", "(", "indFirstElement", ",", "indLastElement", ")", ";", "}", ")", ";", "}" ]

[ "As", "the", "stack", "in", "currentPromiseArrays", "might", "get", "very", "long", "and", "slow", "down", "the", "application", "we", "will", "splice", "all", "of", "the", "launchArrays", "already", "completely", "resolved", "out", "of", "the", "currentPromiseArrays", "As", "currentPromiseArrays", "can", "get", "extremely", "large", "and", "we", "want", "to", "keep", "the", "app", "performant", "autoSplice", "will", "automatically", "remove", "a", "LaunchArray", "from", "the", "currentPromiseArrays", "after", "all", "of", "them", "have", "either", "been", "resolved", "or", "one", "is", "rejected" ]

[ "function", "(", "inParams", ",", "inCallbackFunctionName", ")", "{", "if", "(", "enyo", ".", "isString", "(", "inParams", ")", ")", "{", "return", "inParams", ".", "replace", "(", "\"=?\"", ",", "\"=\"", "+", "inCallbackFunctionName", ")", ";", "}", "else", "{", "var", "params", "=", "enyo", ".", "mixin", "(", "{", "}", ",", "inParams", ")", ";", "params", "[", "this", ".", "callbackName", "]", "=", "inCallbackFunctionName", ";", "return", "enyo", ".", "Ajax", ".", "objectToQuery", "(", "params", ")", ";", "}", "}" ]

[ "for", "a", "string", "version", "of", "inParams", "we", "follow", "the", "convention", "of", "replacing", "the", "string", "=", "?", "with", "the", "callback", "name", ".", "For", "the", "more", "common", "case", "of", "inParams", "being", "an", "object", "we", "ll", "add", "a", "argument", "named", "using", "the", "callbackName", "published", "property", "." ]

[ "function", "stupidDirsExist", "(", "dirs", ")", "{", "const", "check", "=", "[", "]", ";", "dirs", ".", "forEach", "(", "(", "dir", ")", "=>", "{", "check", ".", "push", "(", "dirExist", "(", "dir", ")", ")", ";", "}", ")", ";", "return", "Promise", ".", "all", "(", "check", ")", ".", "then", "(", "(", "results", ")", "=>", "{", "// Combine to single object", "return", "dirs", ".", "reduce", "(", "function", "(", "prev", ",", "item", ",", "i", ")", "{", "prev", "[", "item", "]", "=", "!", "!", "results", "[", "i", "]", ";", "return", "prev", ";", "}", ",", "{", "}", ")", ";", "}", ")", ";", "}" ]

[ "Check", "if", "dirs", "exist", "all", "at", "once" ]

[ "function", "dirsExist", "(", "dirs", ")", "{", "if", "(", "0", "===", "dirs", ".", "length", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ")", "=>", "{", "resolve", "(", "{", "}", ")", ";", "}", ")", ";", "}", "// Group dirs by '/' count", "const", "dirsByDepth", "=", "dirs", ".", "reduce", "(", "function", "(", "prev", ",", "curItem", ")", "{", "const", "depth", "=", "curItem", ".", "split", "(", "path", ".", "sep", ")", ".", "length", ";", "(", "prev", "[", "depth", "]", "=", "prev", "[", "depth", "]", "||", "[", "]", ")", ".", "push", "(", "curItem", ")", ";", "return", "prev", ";", "}", ",", "{", "}", ")", ";", "// Extract min depth dirs", "const", "allDepths", "=", "Object", ".", "keys", "(", "dirsByDepth", ")", ".", "map", "(", "Number", ")", ";", "const", "currDepth", "=", "Math", ".", "min", "(", "...", "allDepths", ")", ";", "const", "currDirs", "=", "dirsByDepth", "[", "currDepth", "]", ";", "// Prepare result object", "const", "result", "=", "dirs", ".", "reduce", "(", "function", "(", "prev", ",", "item", ")", "{", "prev", "[", "item", "]", "=", "null", ";", "return", "prev", ";", "}", ",", "{", "}", ")", ";", "// Check if min depth dirs exist", "return", "stupidDirsExist", "(", "currDirs", ")", ".", "then", "(", "(", "localResult", ")", "=>", "{", "Object", ".", "keys", "(", "result", ")", ".", "forEach", "(", "(", "dir", ")", "=>", "{", "if", "(", "null", "!==", "result", "[", "dir", "]", ")", "{", "return", ";", "}", "Object", ".", "keys", "(", "localResult", ")", ".", "forEach", "(", "(", "localDir", ")", "=>", "{", "// Transfer local check result to global \"as is\"", "result", "[", "localDir", "]", "=", "localResult", "[", "localDir", "]", ";", "// Additionally check if we can mark more deeper directories", "// as non-existing", "if", "(", "false", "===", "localResult", "[", "localDir", "]", "&&", "dir", ".", "slice", "(", "0", ",", "localDir", ".", "length", "+", "1", ")", "===", "localDir", "+", "path", ".", "sep", ")", "{", "result", "[", "dir", "]", "=", "false", ";", "}", "}", ")", ";", "}", ")", ";", "// Extract not checked dirs", "const", "restDirs", "=", "dirs", ".", "filter", "(", "(", "dir", ")", "=>", "{", "return", "null", "===", "result", "[", "dir", "]", ";", "}", ")", ";", "return", "dirsExist", "(", "restDirs", ")", ";", "}", ")", ".", "then", "(", "(", "finalResult", ")", "=>", "{", "// Transfer local check result to global \"as is\"", "Object", ".", "keys", "(", "finalResult", ")", ".", "forEach", "(", "(", "finalDir", ")", "=>", "{", "result", "[", "finalDir", "]", "=", "finalResult", "[", "finalDir", "]", ";", "}", ")", ";", "return", "result", ";", "}", ")", ";", "}" ]

[ "Check", "if", "directories", "exist", ".", "Step", "by", "step", ".", "From", "root", "to", "leaves", "." ]

[ "function", "parseASCIIChunk", "(", "workChunk", ")", "{", "var", "data", "=", "(", "0", ",", "_utils", ".", "ensureString", ")", "(", "workChunk", ")", ";", "// console.log('parseASCII')", "var", "result", "=", "void", "0", ",", "text", "=", "void", "0", ";", "var", "patternNormal", "=", "/", "normal[\\s]+([\\-+]?[0-9]+\\.?[0-9]*([eE][\\-+]?[0-9]+)?)+[\\s]+([\\-+]?[0-9]*\\.?[0-9]+([eE][\\-+]?[0-9]+)?)+[\\s]+([\\-+]?[0-9]*\\.?[0-9]+([eE][\\-+]?[0-9]+)?)+", "/", "g", ";", "var", "patternVertex", "=", "/", "vertex[\\s]+([\\-+]?[0-9]+\\.?[0-9]*([eE][\\-+]?[0-9]+)?)+[\\s]+([\\-+]?[0-9]*\\.?[0-9]+([eE][\\-+]?[0-9]+)?)+[\\s]+([\\-+]?[0-9]*\\.?[0-9]+([eE][\\-+]?[0-9]+)?)+", "/", "g", ";", "var", "patternFace", "=", "/", "facet([\\s\\S]*?)endfacet", "/", "g", ";", "var", "posArray", "=", "[", "]", ";", "var", "normArray", "=", "[", "]", ";", "var", "faces", "=", "0", ";", "var", "offset", "=", "0", ";", "while", "(", "(", "result", "=", "patternFace", ".", "exec", "(", "data", ")", ")", "!==", "null", ")", "{", "var", "length", "=", "0", ";", "text", "=", "result", "[", "0", "]", ";", "offset", "=", "result", ".", "index", "+", "text", ".", "length", ";", "while", "(", "(", "result", "=", "patternNormal", ".", "exec", "(", "text", ")", ")", "!==", "null", ")", "{", "normArray", ".", "push", "(", "parseFloat", "(", "result", "[", "1", "]", ")", ",", "parseFloat", "(", "result", "[", "3", "]", ")", ",", "parseFloat", "(", "result", "[", "5", "]", ")", ")", ";", "normArray", ".", "push", "(", "parseFloat", "(", "result", "[", "1", "]", ")", ",", "parseFloat", "(", "result", "[", "3", "]", ")", ",", "parseFloat", "(", "result", "[", "5", "]", ")", ")", ";", "normArray", ".", "push", "(", "parseFloat", "(", "result", "[", "1", "]", ")", ",", "parseFloat", "(", "result", "[", "3", "]", ")", ",", "parseFloat", "(", "result", "[", "5", "]", ")", ")", ";", "}", "while", "(", "(", "result", "=", "patternVertex", ".", "exec", "(", "text", ")", ")", "!==", "null", ")", "{", "posArray", ".", "push", "(", "parseFloat", "(", "result", "[", "1", "]", ")", ",", "parseFloat", "(", "result", "[", "3", "]", ")", ",", "parseFloat", "(", "result", "[", "5", "]", ")", ")", ";", "length", "+=", "1", ";", "}", "faces", "+=", "1", ";", "}", "var", "positions", "=", "new", "Float32Array", "(", "faces", "*", "3", "*", "3", ")", ";", "var", "normals", "=", "new", "Float32Array", "(", "faces", "*", "3", "*", "3", ")", ";", "positions", ".", "set", "(", "posArray", ")", ";", "normals", ".", "set", "(", "normArray", ")", ";", "// compute offsets, remainderData etc for next chunk etc", "var", "remainderTextData", "=", "data", ".", "slice", "(", "offset", ")", ";", "// console.log('remainderData', remainderTextData)", "var", "remainderData", "=", "new", "Buffer", "(", "remainderTextData", ")", ";", "return", "{", "faceOffset", ":", "faces", ",", "remainderData", ":", "remainderData", ",", "positions", ":", "positions", ",", "normals", ":", "normals", "}", ";", "}" ]

[ "ASCII", "stl", "parsing" ]

[ "function", "(", "value", ")", "{", "var", "res", ";", "if", "(", "this", ".", "has", "(", "value", ")", ")", "{", "res", "=", "this", ".", "items", ".", "splice", "(", "x", ".", "indexOf", "(", "this", ".", "items", ",", "value", ")", ",", "1", ")", ";", "}", "return", "res", ";", "}" ]

[ "Removes", "value", "from", "Set" ]

[ "function", "(", "callback", ")", "{", "for", "(", "var", "i", "=", "0", ",", "l", "=", "this", ".", "items", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "callback", "(", "this", ".", "items", "[", "i", "]", ",", "i", ",", "this", ".", "items", ")", ";", "}", "return", "this", ";", "}" ]

[ "Iterates", "through", "values", "and", "void", "callback" ]

[ "function", "argv", "(", "k", ")", "{", "if", "(", "!", "nargv", ")", "{", "nargv", "=", "process", ".", "argv", ".", "slice", "(", "0", ",", "2", ")", ";", "}", "var", "v", "=", "''", ",", "m", "=", "null", ";", "var", "x", "=", "new", "RegExp", "(", "k", "+", "regexKeyVal", ".", "source", ")", ";", "nargv", ".", "every", "(", "function", "(", "e", ")", "{", "m", "=", "e", ".", "match", "(", "x", ")", ";", "if", "(", "m", "&&", "m", ".", "length", ")", "{", "v", "=", "m", "[", "0", "]", ";", "return", "false", ";", "}", "}", ")", ";", "return", "v", ";", "}" ]

[ "find", "via", "node", "CLI", "argument", "in", "the", "format", "key", "=", "value" ]

[ "function", "clone", "(", "c", ",", "wl", ",", "bl", ")", "{", "var", "cl", "=", "{", "}", ",", "cp", ",", "t", ";", "for", "(", "var", "keys", "=", "Object", ".", "keys", "(", "c", ")", ",", "l", "=", "0", ";", "l", "<", "keys", ".", "length", ";", "l", "++", ")", "{", "cp", "=", "c", "[", "keys", "[", "l", "]", "]", ";", "if", "(", "bl", "&&", "bl", ".", "indexOf", "(", "cp", ")", ">=", "0", ")", "{", "continue", ";", "}", "if", "(", "Array", ".", "isArray", "(", "cp", ")", ")", "{", "cl", "[", "keys", "[", "l", "]", "]", "=", "cp", ".", "slice", "(", "0", ")", ";", "}", "else", "if", "(", "(", "t", "=", "typeof", "cp", ")", "===", "'function'", ")", "{", "if", "(", "!", "wl", "||", "wl", ".", "indexOf", "(", "cp", ")", ">=", "0", ")", "{", "cl", "[", "keys", "[", "l", "]", "]", "=", "cp", ";", "// cp.bind(cp);", "}", "}", "else", "if", "(", "cp", "==", "null", "||", "t", "===", "'string'", "||", "t", "===", "'number'", "||", "t", "===", "'boolean'", "||", "util", ".", "isRegExp", "(", "cp", ")", "||", "util", ".", "isDate", "(", "cp", ")", "||", "util", ".", "isError", "(", "cp", ")", ")", "{", "cl", "[", "keys", "[", "l", "]", "]", "=", "cp", ";", "}", "else", "if", "(", "t", "!==", "'undefined'", ")", "{", "cl", "[", "keys", "[", "l", "]", "]", "=", "clone", "(", "cp", ",", "wl", ",", "bl", ")", ";", "}", "}", "return", "cl", ";", "}" ]

[ "Clones", "an", "object" ]

[ "function", "pkgPropUpd", "(", "pd", ",", "u", ",", "n", ",", "r", ")", "{", "var", "v", "=", "null", ";", "if", "(", "u", "&&", "pd", ".", "oldVer", "!==", "self", ".", "version", "&&", "self", ".", "version", ")", "{", "v", "=", "self", ".", "version", ";", "}", "else", "if", "(", "n", "&&", "pd", ".", "oldVer", "!==", "self", ".", "next", ".", "version", "&&", "self", ".", "next", ".", "version", ")", "{", "v", "=", "self", ".", "next", ".", "version", ";", "}", "else", "if", "(", "r", "&&", "self", ".", "prev", ".", "version", ")", "{", "v", "=", "self", ".", "prev", ".", "version", ";", "}", "pd", ".", "version", "=", "v", ";", "if", "(", "v", "&&", "!", "pd", ".", "props", ")", "{", "pd", ".", "pkg", ".", "version", "=", "v", ";", "pd", ".", "propChangeCount", "++", ";", "}", "if", "(", "pd", ".", "props", "&&", "pd", ".", "pkgParent", ")", "{", "pd", ".", "props", ".", "forEach", "(", "function", "pkgProp", "(", "p", ")", "{", "if", "(", "pd", ".", "pkgParent", "[", "p", "]", "&&", "(", "!", "pd", ".", "pkg", "[", "p", "]", "||", "pd", ".", "pkgParent", "[", "p", "]", "!==", "pd", ".", "pkg", "[", "p", "]", ")", ")", "{", "// sync parent package property with the current one", "pd", ".", "pkg", "[", "p", "]", "=", "pd", ".", "pkgParent", "[", "p", "]", ";", "pd", ".", "propChangeCount", "++", ";", "}", "}", ")", ";", "}", "return", "v", ";", "}" ]

[ "updates", "the", "package", "version", "or", "a", "set", "of", "properties", "from", "a", "parent", "package", "for", "a", "given", "package", "data", "element", "and", "flag" ]

[ "function", "vmtchs", "(", "start", ",", "end", ",", "skips", ")", "{", "var", "s", "=", "''", ";", "for", "(", "var", "i", "=", "start", ";", "i", "<=", "end", ";", "i", "++", ")", "{", "if", "(", "skips", "&&", "skips", ".", "indexOf", "(", "i", ")", ">=", "0", ")", "{", "continue", ";", "}", "s", "+=", "self", ".", "versionMatch", "[", "i", "]", "||", "''", ";", "}", "return", "s", ";", "}" ]

[ "reconstructs", "the", "version", "matches" ]

[ "function", "buildHelpContents", "(", ")", "{", "var", "pageTpl", "=", "'<div class=\"cke_accessibility_legend\" role=\"document\" aria-labelledby=\"'", "+", "id", "+", "'_arialbl\" tabIndex=\"-1\">%1</div>'", "+", "'<span id=\"'", "+", "id", "+", "'_arialbl\" class=\"cke_voice_label\">'", "+", "lang", ".", "contents", "+", "' </span>'", ",", "sectionTpl", "=", "'<h1>%1</h1><dl>%2</dl>'", ",", "itemTpl", "=", "'<dt>%1</dt><dd>%2</dd>'", ";", "var", "pageHtml", "=", "[", "]", ",", "sections", "=", "lang", ".", "legend", ",", "sectionLength", "=", "sections", ".", "length", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "sectionLength", ";", "i", "++", ")", "{", "var", "section", "=", "sections", "[", "i", "]", ",", "sectionHtml", "=", "[", "]", ",", "items", "=", "section", ".", "items", ",", "itemsLength", "=", "items", ".", "length", ";", "for", "(", "var", "j", "=", "0", ";", "j", "<", "itemsLength", ";", "j", "++", ")", "{", "var", "item", "=", "items", "[", "j", "]", ",", "itemLegend", "=", "item", ".", "legend", ".", "replace", "(", "variablesPattern", ",", "replaceVariables", ")", ";", "// (#9765) If some commands haven't been replaced in the legend,\r", "// most likely their keystrokes are unavailable and we shouldn't include\r", "// them in our help list.\r", "if", "(", "itemLegend", ".", "match", "(", "variablesPattern", ")", ")", "continue", ";", "sectionHtml", ".", "push", "(", "itemTpl", ".", "replace", "(", "'%1'", ",", "item", ".", "name", ")", ".", "replace", "(", "'%2'", ",", "itemLegend", ")", ")", ";", "}", "pageHtml", ".", "push", "(", "sectionTpl", ".", "replace", "(", "'%1'", ",", "section", ".", "name", ")", ".", "replace", "(", "'%2'", ",", "sectionHtml", ".", "join", "(", "''", ")", ")", ")", ";", "}", "return", "pageTpl", ".", "replace", "(", "'%1'", ",", "pageHtml", ".", "join", "(", "''", ")", ")", ";", "}" ]

[ "Create", "the", "help", "list", "directly", "from", "lang", "file", "entries", "." ]

[ "function", "getArguments", "(", "f", ",", "amended", ")", "{", "var", "functionCode", "=", "f", ".", "toString", "(", ")", ";", "if", "(", "amended", ")", "{", "//This is a fix for when we are passed anonymous functions (which are passed to us as unassigned)", "//ex: \"function (a, b, c) { }\"", "//These are actually parse errors so we'll try adding an assignment to fix the parse error", "functionCode", "=", "'var a='", "+", "functionCode", ";", "}", "try", "{", "var", "ast", "=", "babylon", ".", "parse", "(", "functionCode", ")", ";", "var", "functionDecl", "=", "findFunctionDecl", "(", "ast", ")", ";", "if", "(", "!", "functionDecl", ")", "return", "[", "]", ";", "return", "functionDecl", ".", "params", ".", "map", "(", "p", "=>", "p", ".", "name", ")", ";", "}", "catch", "(", "e", ")", "{", "//try one more time", "if", "(", "!", "amended", ")", "{", "return", "getArguments", "(", "f", ",", "true", ")", ";", "}", "throw", "new", "Error", "(", "'Could not parse:\\n'", "+", "functionCode", "+", "'\\n'", "+", "e", ")", ";", "}", "}" ]

[ "Get", "the", "parameter", "names", "of", "a", "function", "." ]

[ "function", "runChromedriver", "(", "location", ",", "remote", ",", "options", ")", "{", "assert", "(", "remote", "===", "'chromedriver'", ",", "'expected remote to be chromedriver'", ")", ";", "if", "(", "!", "options", ".", "chromedriverStarted", ")", "{", "chromedriver", ".", "start", "(", ")", ";", "}", "var", "throttle", "=", "options", ".", "throttle", "||", "function", "(", "fn", ")", "{", "return", "fn", "(", ")", ";", "}", ";", "return", "throttle", "(", "function", "(", ")", "{", "return", "runSingleBrowser", "(", "location", ",", "'http://localhost:9515/'", ",", "options", ".", "platform", "||", "options", ".", "capabilities", "||", "{", "}", ",", "{", "name", ":", "options", ".", "name", ",", "debug", ":", "options", ".", "debug", ",", "httpDebug", ":", "options", ".", "httpDebug", ",", "allowExceptions", ":", "options", ".", "allowExceptions", ",", "testComplete", ":", "options", ".", "testComplete", ",", "testPassed", ":", "options", ".", "testPassed", ",", "timeout", ":", "options", ".", "timeout", "}", ")", ";", "}", ")", ".", "then", "(", "function", "(", "result", ")", "{", "if", "(", "!", "options", ".", "keepChromedriverAlive", ")", "{", "chromedriver", ".", "stop", "(", ")", ";", "}", "return", "result", ";", "}", ",", "function", "(", "err", ")", "{", "if", "(", "!", "options", ".", "keepChromedriverAlive", ")", "{", "chromedriver", ".", "stop", "(", ")", ";", "}", "throw", "err", ";", "}", ")", ";", "}" ]

[ "Run", "a", "test", "using", "chromedriver", "then", "stops", "chrome", "driver", "and", "returns", "the", "result" ]

[ "function", "pad", "(", "n", ",", "width", ",", "z", ")", "{", "if", "(", "typeof", "n", "!==", "'string'", ")", "throw", "new", "Error", "(", "'bitString#pad: Need String'", ")", ";", "z", "=", "z", "||", "'0'", ";", "while", "(", "n", ".", "length", "<", "width", ")", "{", "n", "=", "z", "+", "n", ";", "}", "return", "n", ";", "}" ]

[ "Pad", "a", "string", "to", "atleast", "desired", "width" ]

[ "function", "checksum", "(", "bits", ",", "size", ")", "{", "if", "(", "bits", "==", "null", "||", "!", "isValid", "(", "bits", ")", ")", "throw", "new", "Error", "(", "'bitString#checksum: Need valid bits'", ")", ";", "if", "(", "size", "==", "null", "||", "size", "%", "2", "!==", "0", ")", "throw", "new", "Error", "(", "'bitString#checksum: size needs to be even'", ")", ";", "var", "sumA", "=", "0", ",", "sumB", "=", "0", ",", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "bits", ".", "length", ";", "i", "++", ")", "{", "sumA", "=", "(", "sumA", "+", "parseInt", "(", "bits", "[", "i", "]", ",", "2", ")", ")", "%", "size", ";", "sumB", "=", "(", "sumB", "+", "sumA", ")", "%", "size", ";", "}", "return", "pad", "(", "sumB", ".", "toString", "(", "2", ")", ",", "size", "/", "2", ")", "+", "pad", "(", "sumA", ".", "toString", "(", "2", ")", ",", "size", "/", "2", ")", ";", "}" ]

[ "Fletcher", "s", "checksum", "on", "a", "bitstring" ]

[ "function", "randomBits", "(", "n", ")", "{", "if", "(", "typeof", "n", "!==", "'number'", ")", "throw", "new", "Error", "(", "'bitString#randomBits: Need number'", ")", ";", "var", "buf", "=", "_randomBytes", "(", "Math", ".", "ceil", "(", "n", "/", "8", ")", ")", ",", "bits", "=", "''", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "bits", "+=", "(", "buf", "[", "Math", ".", "floor", "(", "i", "/", "8", ")", "]", "&", "(", "0x01", "<<", "(", "i", "%", "8", ")", ")", ")", "?", "'1'", ":", "'0'", ";", "}", "return", "bits", ";", "}" ]

[ "Get", "n", "random", "bits", "Get", "N", "randomBits", "as", "bitstring" ]

[ "function", "createFormatChangelog", "(", "inPath", ")", "{", "if", "(", "!", "inPath", ")", "{", "throw", "new", "Error", "(", "'Input path argument is required'", ")", ";", "}", "return", "function", "formatChangelog", "(", ")", "{", "return", "gulp", ".", "src", "(", "inPath", ")", "// Replace all version compare links.", ".", "pipe", "(", "replace", "(", "/", "\\(http.*\\) ", "/", "g", ",", "' '", ")", ")", "// Replace all commit links.", ".", "pipe", "(", "replace", "(", "/", " \\(\\[.*", "/", "g", ",", "''", ")", ")", ".", "pipe", "(", "gulp", ".", "dest", "(", "file", "=>", "file", ".", "base", ")", ")", ";", "}", ";", "}" ]

[ "Higher", "order", "function", "to", "create", "gulp", "function", "that", "strips", "links", "to", "the", "git", "repository", "from", "changelogs", "generated", "by", "conventional", "changelog", "." ]

[ "function", "(", "parts", ")", "{", "var", "urls", "=", "[", "]", ";", "var", "start", "=", "''", ";", "// If the first part is empty", "// the original path begins with a slash so we", "// do that, too", "if", "(", "_", ".", "isEmpty", "(", "parts", "[", "0", "]", ")", ")", "{", "start", "=", "'/'", ";", "urls", "[", "0", "]", "=", "'/'", ";", "// would not be generated in reduce()", "}", "_", ".", "reduce", "(", "parts", ",", "function", "(", "acc", ",", "value", ")", "{", "if", "(", "!", "_", ".", "isString", "(", "value", ")", "||", "_", ".", "isEmpty", "(", "value", ")", ")", "return", "acc", ";", "acc", "+=", "value", ";", "// Push w/out trailing slash", "urls", ".", "push", "(", "acc", ")", ";", "return", "acc", "+", "'/'", ";", "}", ",", "start", ")", ";", "return", "urls", ";", "}" ]

[ "Function", "that", "creates", "a", "list", "of", "parent", "URLs", "for", "a", "given", "relative", "URL", "." ]

[ "function", "(", "urls", ",", "skipMissing", ")", "{", "var", "i", "=", "-", "1", ";", "var", "j", ";", "var", "handlers", "=", "[", "]", ";", "var", "url", ";", "var", "resource", ";", "var", "urlsLength", "=", "urls", ".", "length", ";", "var", "resourcesLength", "=", "this", ".", "_resources", ".", "length", ";", "var", "foundHandler", ";", "// All URLs", "while", "(", "++", "i", "<", "urlsLength", ")", "{", "url", "=", "urls", "[", "i", "]", ";", "foundHandler", "=", "undefined", ";", "// No handler yet", "j", "=", "-", "1", ";", "// All resources", "while", "(", "++", "j", "<", "resourcesLength", ")", "{", "resource", "=", "this", ".", "_resources", "[", "j", "]", ";", "if", "(", "!", "resource", ".", "getPattern", "(", ")", ".", "matches", "(", "url", ")", ")", "continue", ";", "// If this handler does not want to use cascading", "// we remove every handler that might have been executed", "// before it", "if", "(", "false", "===", "resource", ".", "getOption", "(", "'cascading'", ")", ")", "handlers", "=", "[", "]", ";", "handlers", ".", "push", "(", "{", "path", ":", "url", ",", "handler", ":", "resource", "}", ")", ";", "foundHandler", "=", "resource", ";", "break", ";", "}", "// One handler missing? Chain is broken, return an error if required", "if", "(", "_", ".", "isUndefined", "(", "foundHandler", ")", "&&", "!", "skipMissing", ")", "return", "null", ";", "}", "return", "handlers", ";", "}" ]

[ "Finds", "all", "handlers", "for", "the", "given", "URLs", ".", "If", "skipMissing", "is", "false", "null", "will", "be", "returned", "if", "a", "handler", "was", "not", "found", "." ]

[ "function", "(", "resource", ")", "{", "var", "handler", "=", "resource", ".", "handler", ".", "getCallback", "(", "request", ".", "method", ")", ";", "request", ".", "api", ".", "handler", "=", "handler", ";", "request", ".", "path", "=", "resource", ".", "path", ";", "var", "context", "=", "resource", ".", "handler", ".", "getContext", "(", ")", ";", "context", ".", "__espressojs", "=", "{", "chainIsComplete", ":", "chainIsComplete", ",", "// Reference to the currently processed handler", "handler", ":", "resource", ".", "handler", ",", "// Currently processed path", "path", ":", "resource", ".", "path", "}", ";", "return", "context", ";", "}" ]

[ "Helper", "function", "used", "to", "prepare", "the", "handler", "invokation", "Uses", "and", "manipulates", "global", "state", "like", "chainIsComplete", "and", "request", "." ]

[ "function", "setup", "(", "request", ",", "options", ",", "...", "args", ")", "{", "const", "len", "=", "request", ".", "headers", "[", "'content-length'", "]", "const", "encoding", "=", "request", ".", "headers", "[", "'content-encoding'", "]", "||", "'identity'", "return", "Object", ".", "assign", "(", "{", "}", ",", "options", ",", "{", "encoding", ":", "options", ".", "encoding", "||", "'utf-8'", ",", "limit", ":", "options", ".", "limit", "||", "'1mb'", ",", "length", ":", "(", "len", "&&", "encoding", "===", "'identity'", ")", "?", "~", "~", "len", ":", "options", ".", "length", "}", ",", "...", "args", ")", "}" ]

[ "Clone", "and", "setup", "default", "options", "." ]

[ "function", "getRecaptchaResponse", "(", "field", ",", "req", ")", "{", "return", "req", ".", "get", "(", "field", ")", "||", "(", "req", ".", "query", "&&", "req", ".", "query", "[", "field", "]", ")", "||", "(", "req", ".", "body", "&&", "req", ".", "body", "[", "field", "]", ")", "}" ]

[ "Gets", "recaptcha", "response", "from", "request", "." ]

[ "function", "resolveAsync", "(", "p", ",", "base", ",", "root", ")", "{", "if", "(", "!", "path", ".", "isAbsolute", "(", "p", ")", ")", "{", "return", "new", "Promise", "(", "function", "(", "r", ",", "j", ")", "{", "resolve", "(", "forceRelative", "(", "p", ")", ",", "{", "basedir", ":", "path", ".", "resolve", "(", "root", ",", "base", ")", "}", ",", "function", "(", "err", ",", "res", ")", "{", "if", "(", "err", ")", "{", "j", "(", "err", ")", ";", "}", "else", "{", "r", "(", "res", ")", ";", "}", "}", ")", ";", "}", ")", ";", "}", "else", "{", "return", "Promise", ".", "resolve", "(", "p", ")", ";", "}", "}" ]

[ "Resolve", "path", "the", "same", "way", "ans", "postcss", "-", "import" ]

[ "function", "object", "(", "pairs", ")", "{", "let", "obj", "=", "{", "}", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "pairs", ".", "length", ";", "++", "i", ")", "{", "obj", "[", "pairs", "[", "i", "]", "[", "0", "]", "]", "=", "pairs", "[", "i", "]", "[", "1", "]", ";", "}", "return", "obj", ";", "}" ]

[ "Object", "fn", "surrogate" ]

[ "function", "matchToHolders", "(", "match", ",", "tag", ")", "{", "return", "object", "(", "match", ".", "map", "(", "function", "(", "val", ",", "index", ")", "{", "return", "[", "tag", "+", "\":\"", "+", "index", ",", "val", "]", ";", "}", ")", ")", ";", "}" ]

[ "Transform", "regExpr", "exec", "result", "to", "hashmap", "with", "tagged", "keys" ]

[ "function", "filterValidRule", "(", "rule", ")", "{", "return", "(", "rule", ".", "hasOwnProperty", "(", "'match'", ")", "&&", "typeof", "rule", ".", "match", "===", "\"object\"", ")", "&&", "(", "rule", ".", "hasOwnProperty", "(", "'use'", ")", "&&", "(", "typeof", "rule", ".", "use", "===", "\"object\"", "||", "typeof", "rule", ".", "use", "===", "\"function\"", ")", ")", "&&", "(", "(", "rule", ".", "match", ".", "hasOwnProperty", "(", "'request'", ")", ")", "||", "(", "rule", ".", "match", ".", "hasOwnProperty", "(", "'base'", ")", ")", ")", "}" ]

[ "Filter", "rules", "with", "use", "prop" ]

[ "function", "mapDefaults", "(", "rule", ")", "{", "return", "Object", ".", "assign", "(", "{", "}", ",", "rule", ",", "{", "match", ":", "Object", ".", "assign", "(", "{", "request", ":", "defaultExpr", ",", "base", ":", "defaultExpr", ",", "module", ":", "defaultExpr", "}", ",", "rule", ".", "match", ")", ",", "use", ":", "rule", ".", "use", ",", "}", ")", ";", "}" ]

[ "Merge", "with", "defaults" ]

[ "function", "wrapPlaceholders", "(", "placeholders", ")", "{", "const", "keys", "=", "Object", ".", "keys", "(", "placeholders", ")", ";", "const", "wrappedPlaceholders", "=", "{", "}", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "keys", ".", "length", ";", "i", "++", ")", "{", "wrappedPlaceholders", "[", "'<'", "+", "keys", "[", "i", "]", "+", "'>'", "]", "=", "placeholders", "[", "keys", "[", "i", "]", "]", ";", "}", "return", "wrappedPlaceholders", ";", "}" ]

[ "Wrap", "placeholders", "with", "scobes" ]

[ "function", "isRequiresEarlyResolve", "(", "rules", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "rules", ".", "length", ";", "++", "i", ")", "{", "if", "(", "Object", ".", "prototype", ".", "hasOwnProperty", ".", "call", "(", "rules", "[", "i", "]", ",", "'module'", ")", "||", "(", "Object", ".", "prototype", ".", "hasOwnProperty", ".", "call", "(", "rules", "[", "i", "]", ",", "'append'", ")", "&&", "rules", "[", "i", "]", ".", "append", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Search", "module", "in", "rules", "existing" ]

[ "function", "toArray", "(", "id", ")", "{", "if", "(", "!", "isValid", "(", "id", ")", ")", "throw", "new", "Error", "(", "'random#toArray: Need valid id'", ")", ";", "// Decode", "var", "result", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "id", ".", "length", ";", "i", "++", ")", "{", "result", ".", "push", "(", "baseURL", ".", "ALPHABET", ".", "indexOf", "(", "id", "[", "i", "]", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Convert", "a", "random", "id", "to", "Integer", "Array" ]

[ "function", "request", "(", "packet", ",", "json", ")", "{", "return", "_create", "(", "packet", ",", "1", ",", "(", "METHODS", "[", "packet", ".", "method", "]", "||", "''", ")", "+", "packet", ".", "resource", ",", "json", ")", ";", "}" ]

[ "Serialize", "request", "to", "array", "or", "JSON", "." ]

[ "function", "reply", "(", "packet", ",", "json", ")", "{", "return", "_create", "(", "packet", ",", "packet", ".", "status", "||", "500", ",", "(", "METHODS", "[", "packet", ".", "method", "]", "||", "''", ")", "+", "packet", ".", "resource", ",", "json", ")", ";", "}" ]

[ "Serialize", "reply", "to", "array", "or", "JSON", "." ]

[ "function", "(", ")", "{", "var", "date", "=", "new", "Date", "(", ")", ";", "date", ".", "setHours", "(", "0", ",", "0", ",", "0", ")", ";", "date", ".", "setDate", "(", "date", ".", "getDate", "(", ")", "+", "4", "-", "(", "date", ".", "getDay", "(", ")", "||", "7", ")", ")", ";", "return", "Math", ".", "ceil", "(", "(", "(", "(", "date", "-", "new", "Date", "(", "date", ".", "getFullYear", "(", ")", ",", "0", ",", "1", ")", ")", "/", "8.64e7", ")", "+", "1", ")", "/", "7", ")", ";", "}" ]

[ "Get", "current", "week", "number", "." ]

[ "function", "methodQualified", "(", "name", ",", "func", ")", "{", "var", "funcStr", "=", "func", ".", "toString", "(", ")", ";", "// Only public methodds (i.e. methods that do not start with '_') which have", "// 'callback' as last parameter are qualified for thunkification.", "return", "(", "/", "^[^_]", "/", ".", "test", "(", "name", ")", "&&", "/", "function.*\\(.*,?.*callback\\)", "/", ".", "test", "(", "funcStr", ")", ")", ";", "}" ]

[ "Given", "method", "name", "and", "its", "function", "determine", "if", "it", "qualifies", "for", "thunkification", "." ]

[ "function", "registerUserTasks", "(", ")", "{", "var", "tasks", "=", "options", ".", "tasks", ",", "task", "=", "that", ".", "task", ".", "bind", "(", "that", ")", ",", "before", "=", "that", ".", "before", ".", "bind", "(", "that", ")", ",", "after", "=", "that", ".", "after", ".", "bind", "(", "that", ")", ",", "taskName", ";", "// register user tasks", "for", "(", "taskName", "in", "tasks", ")", "{", "if", "(", "tasks", ".", "hasOwnProperty", "(", "taskName", ")", ")", "{", "task", "(", "taskName", ",", "tasks", "[", "taskName", "]", ")", ";", "}", "}", "// register predefined user tasks order", "before", "(", "'deploy'", ",", "'beforeDeploy'", ")", ";", "before", "(", "'updateCode'", ",", "'beforeUpdateCode'", ")", ";", "after", "(", "'updateCode'", ",", "'afterUpdateCode'", ")", ";", "before", "(", "'npm'", ",", "'beforeNpm'", ")", ";", "after", "(", "'npm'", ",", "'afterNpm'", ")", ";", "before", "(", "'createSymlink'", ",", "'beforeCreateSymlink'", ")", ";", "after", "(", "'createSymlink'", ",", "'afterCreateSymlink'", ")", ";", "before", "(", "'restart'", ",", "'beforeRestart'", ")", ";", "after", "(", "'restart'", ",", "'afterRestart'", ")", ";", "after", "(", "'deploy'", ",", "'afterDeploy'", ")", ";", "}" ]

[ "Register", "user", "-", "callbacks", "defined", "tasks" ]

[ "function", "combine", "(", "...", "objects", ")", "{", "inv", "(", "Array", ".", "isArray", "(", "objects", ")", "&&", "objects", ".", "length", ">", "0", ",", "'You must pass at least one object to instantiate'", ")", ";", "inv", "(", "objects", ".", "every", "(", "isObj", ")", ",", "'Expecting only plain objects as parameter(s)'", ")", ";", "return", "assign", "(", "{", "}", ",", "...", "objects", ")", ";", "}" ]

[ "Assign", "one", "or", "more", "objects", "." ]

[ "function", "fetchConfiguration", "(", "environment", ",", "applicationId", ",", "callback", ")", "{", "if", "(", "!", "applicationId", ")", "{", "logger", ".", "error", "(", "\"No application ID specified\"", ")", ";", "return", ";", "}", "var", "deviceDetails", "=", "deviceDetector", ".", "getDeviceDetails", "(", ")", ";", "var", "pathname", "=", "environment", ".", "getPathname", "(", ")", ";", "var", "formFactor", "=", "deviceDetails", ".", "formFactor", ";", "var", "requestUrl", "=", "\"\"", ";", "var", "queryParams", "=", "{", "}", ";", "if", "(", "appSettings", ".", "overrides", "&&", "appSettings", ".", "overrides", ".", "configFileLocation", ")", "{", "requestUrl", "=", "appSettings", ".", "overrides", ".", "configFileLocation", ";", "}", "else", "{", "requestUrl", "=", "appSettings", ".", "configurationsApiUrl", ";", "queryParams", "=", "{", "path", ":", "pathname", ",", "device", ":", "formFactor", ",", "\"application_id\"", ":", "applicationId", "}", ";", "}", "ajax", ".", "get", "(", "{", "url", ":", "requestUrl", ",", "query", ":", "queryParams", ",", "success", ":", "function", "(", "data", ")", "{", "if", "(", "appSettings", ".", "overrides", "&&", "appSettings", ".", "overrides", ".", "configFileLocation", ")", "{", "callback", "(", "null", ",", "data", ".", "adUnits", ")", ";", "}", "else", "{", "callback", "(", "null", ",", "data", ")", ";", "}", "}", ",", "error", ":", "function", "(", "err", ")", "{", "callback", "(", "err", ",", "null", ")", ";", "}", "}", ")", ";", "}" ]

[ "Fetch", "the", "ad", "configurations", "to", "load", "on", "the", "current", "page", "from", "the", "server" ]

[ "function", "write", "(", "src", ",", "lvl", ",", "obj", ")", "{", "var", "stack", "=", "null", ";", "var", "lvlInt", "=", "levels", "[", "lvl", "]", ";", "var", "msg", ";", "if", "(", "typeof", "process", ".", "env", ".", "LOG_LEVEL", "==", "\"string\"", "&&", "levels", "[", "process", ".", "env", ".", "LOG_LEVEL", ".", "toLowerCase", "(", ")", "]", ">", "lvlInt", ")", "{", "return", "false", ";", "}", "if", "(", "process", ".", "env", ".", "JSONCONSOLE_DISABLE_JSON_OUTPUT", ")", "{", "return", "src", ".", "write", "(", "util", ".", "format", "(", "obj", ")", "+", "os", ".", "EOL", ")", ";", "}", "if", "(", "lvlInt", ">=", "40", ")", "{", "if", "(", "obj", "instanceof", "Error", ")", "{", "stack", "=", "obj", ".", "stack", ";", "}", "else", "{", "stack", "=", "new", "Error", "(", ")", ".", "stack", ".", "split", "(", "\"\\n\"", ")", ";", "stack", ".", "splice", "(", "1", ",", "4", ")", ";", "// obfuscate the trace inside the logger.", "stack", "=", "stack", ".", "join", "(", "'\\n'", ")", ";", "}", "}", "if", "(", "obj", "instanceof", "RawValue", ")", "{", "msg", "=", "util", ".", "inspect", "(", "obj", ".", "raw", ")", ";", "}", "else", "if", "(", "typeof", "obj", "==", "\"string\"", ")", "{", "msg", "=", "obj", ";", "}", "else", "{", "msg", "=", "util", ".", "inspect", "(", "obj", ")", ";", "}", "var", "log", "=", "{", "name", ":", "options", ".", "name", ",", "hostname", ",", "pid", ":", "process", ".", "pid", ",", "level", ":", "lvlInt", ",", "msg", ":", "msg", ",", "time", ":", "options", ".", "localDate", "?", "formatLocalDate", "(", ")", ":", "new", "Date", "(", ")", ".", "toISOString", "(", ")", ",", "src", ":", "getCaller3Info", "(", ")", ",", "levelName", ":", "levelNames", "[", "lvlInt", "]", ",", "}", ";", "if", "(", "obj", "instanceof", "RawValue", ")", "{", "log", ".", "raw", "=", "obj", ".", "raw", ";", "}", "stack", "=", "stack", "&&", "options", ".", "root", "?", "stack", ".", "replace", "(", "new", "RegExp", "(", "options", ".", "root", ",", "'g'", ")", ",", "'{root}'", ")", ":", "stack", ";", "if", "(", "stack", ")", "{", "log", ".", "stack", "=", "stack", ";", "}", "log", ".", "v", "=", "options", ".", "v", ";", "log", ".", "src", ".", "r", "=", "options", ".", "root", ";", "return", "src", ".", "write", "(", "JSON", ".", "stringify", "(", "log", ")", "+", "os", ".", "EOL", ")", ";", "}" ]

[ "Write", "JSON", "log", "line", "to", "stderr", "&", "stdout" ]

[ "function", "replace", "(", ")", "{", "if", "(", "!", "isOriginal", ")", "return", ";", "else", "isOriginal", "=", "false", ";", "function", "replaceWith", "(", "fn", ")", "{", "return", "function", "(", ")", "{", "/* eslint prefer-rest-params:0 */", "// todo: once node v4 support dropped, use rest parameter instead", "fn", ".", "apply", "(", "logger", ",", "Array", ".", "from", "(", "arguments", ")", ")", ";", "}", ";", "}", "[", "'log'", ",", "'debug'", ",", "'info'", ",", "'warn'", ",", "'error'", "]", ".", "forEach", "(", "(", "lvl", ")", "=>", "{", "console", "[", "lvl", "]", "=", "function", "(", ")", "{", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ".", "forEach", "(", "(", "arg", ")", "=>", "{", "write", "(", "lvl", "==", "\"error\"", "?", "process", ".", "stderr", ":", "process", ".", "stdout", ",", "lvl", ",", "arg", ")", ";", "}", ")", ";", "}", ";", "}", ")", ";", "}" ]

[ "Replace", "global", "console", "api" ]

[ "function", "restore", "(", ")", "{", "if", "(", "isOriginal", ")", "return", ";", "else", "isOriginal", "=", "true", ";", "[", "'log'", ",", "'debug'", ",", "'info'", ",", "'warn'", ",", "'error'", "]", ".", "forEach", "(", "(", "item", ")", "=>", "{", "console", "[", "item", "]", "=", "originalConsoleFunctions", "[", "item", "]", ";", "}", ")", ";", "}" ]

[ "Restore", "original", "console", "api" ]

[ "function", "setup", "(", "userOptions", ")", "{", "Object", ".", "assign", "(", "options", ",", "userOptions", ")", ";", "/*\n Try to automatically grab the app name from the root directory\n */", "if", "(", "!", "options", ".", "root", ")", "{", "try", "{", "var", "p", "=", "require", "(", "path", ".", "dirname", "(", "process", ".", "mainModule", ".", "filename", ")", "+", "'/package.json'", ")", ";", "options", ".", "root", "=", "path", ".", "dirname", "(", "process", ".", "mainModule", ".", "filename", ")", ";", "options", ".", "name", "=", "p", ".", "name", ";", "}", "catch", "(", "e", ")", "{", "options", ".", "root", "=", "null", ";", "}", "}", "if", "(", "options", ".", "root", "&&", "!", "options", ".", "name", ")", "{", "try", "{", "var", "p", "=", "require", "(", "options", ".", "root", "+", "'/package.json'", ")", ";", "options", ".", "name", "=", "p", ".", "name", ";", "}", "catch", "(", "e", ")", "{", "}", "}", "/*\n In production mode, define default log threshold to info\n */", "if", "(", "process", ".", "env", ".", "LOG_LEVEL", "===", "undefined", "&&", "process", ".", "env", ".", "NODE_ENV", "===", "\"production\"", ")", "{", "process", ".", "env", ".", "LOG_LEVEL", "=", "\"info\"", ";", "}", "options", ".", "name", "=", "options", ".", "name", "||", "\".\"", ";", "replace", "(", ")", ";", "return", "restore", ";", "}" ]

[ "Setup", "JSON", "console" ]

[ "function", "(", "inX", ",", "inY", ")", "{", "var", "o", "=", "inX", "+", "\"px, \"", "+", "inY", "+", "\"px\"", "+", "(", "this", ".", "accel", "?", "\",0\"", ":", "\"\"", ")", ";", "enyo", ".", "dom", ".", "transformValue", "(", "this", ".", "$", ".", "client", ",", "this", ".", "translation", ",", "o", ")", ";", "}" ]

[ "While", "moving", "scroller", "uses", "translate", "." ]

[ "function", "deus", "(", "one", ",", "two", ",", "fn", ")", "{", "var", "types", "=", "[", "one", ",", "two", "]", ";", "var", "type", "=", "function", "(", "args", ",", "arg", ")", "{", "var", "idx", "=", "index", "(", "types", ",", "typeof", "arg", ")", ";", "if", "(", "idx", ">", "-", "1", "&&", "!", "args", "[", "idx", "]", ")", "args", "[", "idx", "]", "=", "arg", ";", "else", "if", "(", "arg", ")", "args", ".", "splice", "(", "args", ".", "length", ",", "0", ",", "arg", ")", ";", "}", ";", "return", "function", "(", ")", "{", "var", "args", "=", "[", ",", ",", "]", ";", "for", "(", "var", "i", "=", "0", ",", "l", "=", "arguments", ".", "length", ";", "i", "<", "l", ";", "i", "++", ")", "{", "type", "(", "args", ",", "arguments", "[", "i", "]", ")", ";", "}", "return", "fn", ".", "apply", "(", "this", ",", "args", ")", ";", "}", ";", "}" ]

[ "Make", "two", "arguments", "function", "flexible", "." ]

[ "function", "ensureDoc", "(", "$node", ")", "{", "// FIXME if isVNode(node) use cx on node", "var", "cx", "=", "(", "0", ",", "_vnode", ".", "getContext", ")", "(", "this", ",", "inode", ")", ";", "return", "(", "0", ",", "_just", ".", "default", ")", "(", "$node", ")", ".", "pipe", "(", "(", "0", ",", "_operators", ".", "concatMap", ")", "(", "function", "(", "node", ")", "{", "if", "(", "!", "(", "0", ",", "_vnode", ".", "isVNode", ")", "(", "node", ")", ")", "{", "var", "type", "=", "cx", ".", "getType", "(", "node", ")", ";", "if", "(", "type", "==", "9", "||", "type", "==", "11", ")", "{", "var", "root", "=", "cx", ".", "first", "(", "node", ")", ";", "return", "(", "0", ",", "_just", ".", "default", ")", "(", "cx", ".", "vnode", "(", "root", ",", "cx", ".", "vnode", "(", "node", ")", ",", "1", ",", "0", ")", ")", ";", "}", "else", "{", "// create a document-fragment by default!", "var", "doc", "=", "t", ".", "bind", "(", "cx", ")", "(", ")", ";", "var", "_root", "=", "cx", ".", "vnode", "(", "node", ",", "doc", ",", "1", ",", "0", ")", ";", "return", "(", "0", ",", "_just", ".", "default", ")", "(", "doc", ")", ".", "pipe", "(", "(", "0", ",", "_operators", ".", "concatMap", ")", "(", "function", "(", "doc", ")", "{", "doc", "=", "doc", ".", "push", "(", "[", "0", ",", "_root", ".", "node", "]", ")", ";", "var", "next", "=", "doc", ".", "first", "(", ")", ";", "return", "next", "?", "(", "0", ",", "_just", ".", "default", ")", "(", "doc", ".", "vnode", "(", "next", ",", "doc", ",", "doc", ".", "depth", "+", "1", ",", "0", ")", ")", ":", "(", "0", ",", "_just", ".", "default", ")", "(", ")", ";", "}", ")", ")", ";", "}", "}", "if", "(", "typeof", "node", ".", "node", "===", "\"function\"", ")", "{", "// NOTE never bind to current node.cx, but purposely allow cross-binding", "return", "(", "0", ",", "_just", ".", "default", ")", "(", "t", ".", "bind", "(", "cx", ")", "(", "node", ")", ")", ".", "pipe", "(", "(", "0", ",", "_operators", ".", "concatMap", ")", "(", "function", "(", "node", ")", "{", "var", "next", "=", "node", ".", "first", "(", ")", ";", "return", "next", "?", "(", "0", ",", "_just", ".", "default", ")", "(", "node", ".", "vnode", "(", "next", ",", "node", ",", "node", ".", "depth", "+", "1", ",", "0", ")", ")", ":", "(", "0", ",", "_just", ".", "default", ")", "(", ")", ";", "}", ")", ")", ";", "}", "return", "(", "0", ",", "_just", ".", "default", ")", "(", "node", ")", ";", "}", ")", ")", ";", "}" ]

[ "Document", "-", "related", "functions" ]

[ "function", "Tree2Json", "(", "inputTree", ")", "{", "if", "(", "!", "(", "this", "instanceof", "Tree2Json", ")", ")", "return", "new", "Tree2Json", "(", "inputTree", ")", ";", "this", ".", "inputTree", "=", "inputTree", ".", "replace", "(", "/", "\\/$", "/", ",", "''", ")", ";", "this", ".", "walker", "=", "new", "TreeTraverser", "(", "inputTree", ",", "this", ")", ";", "}" ]

[ "Take", "an", "input", "tree", "and", "roll", "it", "up", "into", "a", "JSON", "document", ".", "The", "resulting", "document", "will", "be", "named", "srcDir", ".", "json", ".", "it", "will", "have", "key", "names", "associated", "with", "each", "of", "the", "file", "and", "directories", "that", "srcDir", "contains", ".", "If", "the", "key", "represents", "the", "file", "then", "the", "stringified", "file", "contents", "will", "be", "the", "value", "of", "the", "key", ".", "If", "the", "key", "represents", "a", "directory", "then", "the", "value", "of", "that", "key", "will", "be", "an", "Object", "represented", "by", "the", "same", "algorithm" ]

[ "function", "cov", "(", "x", ")", "{", "// Useful variables", "let", "N", "=", "x", ".", "length", ";", "// Step 1: Find expected value for each variable (columns are variables, rows are samples)", "let", "E", "=", "[", "]", ";", "for", "(", "let", "c", "=", "0", ";", "c", "<", "x", "[", "0", "]", ".", "length", ";", "c", "++", ")", "{", "let", "u", "=", "0", ";", "for", "(", "let", "r", "=", "0", ";", "r", "<", "N", ";", "r", "++", ")", "{", "u", "+=", "x", "[", "r", "]", "[", "c", "]", ";", "}", "E", ".", "push", "(", "u", "/", "N", ")", ";", "}", "// Step 2: Center each variable at 0", "let", "centered", "=", "[", "]", ";", "for", "(", "let", "r", "=", "0", ";", "r", "<", "N", ";", "r", "++", ")", "{", "centered", ".", "push", "(", "[", "]", ")", ";", "for", "(", "let", "c", "=", "0", ";", "c", "<", "x", "[", "0", "]", ".", "length", ";", "c", "++", ")", "{", "centered", "[", "r", "]", ".", "push", "(", "x", "[", "r", "]", "[", "c", "]", "-", "E", "[", "c", "]", ")", ";", "}", "}", "// Step 3: Calculate covariance between each possible combination of variables", "let", "S", "=", "[", "]", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "x", "[", "0", "]", ".", "length", ";", "i", "++", ")", "{", "S", ".", "push", "(", "[", "]", ")", ";", "}", "for", "(", "let", "c1", "=", "0", ";", "c1", "<", "x", "[", "0", "]", ".", "length", ";", "c1", "++", ")", "{", "// Doing c2 = c1; because, for example, cov(1,2) = cov(2, 1)", "// so no need to recalculate", "for", "(", "let", "c2", "=", "c1", ";", "c2", "<", "x", "[", "0", "]", ".", "length", ";", "c2", "++", ")", "{", "// Solve cov(c1, c2) = average of elementwise products of each variable sample", "let", "cov", "=", "0", ";", "for", "(", "let", "r", "=", "0", ";", "r", "<", "N", ";", "r", "++", ")", "{", "cov", "+=", "centered", "[", "r", "]", "[", "c1", "]", "*", "centered", "[", "r", "]", "[", "c2", "]", ";", "}", "cov", "/=", "(", "N", "-", "1", ")", ";", "// N-1 for sample covariance, N for population. In this case, using sample covariance", "S", "[", "c1", "]", "[", "c2", "]", "=", "cov", ";", "S", "[", "c2", "]", "[", "c1", "]", "=", "cov", ";", "// Matrix is symmetric", "}", "}", "return", "S", ";", "}" ]

[ "Returns", "the", "covariance", "matrix", "for", "a", "given", "matrix", "." ]

[ "function", "mean", "(", "x", ")", "{", "let", "result", "=", "[", "]", ";", "for", "(", "let", "c", "=", "0", ";", "c", "<", "x", "[", "0", "]", ".", "length", ";", "c", "++", ")", "{", "result", ".", "push", "(", "0", ")", ";", "}", "for", "(", "let", "r", "=", "0", ";", "r", "<", "x", ".", "length", ";", "r", "++", ")", "{", "for", "(", "let", "c", "=", "0", ";", "c", "<", "x", "[", "r", "]", ".", "length", ";", "c", "++", ")", "{", "result", "[", "c", "]", "+=", "x", "[", "r", "]", "[", "c", "]", ";", "}", "}", "for", "(", "let", "c", "=", "0", ";", "c", "<", "x", "[", "0", "]", ".", "length", ";", "c", "++", ")", "{", "result", "[", "c", "]", "/=", "x", ".", "length", ";", "}", "return", "result", ";", "}" ]

[ "Returns", "the", "mean", "of", "each", "column", "in", "the", "provided", "matrix", "." ]

[ "function", "(", "config", ")", "{", "config", "=", "config", "||", "{", "}", ";", "this", ".", "api_key", "=", "config", ".", "api_key", ";", "this", ".", "host", "=", "config", ".", "host", "||", "undefined", ";", "this", ".", "api_version", "=", "config", ".", "api_version", "||", "undefined", ";", "this", ".", "dev_mode", "=", "config", ".", "dev_mode", "||", "false", ";", "return", "this", ";", "}" ]

[ "Initializes", "the", "class", "for", "remote", "API", "Calls" ]

[ "function", "(", "context_uid", ",", "sender", ",", "receiver", ",", "channel", ",", "message", ",", "meta", ")", "{", "if", "(", "!", "this", ".", "api_key", ")", "throw", "new", "ChangeTipException", "(", "300", ")", ";", "if", "(", "!", "channel", ")", "throw", "new", "ChangeTipException", "(", "301", ")", ";", "var", "deferred", "=", "Q", ".", "defer", "(", ")", ",", "data", ";", "data", "=", "{", "context_uid", ":", "context_uid", ",", "sender", ":", "sender", ",", "receiver", ":", "receiver", ",", "channel", ":", "channel", ",", "message", ":", "message", ",", "meta", ":", "meta", "}", ";", "this", ".", "_send_request", "(", "data", ",", "'tips'", ",", "null", ",", "Methods", ".", "POST", ",", "deferred", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Sends", "a", "tip", "via", "the", "ChangeTip", "API" ]

[ "function", "(", "tips", ",", "channel", ")", "{", "if", "(", "!", "this", ".", "api_key", ")", "throw", "new", "ChangeTipException", "(", "300", ")", ";", "var", "deferred", "=", "Q", ".", "defer", "(", ")", ",", "params", ";", "params", "=", "{", "tips", ":", "tips", "instanceof", "Array", "?", "tips", ".", "join", "(", "\",\"", ")", ":", "tips", ",", "channel", ":", "channel", "||", "''", "}", ";", "this", ".", "_send_request", "(", "{", "}", ",", "'tips'", ",", "params", ",", "Methods", ".", "GET", ",", "deferred", ")", ";", "return", "deferred", ".", "promise", ";", "}" ]

[ "Retrieve", "tips", "from", "the", "ChangeTip", "API" ]

[ "function", "(", "data", ",", "path", ",", "params", ",", "method", ",", "deferred", ")", "{", "var", "options", ",", "query_params", ",", "req", ",", "dataString", "=", "JSON", ".", "stringify", "(", "data", ")", ";", "query_params", "=", "querystring", ".", "stringify", "(", "params", ")", ";", "options", "=", "{", "host", ":", "this", ".", "host", ",", "port", ":", "443", ",", "path", ":", "'/v'", "+", "this", ".", "api_version", "+", "'/'", "+", "path", "+", "'/?api_key='", "+", "this", ".", "api_key", "+", "(", "query_params", "?", "(", "'&'", "+", "query_params", ")", ":", "''", ")", ",", "method", ":", "method", ",", "headers", ":", "{", "'Content-Type'", ":", "'application/json'", ",", "'Content-Length'", ":", "dataString", ".", "length", "}", "}", ";", "if", "(", "!", "this", ".", "dev_mode", ")", "{", "req", "=", "https", ".", "request", "(", "options", ",", "function", "(", "res", ")", "{", "res", ".", "setEncoding", "(", "'utf-8'", ")", ";", "var", "response", "=", "''", ",", "result", ";", "res", ".", "on", "(", "'data'", ",", "function", "(", "response_data", ")", "{", "response", "+=", "response_data", ";", "}", ")", ";", "res", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "result", "=", "JSON", ".", "parse", "(", "response", ")", ";", "deferred", ".", "resolve", "(", "result", ")", ";", "}", ")", ";", "}", ")", ";", "req", ".", "write", "(", "dataString", ")", ";", "req", ".", "end", "(", ")", ";", "}", "else", "{", "deferred", ".", "resolve", "(", "{", "status", ":", "\"dev_mode\"", ",", "data", ":", "data", ",", "params", ":", "params", ",", "path", ":", "options", ".", "path", "}", ")", ";", "}", "}" ]

[ "Sends", "a", "request" ]

[ "function", "quickTemplate", "(", "pTemplate", ",", "pValues", ")", "{", "return", "pTemplate", ".", "replace", "(", "templateRegex", ",", "function", "(", "i", ",", "pMatch", ")", "{", "return", "pValues", "[", "pMatch", "]", ";", "}", ")", ";", "}" ]

[ "Quick", "and", "dirty", "template", "method" ]

[ "function", "ObjectInfo", "(", "name", ",", "contentType", ")", "{", "this", ".", "_name", "=", "name", ";", "this", ".", "_type", "=", "contentType", "||", "ObjectInfo", ".", "DEFAULT_CONTENT_TYPE", ";", "this", ".", "_partial", "=", "false", ";", "}" ]

[ "Build", "a", "new", "ObjectInfo", "instance", "." ]

[ "function", "initCheckApi", "(", "logger", ",", "config", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "var", "check", "=", "new", "Check", "(", "logger", ",", "config", ")", ";", "var", "promises", "=", "[", "]", ";", "var", "checkers", "=", "require", "(", "'mazaid-checkers'", ")", ";", "for", "(", "var", "checker", "of", "checkers", ")", "{", "promises", ".", "push", "(", "check", ".", "add", "(", "checker", ")", ")", ";", "}", "Promise", ".", "all", "(", "promises", ")", ".", "then", "(", "(", ")", "=>", "{", "return", "check", ".", "init", "(", ")", ";", "}", ")", ".", "then", "(", "(", ")", "=>", "{", "checkApi", "=", "check", ";", "resolve", "(", ")", ";", "}", ")", ".", "catch", "(", "(", "error", ")", "=>", "{", "reject", "(", "error", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "init", "check", "api", "add", "ping", "checker" ]

[ "function", "runCheckTask", "(", "logger", ",", "checkTask", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "// create check task object", "// raw.id = uuid();", "// var checkTask = new CheckTask(raw);", "// validate check task", "checkTask", ".", "validate", "(", "logger", ")", ".", "then", "(", "(", "checkTask", ")", "=>", "{", "// set check task status to queued", "checkTask", ".", "queued", "(", ")", ";", "// prepare exec task by check task data", "return", "checkApi", ".", "prepare", "(", "checkTask", ")", ";", "}", ")", ".", "then", "(", "(", "execData", ")", "=>", "{", "// create exec task and validate", "execData", ".", "id", "=", "uuid", "(", ")", ";", "checkTask", ".", "execTaskId", "=", "execData", ".", "id", ";", "var", "execTask", "=", "new", "ExecTask", "(", "execData", ")", ";", "return", "execTask", ".", "validate", "(", ")", ";", "}", ")", ".", "then", "(", "(", "execTask", ")", "=>", "{", "// set check task to started", "checkTask", ".", "started", "(", ")", ";", "// execute exec task", "return", "exec", "(", "logger", ",", "execTask", ")", ";", "}", ")", ".", "then", "(", "(", "execTask", ")", "=>", "{", "// got exec task response and parse it", "return", "checkApi", ".", "parse", "(", "checkTask", ",", "execTask", ")", ";", "}", ")", ".", "then", "(", "(", "parsedResult", ")", "=>", "{", "// got parsed response", "// set to check task", "checkTask", ".", "rawResult", "=", "parsedResult", ";", "// run analyze stage", "return", "checkApi", ".", "analyze", "(", "checkTask", ")", ";", "}", ")", ".", "then", "(", "(", "result", ")", "=>", "{", "// got status and message result, and custom checker data in result", "// set result to check task and validate", "checkTask", ".", "result", "=", "result", ";", "checkTask", ".", "finished", "(", ")", ";", "return", "checkTask", ".", "validate", "(", ")", ";", "}", ")", ".", "then", "(", "(", "task", ")", "=>", "{", "resolve", "(", "task", ")", ";", "}", ")", ".", "catch", "(", "(", "error", ")", "=>", "{", "checkTask", ".", "result", "=", "{", "status", ":", "'fail'", ",", "message", ":", "error", ".", "message", "}", ";", "error", ".", "checkTask", "=", "checkTask", ";", "reject", "(", "error", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "exec", "check", "task" ]

[ "function", "parseRequires", "(", "js", ")", "{", "return", "js", ".", "replace", "(", "/", "require\\('events'\\)", "/", "g", ",", "\"require('browser/events')\"", ")", ".", "replace", "(", "/", "require\\('debug'\\)", "/", "g", ",", "\"require('browser/debug')\"", ")", ".", "replace", "(", "/", "require\\('path'\\)", "/", "g", ",", "\"require('browser/path')\"", ")", ".", "replace", "(", "/", "require\\('diff'\\)", "/", "g", ",", "\"require('browser/diff')\"", ")", ".", "replace", "(", "/", "require\\('tty'\\)", "/", "g", ",", "\"require('browser/tty')\"", ")", ".", "replace", "(", "/", "require\\('fs'\\)", "/", "g", ",", "\"require('browser/fs')\"", ")", "}" ]

[ "Parse", "requires", "." ]

[ "function", "(", "obj", ",", "parts", ")", "{", "if", "(", "parts", ".", "length", "===", "0", ")", "{", "return", "true", ";", "}", "var", "key", "=", "parts", ".", "shift", "(", ")", ";", "if", "(", "!", "_", "(", "obj", ")", ".", "has", "(", "key", ")", ")", "{", "return", "false", ";", "}", "else", "{", "return", "hasKeyPath", "(", "obj", "[", "key", "]", ",", "parts", ")", ";", "}", "}" ]

[ "Recursively", "step", "through", "the", "provided", "object", "and", "return", "whether", "it", "contains", "the", "provided", "keypath", "." ]

[ "function", "(", "obj", ",", "env", ",", "keypath", ")", "{", "if", "(", "!", "_", ".", "isObject", "(", "obj", ")", "||", "_", ".", "isArray", "(", "obj", ")", ")", "{", "return", ";", "}", "if", "(", "hasKeyPath", "(", "obj", ",", "[", "'options'", ",", "'reconfigureOverrides'", ",", "env", "]", ")", ")", "{", "var", "options", "=", "obj", ".", "options", ",", "overrides", "=", "obj", ".", "options", ".", "reconfigureOverrides", "[", "env", "]", ";", "for", "(", "var", "key", "in", "overrides", ")", "{", "var", "update", "=", "{", "key", ":", "keypath", "+", "'.options.'", "+", "key", ",", "oldVal", ":", "(", "typeof", "options", "[", "key", "]", "===", "'undefined'", ")", "?", "'undefined'", ":", "util", ".", "inspect", "(", "options", "[", "key", "]", ")", ",", "}", ";", "if", "(", "_", ".", "isObject", "(", "options", "[", "key", "]", ")", "&&", "_", ".", "isObject", "(", "overrides", "[", "key", "]", ")", ")", "{", "var", "newVal", "=", "_", ".", "extend", "(", "options", "[", "key", "]", ",", "overrides", "[", "key", "]", ")", ";", "update", ".", "newVal", "=", "util", ".", "inspect", "(", "newVal", ")", ";", "}", "else", "{", "options", "[", "key", "]", "=", "overrides", "[", "key", "]", ";", "update", ".", "newVal", "=", "util", ".", "inspect", "(", "overrides", "[", "key", "]", ")", ";", "}", "updates", ".", "push", "(", "update", ")", ";", "}", "}", "for", "(", "var", "objKey", "in", "obj", ")", "{", "updateOptions", "(", "obj", "[", "objKey", "]", ",", "env", ",", "keypath", "+", "'.'", "+", "objKey", ")", ";", "}", "}" ]

[ "Recursively", "step", "through", "the", "provided", "object", "searching", "for", "an", "options", "object", "with", "reconfigureOverrides", "containing", "the", "provided", "env", ".", "If", "it", "finds", "one", "it", "resets", "any", "keys", "and", "values", "found", "inside", "on", "the", "containing", "options", "object", "." ]

[ "function", "pushLogEntry", "(", "logEntry", ")", "{", "var", "logger", "=", "window", "[", "appSettings", ".", "loggerVar", "]", ";", "if", "(", "logger", ")", "{", "logger", ".", "logs", ".", "push", "(", "logEntry", ")", ";", "if", "(", "window", ".", "console", ")", "{", "if", "(", "typeof", "console", ".", "error", "===", "\"function\"", "&&", "typeof", "console", ".", "warn", "===", "\"function\"", ")", "{", "switch", "(", "logEntry", ".", "type", ")", "{", "case", "enumerations", ".", "logType", ".", "wtf", ":", "console", ".", "error", "(", "toFriendlyString", "(", "logEntry", ")", ")", ";", "break", ";", "case", "enumerations", ".", "logType", ".", "error", ":", "if", "(", "appSettings", ".", "logLevel", "<=", "enumerations", ".", "logLevel", ".", "error", "&&", "appSettings", ".", "logLevel", ">", "enumerations", ".", "logLevel", ".", "off", ")", "{", "console", ".", "error", "(", "toFriendlyString", "(", "logEntry", ")", ")", ";", "}", "break", ";", "case", "enumerations", ".", "logType", ".", "warning", ":", "if", "(", "appSettings", ".", "logLevel", "<=", "enumerations", ".", "logLevel", ".", "warn", "&&", "appSettings", ".", "logLevel", ">", "enumerations", ".", "logLevel", ".", "off", ")", "{", "console", ".", "warn", "(", "toFriendlyString", "(", "logEntry", ")", ")", ";", "}", "break", ";", "default", ":", "if", "(", "appSettings", ".", "logLevel", "<=", "enumerations", ".", "logLevel", ".", "debug", "&&", "appSettings", ".", "logLevel", ">", "enumerations", ".", "logLevel", ".", "off", ")", "{", "console", ".", "log", "(", "toFriendlyString", "(", "logEntry", ")", ")", ";", "break", ";", "}", "}", "}", "else", "{", "console", ".", "log", "(", "toFriendlyString", "(", "logEntry", ")", ")", ";", "}", "}", "}", "}" ]

[ "Push", "a", "logEntry", "to", "the", "array", "of", "logs", "and", "output", "it", "to", "the", "console" ]

[ "function", "getCurrentTimeString", "(", ")", "{", "var", "today", "=", "new", "Date", "(", ")", ";", "var", "hh", "=", "today", ".", "getHours", "(", ")", ";", "var", "mm", "=", "today", ".", "getMinutes", "(", ")", ";", "//January is 0", "var", "ss", "=", "today", ".", "getSeconds", "(", ")", ";", "var", "ms", "=", "today", ".", "getMilliseconds", "(", ")", ";", "if", "(", "hh", "<", "10", ")", "{", "hh", "=", "'0'", "+", "hh", ";", "}", "if", "(", "mm", "<", "10", ")", "{", "mm", "=", "'0'", "+", "mm", ";", "}", "if", "(", "ss", "<", "10", ")", "{", "ss", "=", "'0'", "+", "ss", ";", "}", "if", "(", "ms", "<", "10", ")", "{", "ms", "=", "'0'", "+", "ms", ";", "}", "return", "hh", "+", "\":\"", "+", "mm", "+", "\":\"", "+", "ss", "+", "\":\"", "+", "ms", ";", "}" ]

[ "Get", "the", "current", "time", "as", "a", "string" ]

[ "function", "read_from_source", "(", "codestr", ",", "filenameOrLexer", ",", "options", ")", "{", "var", "lexer", ";", "if", "(", "typeof", "filenameOrLexer", "===", "'string'", ")", "{", "lexer", "=", "initLexerFor", "(", "codestr", ",", "filenameOrLexer", ",", "options", ")", ";", "}", "else", "{", "lexer", "=", "filenameOrLexer", ";", "lexer", ".", "set_source_text", "(", "codestr", ",", "options", ")", ";", "}", "// read the forms", "var", "forms", "=", "read", "(", "lexer", ")", ";", "// it's useful to sometimes look \"up\" the lexical nesting of forms...", "// to make this easy/reliable - walk the form tree setting \"parent\"", "// I SHOULD TIME THIS? IF IT'S EXPENSIVE - I'M NOT SURE I EVEN NEED IT ANYMORE?", "if", "(", "options", ".", "setParents", "!==", "'no'", "&&", "forms", ".", "setParents", ")", "{", "forms", ".", "setParents", "(", ")", ";", "}", "return", "forms", ";", "}" ]

[ "Read", "the", "expressions", "in", "the", "provided", "source", "code", "string", "." ]

[ "function", "unuse_dialect", "(", "dialectName", ",", "lexer", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "if", "(", "dialectName", "&&", "options", ".", "validate", "&&", "lexer", ".", "dialects", "[", "0", "]", ".", "name", "!==", "dialectName", ")", "{", "lexer", ".", "error", "(", "'Attempt to exit dialect \"'", "+", "dialectName", "+", "'\" while \"'", "+", "lexer", ".", "dialects", "[", "0", "]", ".", "name", "+", "'\" was still active'", ")", ";", "}", "slinfo", "(", "'removing dialect'", ",", "dialectName", "?", "\": \"", "+", "dialectName", ":", "\"\"", ")", ";", "var", "removedDialect", "=", "lexer", ".", "pop_dialect", "(", "dialectName", ")", ";", "if", "(", "!", "removedDialect", ")", "{", "lexer", ".", "error", "(", "'The dialect '", "+", "(", "dialectName", "?", "'\"'", "+", "dialectName", "+", "'\"'", ":", "''", ")", "+", "' has never been used'", ")", ";", "}", "}" ]

[ "stop", "using", "a", "dialect" ]

[ "function", "invokeInitDialectFunctions", "(", "dialect", ",", "lexer", ",", "options", ")", "{", "var", "initfnkey", "=", "\"__init\"", ";", "if", "(", "dialect", "[", "initfnkey", "]", ")", "{", "dialect", "[", "initfnkey", "]", "(", "lexer", ",", "dialect", ",", "options", ")", ";", "}", "if", "(", "dialect", ".", "lextab", "[", "initfnkey", "]", ")", "{", "dialect", ".", "lextab", "[", "initfnkey", "]", "(", "lexer", ",", "dialect", ",", "options", ")", ";", "}", "if", "(", "dialect", ".", "readtab", "[", "initfnkey", "]", ")", "{", "dialect", ".", "readtab", "[", "initfnkey", "]", "(", "lexer", ",", "dialect", ",", "options", ")", ";", "}", "if", "(", "dialect", ".", "gentab", "[", "initfnkey", "]", ")", "{", "dialect", ".", "gentab", "[", "initfnkey", "]", "(", "lexer", ",", "dialect", ",", "options", ")", ";", "}", "}" ]

[ "Init", "dialect", "functions", "can", "optionally", "be", "used", "to", "initialize", "things", "at", "the", "time", "a", "dialect", "is", "used", "." ]

[ "function", "read", "(", "lexer", ",", "precedence", ")", "{", "precedence", "=", "precedence", "||", "0", ";", "var", "form", "=", "read_via_closest_dialect", "(", "lexer", ")", ";", "// are we a prefix unary operator?", "var", "leftForm", "=", "form", ";", "if", "(", "sl", ".", "isAtom", "(", "form", ")", ")", "{", "var", "opSpec", "=", "getOperatorSpecFor", "(", "form", ",", "lexer", ".", "dialects", ")", ";", "if", "(", "opSpec", "&&", "isEnabled", "(", "opSpec", ".", "prefix", ")", "&&", "opSpec", ".", "prefix", ".", "transform", "&&", "// \"nospace\" prefix ops must butt up against their arg so", "// \"--i\" not \"-- i\" this way we can't confuse e.g. (- x y)", "// with (-x y)", "(", "!", "opSpec", ".", "options", "||", "!", "opSpec", ".", "options", ".", "nospace", "||", "!", "lexer", ".", "onwhitespace", "(", "-", "1", ")", ")", ")", "{", "leftForm", "=", "opSpec", ".", "prefix", ".", "transform", "(", "lexer", ",", "opSpec", ".", "prefix", ",", "form", ")", ";", "}", "}", "// note flipped check below from < to > because our precedences", "// are currently as you see them here: http://www.scriptingmaster.com/javascript/operator-precedence.asp", "// not as you see them here: http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/", "var", "token", ",", "opSpecObj", ";", "while", "(", "!", "lexer", ".", "eos", "(", ")", "&&", "(", "token", "=", "lexer", ".", "peek_token", "(", ")", ")", "&&", "(", "opSpecObj", "=", "getOperatorSpecFor", "(", "token", ".", "text", ",", "lexer", ".", "dialects", ")", ")", "&&", "opSpecObj", "&&", "(", "isEnabled", "(", "opSpecObj", ".", "infix", ")", "||", "isEnabled", "(", "opSpecObj", ".", "postfix", ")", ")", ")", "{", "// make sure we don't misinterpet e.g. \"(get ++i)\" as \"(get++ i)\"", "if", "(", "opSpecObj", ".", "prefix", "&&", "opSpecObj", ".", "postfix", "&&", "(", "lexer", ".", "onwhitespace", "(", "-", "1", ")", "&&", "!", "lexer", ".", "onwhitespace", "(", "token", ".", "text", ".", "length", ")", ")", ")", "{", "break", ";", "// let it be prefix next time round", "}", "// we don't distinguish infix from postfix below:", "var", "opSpec", "=", "opSpecObj", ".", "infix", "||", "opSpecObj", ".", "postfix", ";", "// we only keep scanning if we're hitting *higher* precedence", "if", "(", "(", "opSpec", ".", "precedence", "||", "0", ")", "<=", "precedence", ")", "{", "trace", "(", "\"read of infix/postfix stopping because op precedence \"", "+", "(", "opSpec", ".", "precedence", "||", "0", ")", "+", "\" is <= the current precendence of \"", "+", "precedence", ")", ";", "break", ";", "// stop scanning", "}", "token", "=", "lexer", ".", "next_token", "(", ")", ";", "leftForm", "=", "opSpec", ".", "transform", "(", "lexer", ",", "opSpec", ",", "leftForm", ",", "sl", ".", "atom", "(", "token", ")", ")", ";", "}", "if", "(", "sl", ".", "isList", "(", "leftForm", ")", ")", "{", "// now that we've finished reading the list,", "// pop any local dialects whose scope has ended", "pop_local_dialects", "(", "lexer", ",", "leftForm", ")", ";", "}", "return", "leftForm", ";", "}" ]

[ "Read", "the", "form", "at", "the", "current", "position", "in", "the", "source", "." ]