Datasets:

CM

/

codexglue_code2text_javascript

like 8

[ "function", "discoverAndReadFiles", "(", "options", ")", "{", "const", "FILES", "=", "{", "}", ";", "const", "in_queue", "=", "Object", ".", "create", "(", "null", ")", ";", "const", "queue", "=", "[", "]", ";", "const", "enqueue", "=", "(", "moduleId", ")", "=>", "{", "if", "(", "in_queue", "[", "moduleId", "]", ")", "{", "return", ";", "}", "in_queue", "[", "moduleId", "]", "=", "true", ";", "queue", ".", "push", "(", "moduleId", ")", ";", "}", ";", "options", ".", "entryPoints", ".", "forEach", "(", "(", "entryPoint", ")", "=>", "enqueue", "(", "entryPoint", ")", ")", ";", "while", "(", "queue", ".", "length", ">", "0", ")", "{", "const", "moduleId", "=", "queue", ".", "shift", "(", ")", ";", "const", "dts_filename", "=", "path", ".", "join", "(", "options", ".", "sourcesRoot", ",", "moduleId", "+", "'.d.ts'", ")", ";", "if", "(", "fs", ".", "existsSync", "(", "dts_filename", ")", ")", "{", "const", "dts_filecontents", "=", "fs", ".", "readFileSync", "(", "dts_filename", ")", ".", "toString", "(", ")", ";", "FILES", "[", "`", "${", "moduleId", "}", "`", "]", "=", "dts_filecontents", ";", "continue", ";", "}", "const", "js_filename", "=", "path", ".", "join", "(", "options", ".", "sourcesRoot", ",", "moduleId", "+", "'.js'", ")", ";", "if", "(", "fs", ".", "existsSync", "(", "js_filename", ")", ")", "{", "// This is an import for a .js file, so ignore it...", "continue", ";", "}", "let", "ts_filename", ";", "if", "(", "options", ".", "redirects", "[", "moduleId", "]", ")", "{", "ts_filename", "=", "path", ".", "join", "(", "options", ".", "sourcesRoot", ",", "options", ".", "redirects", "[", "moduleId", "]", "+", "'.ts'", ")", ";", "}", "else", "{", "ts_filename", "=", "path", ".", "join", "(", "options", ".", "sourcesRoot", ",", "moduleId", "+", "'.ts'", ")", ";", "}", "const", "ts_filecontents", "=", "fs", ".", "readFileSync", "(", "ts_filename", ")", ".", "toString", "(", ")", ";", "const", "info", "=", "ts", ".", "preProcessFile", "(", "ts_filecontents", ")", ";", "for", "(", "let", "i", "=", "info", ".", "importedFiles", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "const", "importedFileName", "=", "info", ".", "importedFiles", "[", "i", "]", ".", "fileName", ";", "if", "(", "options", ".", "importIgnorePattern", ".", "test", "(", "importedFileName", ")", ")", "{", "// Ignore vs/css! imports", "continue", ";", "}", "let", "importedModuleId", "=", "importedFileName", ";", "if", "(", "/", "(^\\.\\/)|(^\\.\\.\\/)", "/", ".", "test", "(", "importedModuleId", ")", ")", "{", "importedModuleId", "=", "path", ".", "join", "(", "path", ".", "dirname", "(", "moduleId", ")", ",", "importedModuleId", ")", ";", "}", "enqueue", "(", "importedModuleId", ")", ";", "}", "FILES", "[", "`", "${", "moduleId", "}", "`", "]", "=", "ts_filecontents", ";", "}", "return", "FILES", ";", "}" ]

[ "Read", "imports", "and", "follow", "them", "until", "all", "files", "have", "been", "handled" ]

[ "function", "handleDeletions", "(", ")", "{", "return", "es", ".", "mapSync", "(", "f", "=>", "{", "if", "(", "/", "\\.ts$", "/", ".", "test", "(", "f", ".", "relative", ")", "&&", "!", "f", ".", "contents", ")", "{", "f", ".", "contents", "=", "Buffer", ".", "from", "(", "''", ")", ";", "f", ".", "stat", "=", "{", "mtime", ":", "new", "Date", "(", ")", "}", ";", "}", "return", "f", ";", "}", ")", ";", "}" ]

[ "Ugly", "hack", "for", "gulp", "-", "tsb" ]

[ "function", "uglifyWithCopyrights", "(", ")", "{", "const", "preserveComments", "=", "(", "f", ")", "=>", "{", "return", "(", "_node", ",", "comment", ")", "=>", "{", "const", "text", "=", "comment", ".", "value", ";", "const", "type", "=", "comment", ".", "type", ";", "if", "(", "/", "@minifier_do_not_preserve", "/", ".", "test", "(", "text", ")", ")", "{", "return", "false", ";", "}", "const", "isOurCopyright", "=", "IS_OUR_COPYRIGHT_REGEXP", ".", "test", "(", "text", ")", ";", "if", "(", "isOurCopyright", ")", "{", "if", "(", "f", ".", "__hasOurCopyright", ")", "{", "return", "false", ";", "}", "f", ".", "__hasOurCopyright", "=", "true", ";", "return", "true", ";", "}", "if", "(", "'comment2'", "===", "type", ")", "{", "// check for /*!. Note that text doesn't contain leading /*", "return", "(", "text", ".", "length", ">", "0", "&&", "text", "[", "0", "]", "===", "'!'", ")", "||", "/", "@preserve|license|@cc_on|copyright", "/", "i", ".", "test", "(", "text", ")", ";", "}", "else", "if", "(", "'comment1'", "===", "type", ")", "{", "return", "/", "license|copyright", "/", "i", ".", "test", "(", "text", ")", ";", "}", "return", "false", ";", "}", ";", "}", ";", "const", "minify", "=", "composer", "(", "uglifyes", ")", ";", "const", "input", "=", "es", ".", "through", "(", ")", ";", "const", "output", "=", "input", ".", "pipe", "(", "flatmap", "(", "(", "stream", ",", "f", ")", "=>", "{", "return", "stream", ".", "pipe", "(", "minify", "(", "{", "output", ":", "{", "comments", ":", "preserveComments", "(", "f", ")", ",", "max_line_len", ":", "1024", "}", "}", ")", ")", ";", "}", ")", ")", ";", "return", "es", ".", "duplex", "(", "input", ",", "output", ")", ";", "}" ]

[ "Wrap", "around", "uglify", "and", "allow", "the", "preserveComments", "function", "to", "have", "a", "file", "context", "to", "include", "our", "copyright", "only", "once", "per", "file", "." ]

[ "function", "sequence", "(", "streamProviders", ")", "{", "const", "result", "=", "es", ".", "through", "(", ")", ";", "function", "pop", "(", ")", "{", "if", "(", "streamProviders", ".", "length", "===", "0", ")", "{", "result", ".", "emit", "(", "'end'", ")", ";", "}", "else", "{", "const", "fn", "=", "streamProviders", ".", "shift", "(", ")", ";", "fn", "(", ")", ".", "on", "(", "'end'", ",", "function", "(", ")", "{", "setTimeout", "(", "pop", ",", "0", ")", ";", "}", ")", ".", "pipe", "(", "result", ",", "{", "end", ":", "false", "}", ")", ";", "}", "}", "pop", "(", ")", ";", "return", "result", ";", "}" ]

[ "We", "re", "doing", "way", "too", "much", "stuff", "at", "once", "with", "webpack", "et", "al", ".", "So", "much", "stuff", "that", "while", "downloading", "extensions", "from", "the", "marketplace", "node", "js", "doesn", "t", "get", "enough", "stack", "frames", "to", "complete", "the", "download", "in", "under", "2", "minutes", "at", "which", "point", "the", "marketplace", "server", "cuts", "off", "the", "http", "request", ".", "So", "we", "sequentialize", "the", "extensino", "tasks", "." ]

[ "function", "(", "what", ")", "{", "moduleManager", ".", "getRecorder", "(", ")", ".", "record", "(", "33", "/* NodeBeginNativeRequire */", ",", "what", ")", ";", "try", "{", "return", "_nodeRequire_1", "(", "what", ")", ";", "}", "finally", "{", "moduleManager", ".", "getRecorder", "(", ")", ".", "record", "(", "34", "/* NodeEndNativeRequire */", ",", "what", ")", ";", "}", "}" ]

[ "re", "-", "expose", "node", "s", "require", "function" ]

[ "function", "nls", "(", ")", "{", "const", "input", "=", "event_stream_1", ".", "through", "(", ")", ";", "const", "output", "=", "input", ".", "pipe", "(", "event_stream_1", ".", "through", "(", "function", "(", "f", ")", "{", "if", "(", "!", "f", ".", "sourceMap", ")", "{", "return", "this", ".", "emit", "(", "'error'", ",", "new", "Error", "(", "`", "${", "f", ".", "relative", "}", "`", ")", ")", ";", "}", "let", "source", "=", "f", ".", "sourceMap", ".", "sources", "[", "0", "]", ";", "if", "(", "!", "source", ")", "{", "return", "this", ".", "emit", "(", "'error'", ",", "new", "Error", "(", "`", "${", "f", ".", "relative", "}", "`", ")", ")", ";", "}", "const", "root", "=", "f", ".", "sourceMap", ".", "sourceRoot", ";", "if", "(", "root", ")", "{", "source", "=", "path", ".", "join", "(", "root", ",", "source", ")", ";", "}", "const", "typescript", "=", "f", ".", "sourceMap", ".", "sourcesContent", "[", "0", "]", ";", "if", "(", "!", "typescript", ")", "{", "return", "this", ".", "emit", "(", "'error'", ",", "new", "Error", "(", "`", "${", "f", ".", "relative", "}", "`", ")", ")", ";", "}", "nls", ".", "patchFiles", "(", "f", ",", "typescript", ")", ".", "forEach", "(", "f", "=>", "this", ".", "emit", "(", "'data'", ",", "f", ")", ")", ";", "}", ")", ")", ";", "return", "event_stream_1", ".", "duplex", "(", "input", ",", "output", ")", ";", "}" ]

[ "Returns", "a", "stream", "containing", "the", "patched", "JavaScript", "and", "source", "maps", "." ]

[ "function", "bundle", "(", "entryPoints", ",", "config", ",", "callback", ")", "{", "const", "entryPointsMap", "=", "{", "}", ";", "entryPoints", ".", "forEach", "(", "(", "module", ")", "=>", "{", "entryPointsMap", "[", "module", ".", "name", "]", "=", "module", ";", "}", ")", ";", "const", "allMentionedModulesMap", "=", "{", "}", ";", "entryPoints", ".", "forEach", "(", "(", "module", ")", "=>", "{", "allMentionedModulesMap", "[", "module", ".", "name", "]", "=", "true", ";", "(", "module", ".", "include", "||", "[", "]", ")", ".", "forEach", "(", "function", "(", "includedModule", ")", "{", "allMentionedModulesMap", "[", "includedModule", "]", "=", "true", ";", "}", ")", ";", "(", "module", ".", "exclude", "||", "[", "]", ")", ".", "forEach", "(", "function", "(", "excludedModule", ")", "{", "allMentionedModulesMap", "[", "excludedModule", "]", "=", "true", ";", "}", ")", ";", "}", ")", ";", "const", "code", "=", "require", "(", "'fs'", ")", ".", "readFileSync", "(", "path", ".", "join", "(", "__dirname", ",", "'../../src/vs/loader.js'", ")", ")", ";", "const", "r", "=", "vm", ".", "runInThisContext", "(", "'(function(require, module, exports) { '", "+", "code", "+", "'\\n});'", ")", ";", "const", "loaderModule", "=", "{", "exports", ":", "{", "}", "}", ";", "r", ".", "call", "(", "{", "}", ",", "require", ",", "loaderModule", ",", "loaderModule", ".", "exports", ")", ";", "const", "loader", "=", "loaderModule", ".", "exports", ";", "config", ".", "isBuild", "=", "true", ";", "config", ".", "paths", "=", "config", ".", "paths", "||", "{", "}", ";", "if", "(", "!", "config", ".", "paths", "[", "'vs/nls'", "]", ")", "{", "config", ".", "paths", "[", "'vs/nls'", "]", "=", "'out-build/vs/nls.build'", ";", "}", "if", "(", "!", "config", ".", "paths", "[", "'vs/css'", "]", ")", "{", "config", ".", "paths", "[", "'vs/css'", "]", "=", "'out-build/vs/css.build'", ";", "}", "loader", ".", "config", "(", "config", ")", ";", "loader", "(", "[", "'require'", "]", ",", "(", "localRequire", ")", "=>", "{", "const", "resolvePath", "=", "(", "path", ")", "=>", "{", "const", "r", "=", "localRequire", ".", "toUrl", "(", "path", ")", ";", "if", "(", "!", "/", "\\.js", "/", ".", "test", "(", "r", ")", ")", "{", "return", "r", "+", "'.js'", ";", "}", "return", "r", ";", "}", ";", "for", "(", "const", "moduleId", "in", "entryPointsMap", ")", "{", "const", "entryPoint", "=", "entryPointsMap", "[", "moduleId", "]", ";", "if", "(", "entryPoint", ".", "append", ")", "{", "entryPoint", ".", "append", "=", "entryPoint", ".", "append", ".", "map", "(", "resolvePath", ")", ";", "}", "if", "(", "entryPoint", ".", "prepend", ")", "{", "entryPoint", ".", "prepend", "=", "entryPoint", ".", "prepend", ".", "map", "(", "resolvePath", ")", ";", "}", "}", "}", ")", ";", "loader", "(", "Object", ".", "keys", "(", "allMentionedModulesMap", ")", ",", "(", ")", "=>", "{", "const", "modules", "=", "loader", ".", "getBuildInfo", "(", ")", ";", "const", "partialResult", "=", "emitEntryPoints", "(", "modules", ",", "entryPointsMap", ")", ";", "const", "cssInlinedResources", "=", "loader", "(", "'vs/css'", ")", ".", "getInlinedResources", "(", ")", ";", "callback", "(", "null", ",", "{", "files", ":", "partialResult", ".", "files", ",", "cssInlinedResources", ":", "cssInlinedResources", ",", "bundleData", ":", "partialResult", ".", "bundleData", "}", ")", ";", "}", ",", "(", "err", ")", "=>", "callback", "(", "err", ",", "null", ")", ")", ";", "}" ]

[ "Bundle", "entryPoints", "given", "config", "config", "." ]

[ "function", "visit", "(", "rootNodes", ",", "graph", ")", "{", "const", "result", "=", "{", "}", ";", "const", "queue", "=", "rootNodes", ";", "rootNodes", ".", "forEach", "(", "(", "node", ")", "=>", "{", "result", "[", "node", "]", "=", "true", ";", "}", ")", ";", "while", "(", "queue", ".", "length", ">", "0", ")", "{", "const", "el", "=", "queue", ".", "shift", "(", ")", ";", "const", "myEdges", "=", "graph", "[", "el", "]", "||", "[", "]", ";", "myEdges", ".", "forEach", "(", "(", "toNode", ")", "=>", "{", "if", "(", "!", "result", "[", "toNode", "]", ")", "{", "result", "[", "toNode", "]", "=", "true", ";", "queue", ".", "push", "(", "toNode", ")", ";", "}", "}", ")", ";", "}", "return", "result", ";", "}" ]

[ "Return", "a", "set", "of", "reachable", "nodes", "in", "graph", "starting", "from", "rootNodes" ]

[ "function", "topologicalSort", "(", "graph", ")", "{", "const", "allNodes", "=", "{", "}", ",", "outgoingEdgeCount", "=", "{", "}", ",", "inverseEdges", "=", "{", "}", ";", "Object", ".", "keys", "(", "graph", ")", ".", "forEach", "(", "(", "fromNode", ")", "=>", "{", "allNodes", "[", "fromNode", "]", "=", "true", ";", "outgoingEdgeCount", "[", "fromNode", "]", "=", "graph", "[", "fromNode", "]", ".", "length", ";", "graph", "[", "fromNode", "]", ".", "forEach", "(", "(", "toNode", ")", "=>", "{", "allNodes", "[", "toNode", "]", "=", "true", ";", "outgoingEdgeCount", "[", "toNode", "]", "=", "outgoingEdgeCount", "[", "toNode", "]", "||", "0", ";", "inverseEdges", "[", "toNode", "]", "=", "inverseEdges", "[", "toNode", "]", "||", "[", "]", ";", "inverseEdges", "[", "toNode", "]", ".", "push", "(", "fromNode", ")", ";", "}", ")", ";", "}", ")", ";", "// https://en.wikipedia.org/wiki/Topological_sorting", "const", "S", "=", "[", "]", ",", "L", "=", "[", "]", ";", "Object", ".", "keys", "(", "allNodes", ")", ".", "forEach", "(", "(", "node", ")", "=>", "{", "if", "(", "outgoingEdgeCount", "[", "node", "]", "===", "0", ")", "{", "delete", "outgoingEdgeCount", "[", "node", "]", ";", "S", ".", "push", "(", "node", ")", ";", "}", "}", ")", ";", "while", "(", "S", ".", "length", ">", "0", ")", "{", "// Ensure the exact same order all the time with the same inputs", "S", ".", "sort", "(", ")", ";", "const", "n", "=", "S", ".", "shift", "(", ")", ";", "L", ".", "push", "(", "n", ")", ";", "const", "myInverseEdges", "=", "inverseEdges", "[", "n", "]", "||", "[", "]", ";", "myInverseEdges", ".", "forEach", "(", "(", "m", ")", "=>", "{", "outgoingEdgeCount", "[", "m", "]", "--", ";", "if", "(", "outgoingEdgeCount", "[", "m", "]", "===", "0", ")", "{", "delete", "outgoingEdgeCount", "[", "m", "]", ";", "S", ".", "push", "(", "m", ")", ";", "}", "}", ")", ";", "}", "if", "(", "Object", ".", "keys", "(", "outgoingEdgeCount", ")", ".", "length", ">", "0", ")", "{", "throw", "new", "Error", "(", "'Cannot do topological sort on cyclic graph, remaining nodes: '", "+", "Object", ".", "keys", "(", "outgoingEdgeCount", ")", ")", ";", "}", "return", "L", ";", "}" ]

[ "Perform", "a", "topological", "sort", "on", "graph" ]

[ "function", "getVersion", "(", "repo", ")", "{", "const", "git", "=", "path", ".", "join", "(", "repo", ",", "'.git'", ")", ";", "const", "headPath", "=", "path", ".", "join", "(", "git", ",", "'HEAD'", ")", ";", "let", "head", ";", "try", "{", "head", "=", "fs", ".", "readFileSync", "(", "headPath", ",", "'utf8'", ")", ".", "trim", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "undefined", ";", "}", "if", "(", "/", "^[0-9a-f]{40}$", "/", "i", ".", "test", "(", "head", ")", ")", "{", "return", "head", ";", "}", "const", "refMatch", "=", "/", "^ref: (.*)$", "/", ".", "exec", "(", "head", ")", ";", "if", "(", "!", "refMatch", ")", "{", "return", "undefined", ";", "}", "const", "ref", "=", "refMatch", "[", "1", "]", ";", "const", "refPath", "=", "path", ".", "join", "(", "git", ",", "ref", ")", ";", "try", "{", "return", "fs", ".", "readFileSync", "(", "refPath", ",", "'utf8'", ")", ".", "trim", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "// noop", "}", "const", "packedRefsPath", "=", "path", ".", "join", "(", "git", ",", "'packed-refs'", ")", ";", "let", "refsRaw", ";", "try", "{", "refsRaw", "=", "fs", ".", "readFileSync", "(", "packedRefsPath", ",", "'utf8'", ")", ".", "trim", "(", ")", ";", "}", "catch", "(", "e", ")", "{", "return", "undefined", ";", "}", "const", "refsRegex", "=", "/", "^([0-9a-f]{40})\\s+(.+)$", "/", "gm", ";", "let", "refsMatch", ";", "let", "refs", "=", "{", "}", ";", "while", "(", "refsMatch", "=", "refsRegex", ".", "exec", "(", "refsRaw", ")", ")", "{", "refs", "[", "refsMatch", "[", "2", "]", "]", "=", "refsMatch", "[", "1", "]", ";", "}", "return", "refs", "[", "ref", "]", ";", "}" ]

[ "Returns", "the", "sha1", "commit", "version", "of", "a", "repository", "or", "undefined", "in", "case", "of", "failure", "." ]

[ "function", "safeToArray", "(", "args", ")", "{", "const", "seen", "=", "[", "]", ";", "const", "argsArray", "=", "[", "]", ";", "let", "res", ";", "// Massage some arguments with special treatment", "if", "(", "args", ".", "length", ")", "{", "for", "(", "let", "i", "=", "0", ";", "i", "<", "args", ".", "length", ";", "i", "++", ")", "{", "// Any argument of type 'undefined' needs to be specially treated because", "// JSON.stringify will simply ignore those. We replace them with the string", "// 'undefined' which is not 100% right, but good enough to be logged to console", "if", "(", "typeof", "args", "[", "i", "]", "===", "'undefined'", ")", "{", "args", "[", "i", "]", "=", "'undefined'", ";", "}", "// Any argument that is an Error will be changed to be just the error stack/message", "// itself because currently cannot serialize the error over entirely.", "else", "if", "(", "args", "[", "i", "]", "instanceof", "Error", ")", "{", "const", "errorObj", "=", "args", "[", "i", "]", ";", "if", "(", "errorObj", ".", "stack", ")", "{", "args", "[", "i", "]", "=", "errorObj", ".", "stack", ";", "}", "else", "{", "args", "[", "i", "]", "=", "errorObj", ".", "toString", "(", ")", ";", "}", "}", "argsArray", ".", "push", "(", "args", "[", "i", "]", ")", ";", "}", "}", "// Add the stack trace as payload if we are told so. We remove the message and the 2 top frames", "// to start the stacktrace where the console message was being written", "if", "(", "process", ".", "env", ".", "VSCODE_LOG_STACK", "===", "'true'", ")", "{", "const", "stack", "=", "new", "Error", "(", ")", ".", "stack", ";", "argsArray", ".", "push", "(", "{", "__$stack", ":", "stack", ".", "split", "(", "'\\n'", ")", ".", "slice", "(", "3", ")", ".", "join", "(", "'\\n'", ")", "}", ")", ";", "}", "try", "{", "res", "=", "JSON", ".", "stringify", "(", "argsArray", ",", "function", "(", "key", ",", "value", ")", "{", "// Objects get special treatment to prevent circles", "if", "(", "isObject", "(", "value", ")", "||", "Array", ".", "isArray", "(", "value", ")", ")", "{", "if", "(", "seen", ".", "indexOf", "(", "value", ")", "!==", "-", "1", ")", "{", "return", "'[Circular]'", ";", "}", "seen", ".", "push", "(", "value", ")", ";", "}", "return", "value", ";", "}", ")", ";", "}", "catch", "(", "error", ")", "{", "return", "'Output omitted for an object that cannot be inspected ('", "+", "error", ".", "toString", "(", ")", "+", "')'", ";", "}", "if", "(", "res", "&&", "res", ".", "length", ">", "MAX_LENGTH", ")", "{", "return", "'Output omitted for a large object that exceeds the limits'", ";", "}", "return", "res", ";", "}" ]

[ "Prevent", "circular", "stringify", "and", "convert", "arguments", "to", "real", "array" ]

[ "function", "computeChecksums", "(", "out", ",", "filenames", ")", "{", "var", "result", "=", "{", "}", ";", "filenames", ".", "forEach", "(", "function", "(", "filename", ")", "{", "var", "fullPath", "=", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "out", ",", "filename", ")", ";", "result", "[", "filename", "]", "=", "computeChecksum", "(", "fullPath", ")", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Compute", "checksums", "for", "some", "files", "." ]

[ "function", "computeChecksum", "(", "filename", ")", "{", "var", "contents", "=", "fs", ".", "readFileSync", "(", "filename", ")", ";", "var", "hash", "=", "crypto", ".", "createHash", "(", "'md5'", ")", ".", "update", "(", "contents", ")", ".", "digest", "(", "'base64'", ")", ".", "replace", "(", "/", "=+$", "/", ",", "''", ")", ";", "return", "hash", ";", "}" ]

[ "Compute", "checksum", "for", "a", "file", "." ]

[ "function", "readProperty", "(", "obj", ",", "propertySegments", ",", "index", ")", "{", "const", "value", "=", "obj", "[", "propertySegments", "[", "index", "]", "]", ";", "return", "!", "!", "value", "&&", "(", "index", "===", "propertySegments", ".", "length", "-", "1", "||", "readProperty", "(", "value", ",", "propertySegments", ",", "index", "+", "1", ")", ")", ";", "}" ]

[ "Search", "deeply", "into", "an", "object", "via", "a", "collection", "of", "property", "segments", "starting", "at", "the", "indexed", "segment", "." ]

[ "function", "generateLocale", "(", "locale", ",", "localeData", ",", "baseCurrencies", ")", "{", "// [ localeId, dateTime, number, currency, pluralCase ]", "let", "data", "=", "stringify", "(", "[", "locale", ",", "...", "getDateTimeTranslations", "(", "localeData", ")", ",", "...", "getDateTimeSettings", "(", "localeData", ")", ",", "...", "getNumberSettings", "(", "localeData", ")", ",", "...", "getCurrencySettings", "(", "locale", ",", "localeData", ")", ",", "generateLocaleCurrencies", "(", "localeData", ",", "baseCurrencies", ")", "]", ",", "true", ")", "// We remove \"undefined\" added by spreading arrays when there is no value", ".", "replace", "(", "/", "undefined", "/", "g", ",", "'u'", ")", ";", "// adding plural function after, because we don't want it as a string", "data", "=", "data", ".", "substring", "(", "0", ",", "data", ".", "lastIndexOf", "(", "']'", ")", ")", "+", "`", "`", ";", "return", "`", "${", "HEADER", "}", "${", "getPluralFunction", "(", "locale", ")", "}", "${", "data", "}", "`", ";", "}" ]

[ "Generate", "file", "that", "contains", "basic", "locale", "data" ]

[ "function", "generateLocaleCurrencies", "(", "localeData", ",", "baseCurrencies", ")", "{", "const", "currenciesData", "=", "localeData", ".", "main", "(", "'numbers/currencies'", ")", ";", "const", "currencies", "=", "{", "}", ";", "Object", ".", "keys", "(", "currenciesData", ")", ".", "forEach", "(", "code", "=>", "{", "let", "symbolsArray", "=", "[", "]", ";", "const", "symbol", "=", "currenciesData", "[", "code", "]", ".", "symbol", ";", "const", "symbolNarrow", "=", "currenciesData", "[", "code", "]", "[", "'symbol-alt-narrow'", "]", ";", "if", "(", "symbol", "&&", "symbol", "!==", "code", ")", "{", "symbolsArray", ".", "push", "(", "symbol", ")", ";", "}", "if", "(", "symbolNarrow", "&&", "symbolNarrow", "!==", "symbol", ")", "{", "if", "(", "symbolsArray", ".", "length", ">", "0", ")", "{", "symbolsArray", ".", "push", "(", "symbolNarrow", ")", ";", "}", "else", "{", "symbolsArray", "=", "[", "undefined", ",", "symbolNarrow", "]", ";", "}", "}", "// if locale data are different, set the value", "if", "(", "(", "baseCurrencies", "[", "code", "]", "||", "[", "]", ")", ".", "toString", "(", ")", "!==", "symbolsArray", ".", "toString", "(", ")", ")", "{", "currencies", "[", "code", "]", "=", "symbolsArray", ";", "}", "}", ")", ";", "return", "currencies", ";", "}" ]

[ "To", "minimize", "the", "file", "even", "more", "we", "only", "output", "the", "differences", "compared", "to", "the", "base", "currency" ]

[ "function", "getDayPeriods", "(", "localeData", ",", "dayPeriodsList", ")", "{", "const", "dayPeriods", "=", "localeData", ".", "main", "(", "`", "`", ")", ";", "const", "result", "=", "{", "}", ";", "// cleaning up unused keys", "Object", ".", "keys", "(", "dayPeriods", ")", ".", "forEach", "(", "key1", "=>", "{", "// format / stand-alone", "result", "[", "key1", "]", "=", "{", "}", ";", "Object", ".", "keys", "(", "dayPeriods", "[", "key1", "]", ")", ".", "forEach", "(", "key2", "=>", "{", "// narrow / abbreviated / wide", "result", "[", "key1", "]", "[", "key2", "]", "=", "{", "}", ";", "Object", ".", "keys", "(", "dayPeriods", "[", "key1", "]", "[", "key2", "]", ")", ".", "forEach", "(", "key3", "=>", "{", "if", "(", "dayPeriodsList", ".", "indexOf", "(", "key3", ")", "!==", "-", "1", ")", "{", "result", "[", "key1", "]", "[", "key2", "]", "[", "key3", "]", "=", "dayPeriods", "[", "key1", "]", "[", "key2", "]", "[", "key3", "]", ";", "}", "}", ")", ";", "}", ")", ";", "}", ")", ";", "return", "result", ";", "}" ]

[ "Returns", "data", "for", "the", "chosen", "day", "periods" ]

[ "function", "getDateTimeTranslations", "(", "localeData", ")", "{", "const", "dayNames", "=", "localeData", ".", "main", "(", "`", "`", ")", ";", "const", "monthNames", "=", "localeData", ".", "main", "(", "`", "`", ")", ";", "const", "erasNames", "=", "localeData", ".", "main", "(", "`", "`", ")", ";", "const", "dayPeriods", "=", "getDayPeriodsAmPm", "(", "localeData", ")", ";", "const", "dayPeriodsFormat", "=", "removeDuplicates", "(", "[", "objectValues", "(", "dayPeriods", ".", "format", ".", "narrow", ")", ",", "objectValues", "(", "dayPeriods", ".", "format", ".", "abbreviated", ")", ",", "objectValues", "(", "dayPeriods", ".", "format", ".", "wide", ")", "]", ")", ";", "const", "dayPeriodsStandalone", "=", "removeDuplicates", "(", "[", "objectValues", "(", "dayPeriods", "[", "'stand-alone'", "]", ".", "narrow", ")", ",", "objectValues", "(", "dayPeriods", "[", "'stand-alone'", "]", ".", "abbreviated", ")", ",", "objectValues", "(", "dayPeriods", "[", "'stand-alone'", "]", ".", "wide", ")", "]", ")", ";", "const", "daysFormat", "=", "removeDuplicates", "(", "[", "objectValues", "(", "dayNames", ".", "format", ".", "narrow", ")", ",", "objectValues", "(", "dayNames", ".", "format", ".", "abbreviated", ")", ",", "objectValues", "(", "dayNames", ".", "format", ".", "wide", ")", ",", "objectValues", "(", "dayNames", ".", "format", ".", "short", ")", "]", ")", ";", "const", "daysStandalone", "=", "removeDuplicates", "(", "[", "objectValues", "(", "dayNames", "[", "'stand-alone'", "]", ".", "narrow", ")", ",", "objectValues", "(", "dayNames", "[", "'stand-alone'", "]", ".", "abbreviated", ")", ",", "objectValues", "(", "dayNames", "[", "'stand-alone'", "]", ".", "wide", ")", ",", "objectValues", "(", "dayNames", "[", "'stand-alone'", "]", ".", "short", ")", "]", ")", ";", "const", "monthsFormat", "=", "removeDuplicates", "(", "[", "objectValues", "(", "monthNames", ".", "format", ".", "narrow", ")", ",", "objectValues", "(", "monthNames", ".", "format", ".", "abbreviated", ")", ",", "objectValues", "(", "monthNames", ".", "format", ".", "wide", ")", "]", ")", ";", "const", "monthsStandalone", "=", "removeDuplicates", "(", "[", "objectValues", "(", "monthNames", "[", "'stand-alone'", "]", ".", "narrow", ")", ",", "objectValues", "(", "monthNames", "[", "'stand-alone'", "]", ".", "abbreviated", ")", ",", "objectValues", "(", "monthNames", "[", "'stand-alone'", "]", ".", "wide", ")", "]", ")", ";", "const", "eras", "=", "removeDuplicates", "(", "[", "[", "erasNames", ".", "eraNarrow", "[", "'0'", "]", ",", "erasNames", ".", "eraNarrow", "[", "'1'", "]", "]", ",", "[", "erasNames", ".", "eraAbbr", "[", "'0'", "]", ",", "erasNames", ".", "eraAbbr", "[", "'1'", "]", "]", ",", "[", "erasNames", ".", "eraNames", "[", "'0'", "]", ",", "erasNames", ".", "eraNames", "[", "'1'", "]", "]", "]", ")", ";", "const", "dateTimeTranslations", "=", "[", "...", "removeDuplicates", "(", "[", "dayPeriodsFormat", ",", "dayPeriodsStandalone", "]", ")", ",", "...", "removeDuplicates", "(", "[", "daysFormat", ",", "daysStandalone", "]", ")", ",", "...", "removeDuplicates", "(", "[", "monthsFormat", ",", "monthsStandalone", "]", ")", ",", "eras", "]", ";", "return", "dateTimeTranslations", ";", "}" ]

[ "Returns", "date", "-", "related", "translations", "for", "a", "locale" ]

[ "function", "getDateTimeFormats", "(", "localeData", ")", "{", "function", "getFormats", "(", "data", ")", "{", "return", "removeDuplicates", "(", "[", "data", ".", "short", ".", "_value", "||", "data", ".", "short", ",", "data", ".", "medium", ".", "_value", "||", "data", ".", "medium", ",", "data", ".", "long", ".", "_value", "||", "data", ".", "long", ",", "data", ".", "full", ".", "_value", "||", "data", ".", "full", "]", ")", ";", "}", "const", "dateFormats", "=", "localeData", ".", "main", "(", "'dates/calendars/gregorian/dateFormats'", ")", ";", "const", "timeFormats", "=", "localeData", ".", "main", "(", "'dates/calendars/gregorian/timeFormats'", ")", ";", "const", "dateTimeFormats", "=", "localeData", ".", "main", "(", "'dates/calendars/gregorian/dateTimeFormats'", ")", ";", "return", "[", "getFormats", "(", "dateFormats", ")", ",", "getFormats", "(", "timeFormats", ")", ",", "getFormats", "(", "dateTimeFormats", ")", "]", ";", "}" ]

[ "Returns", "date", "time", "and", "dateTime", "formats", "for", "a", "locale" ]

[ "function", "getDayPeriodRules", "(", "localeData", ")", "{", "const", "dayPeriodRules", "=", "localeData", ".", "get", "(", "`", "${", "localeData", ".", "attributes", ".", "language", "}", "`", ")", ";", "const", "rules", "=", "{", "}", ";", "if", "(", "dayPeriodRules", ")", "{", "Object", ".", "keys", "(", "dayPeriodRules", ")", ".", "forEach", "(", "key", "=>", "{", "if", "(", "dayPeriodRules", "[", "key", "]", ".", "_at", ")", "{", "rules", "[", "key", "]", "=", "dayPeriodRules", "[", "key", "]", ".", "_at", ";", "}", "else", "{", "rules", "[", "key", "]", "=", "[", "dayPeriodRules", "[", "key", "]", ".", "_from", ",", "dayPeriodRules", "[", "key", "]", ".", "_before", "]", ";", "}", "}", ")", ";", "}", "return", "rules", ";", "}" ]

[ "Returns", "day", "period", "rules", "for", "a", "locale" ]

[ "function", "getWeekendRange", "(", "localeData", ")", "{", "const", "startDay", "=", "localeData", ".", "get", "(", "`", "${", "localeData", ".", "attributes", ".", "territory", "}", "`", ")", "||", "localeData", ".", "get", "(", "'supplemental/weekData/weekendStart/001'", ")", ";", "const", "endDay", "=", "localeData", ".", "get", "(", "`", "${", "localeData", ".", "attributes", ".", "territory", "}", "`", ")", "||", "localeData", ".", "get", "(", "'supplemental/weekData/weekendEnd/001'", ")", ";", "return", "[", "WEEK_DAYS", ".", "indexOf", "(", "startDay", ")", ",", "WEEK_DAYS", ".", "indexOf", "(", "endDay", ")", "]", ";", "}" ]

[ "Returns", "week", "-", "end", "range", "for", "a", "locale", "based", "on", "US", "week", "days" ]

[ "function", "getNumberSettings", "(", "localeData", ")", "{", "const", "decimalFormat", "=", "localeData", ".", "main", "(", "'numbers/decimalFormats-numberSystem-latn/standard'", ")", ";", "const", "percentFormat", "=", "localeData", ".", "main", "(", "'numbers/percentFormats-numberSystem-latn/standard'", ")", ";", "const", "scientificFormat", "=", "localeData", ".", "main", "(", "'numbers/scientificFormats-numberSystem-latn/standard'", ")", ";", "const", "currencyFormat", "=", "localeData", ".", "main", "(", "'numbers/currencyFormats-numberSystem-latn/standard'", ")", ";", "const", "symbols", "=", "localeData", ".", "main", "(", "'numbers/symbols-numberSystem-latn'", ")", ";", "const", "symbolValues", "=", "[", "symbols", ".", "decimal", ",", "symbols", ".", "group", ",", "symbols", ".", "list", ",", "symbols", ".", "percentSign", ",", "symbols", ".", "plusSign", ",", "symbols", ".", "minusSign", ",", "symbols", ".", "exponential", ",", "symbols", ".", "superscriptingExponent", ",", "symbols", ".", "perMille", ",", "symbols", ".", "infinity", ",", "symbols", ".", "nan", ",", "symbols", ".", "timeSeparator", ",", "]", ";", "if", "(", "symbols", ".", "currencyDecimal", "||", "symbols", ".", "currencyGroup", ")", "{", "symbolValues", ".", "push", "(", "symbols", ".", "currencyDecimal", ")", ";", "}", "if", "(", "symbols", ".", "currencyGroup", ")", "{", "symbolValues", ".", "push", "(", "symbols", ".", "currencyGroup", ")", ";", "}", "return", "[", "symbolValues", ",", "[", "decimalFormat", ",", "percentFormat", ",", "currencyFormat", ",", "scientificFormat", "]", "]", ";", "}" ]

[ "Returns", "the", "number", "symbols", "and", "formats", "for", "a", "locale" ]

[ "function", "getCurrencySettings", "(", "locale", ",", "localeData", ")", "{", "const", "currencyInfo", "=", "localeData", ".", "main", "(", "`", "`", ")", ";", "let", "currentCurrency", "=", "''", ";", "// find the currency currently used in this country", "const", "currencies", "=", "localeData", ".", "get", "(", "`", "${", "localeData", ".", "attributes", ".", "territory", "}", "`", ")", "||", "localeData", ".", "get", "(", "`", "${", "localeData", ".", "attributes", ".", "language", ".", "toUpperCase", "(", ")", "}", "`", ")", ";", "if", "(", "currencies", ")", "{", "currencies", ".", "some", "(", "currency", "=>", "{", "const", "keys", "=", "Object", ".", "keys", "(", "currency", ")", ";", "return", "keys", ".", "some", "(", "key", "=>", "{", "if", "(", "currency", "[", "key", "]", ".", "_from", "&&", "!", "currency", "[", "key", "]", ".", "_to", ")", "{", "return", "currentCurrency", "=", "key", ";", "}", "}", ")", ";", "}", ")", ";", "if", "(", "!", "currentCurrency", ")", "{", "throw", "new", "Error", "(", "`", "${", "locale", "}", "`", ")", ";", "}", "}", "let", "currencySettings", "=", "[", "undefined", ",", "undefined", "]", ";", "if", "(", "currentCurrency", ")", "{", "currencySettings", "=", "[", "currencyInfo", "[", "currentCurrency", "]", ".", "symbol", ",", "currencyInfo", "[", "currentCurrency", "]", ".", "displayName", "]", ";", "}", "return", "currencySettings", ";", "}" ]

[ "Returns", "the", "currency", "symbol", "and", "name", "for", "a", "locale" ]

[ "function", "_deleteDir", "(", "path", ")", "{", "if", "(", "fs", ".", "existsSync", "(", "path", ")", ")", "{", "var", "subpaths", "=", "fs", ".", "readdirSync", "(", "path", ")", ";", "subpaths", ".", "forEach", "(", "function", "(", "subpath", ")", "{", "var", "curPath", "=", "path", "+", "'/'", "+", "subpath", ";", "if", "(", "fs", ".", "lstatSync", "(", "curPath", ")", ".", "isDirectory", "(", ")", ")", "{", "_deleteDir", "(", "curPath", ")", ";", "}", "else", "{", "fs", ".", "unlinkSync", "(", "curPath", ")", ";", "}", "}", ")", ";", "fs", ".", "rmdirSync", "(", "path", ")", ";", "}", "}" ]

[ "Custom", "implementation", "of", "recursive", "rm", "because", "we", "can", "t", "rely", "on", "the", "state", "of", "node_modules", "to", "pull", "in", "existing", "module", "." ]

[ "function", "generateAllLocalesFile", "(", "LOCALES", ",", "ALIASES", ")", "{", "const", "existingLocalesAliases", "=", "{", "}", ";", "const", "existingLocalesData", "=", "{", "}", ";", "// for each locale, get the data and the list of equivalent locales", "LOCALES", ".", "forEach", "(", "locale", "=>", "{", "const", "eqLocales", "=", "new", "Set", "(", ")", ";", "eqLocales", ".", "add", "(", "locale", ")", ";", "if", "(", "locale", ".", "match", "(", "/", "-", "/", ")", ")", "{", "eqLocales", ".", "add", "(", "locale", ".", "replace", "(", "/", "-", "/", "g", ",", "'_'", ")", ")", ";", "}", "// check for aliases", "const", "alias", "=", "ALIASES", "[", "locale", "]", ";", "if", "(", "alias", ")", "{", "eqLocales", ".", "add", "(", "alias", ")", ";", "if", "(", "alias", ".", "match", "(", "/", "-", "/", ")", ")", "{", "eqLocales", ".", "add", "(", "alias", ".", "replace", "(", "/", "-", "/", "g", ",", "'_'", ")", ")", ";", "}", "// to avoid duplicated \"case\" we regroup all locales in the same \"case\"", "// the simplest way to do that is to have alias aliases", "// e.g. 'no' --> 'nb', 'nb' --> 'no-NO'", "// which means that we'll have 'no', 'nb' and 'no-NO' in the same \"case\"", "const", "aliasKeys", "=", "Object", ".", "keys", "(", "ALIASES", ")", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "aliasKeys", ".", "length", ";", "i", "++", ")", "{", "const", "aliasValue", "=", "ALIASES", "[", "alias", "]", ";", "if", "(", "aliasKeys", ".", "indexOf", "(", "alias", ")", "!==", "-", "1", "&&", "!", "eqLocales", ".", "has", "(", "aliasValue", ")", ")", "{", "eqLocales", ".", "add", "(", "aliasValue", ")", ";", "if", "(", "aliasValue", ".", "match", "(", "/", "-", "/", ")", ")", "{", "eqLocales", ".", "add", "(", "aliasValue", ".", "replace", "(", "/", "-", "/", "g", ",", "'_'", ")", ")", ";", "}", "}", "}", "}", "for", "(", "let", "l", "of", "eqLocales", ")", "{", "// find the existing content file", "const", "path", "=", "`", "${", "RELATIVE_I18N_DATA_FOLDER", "}", "${", "l", "}", "`", ";", "if", "(", "fs", ".", "existsSync", "(", "`", "${", "RELATIVE_I18N_DATA_FOLDER", "}", "${", "l", "}", "`", ")", ")", "{", "const", "localeName", "=", "formatLocale", "(", "locale", ")", ";", "existingLocalesData", "[", "locale", "]", "=", "fs", ".", "readFileSync", "(", "path", ",", "'utf8'", ")", ".", "replace", "(", "`", "${", "HEADER", "}", "\\n", "`", ",", "''", ")", ".", "replace", "(", "'export default '", ",", "`", "${", "localeName", "}", "`", ")", ".", "replace", "(", "'function plural'", ",", "`", "${", "localeName", "}", "`", ")", ".", "replace", "(", "/", ",(\\n | )plural", "/", ",", "`", "${", "localeName", "}", "`", ")", ".", "replace", "(", "'const u = undefined;\\n\\n'", ",", "''", ")", ";", "}", "}", "existingLocalesAliases", "[", "locale", "]", "=", "eqLocales", ";", "}", ")", ";", "function", "generateCases", "(", "locale", ")", "{", "let", "str", "=", "''", ";", "let", "locales", "=", "[", "]", ";", "const", "eqLocales", "=", "existingLocalesAliases", "[", "locale", "]", ";", "for", "(", "let", "l", "of", "eqLocales", ")", "{", "str", "+=", "`", "${", "l", "}", "\\n", "`", ";", "locales", ".", "push", "(", "`", "${", "l", "}", "`", ")", ";", "}", "let", "localesStr", "=", "'['", "+", "locales", ".", "join", "(", "','", ")", "+", "']'", ";", "str", "+=", "`", "${", "formatLocale", "(", "locale", ")", "}", "${", "localesStr", "}", "\\n", "`", ";", "return", "str", ";", "}", "function", "formatLocale", "(", "locale", ")", "{", "return", "locale", ".", "replace", "(", "/", "-", "/", "g", ",", "'_'", ")", ";", "}", "// clang-format off", "return", "`", "${", "HEADER", "}", "${", "LOCALES", ".", "map", "(", "locale", "=>", "`", "${", "existingLocalesData", "[", "locale", "]", "}", "`", ")", ".", "join", "(", "'\\n'", ")", "}", "${", "LOCALES", ".", "map", "(", "locale", "=>", "generateCases", "(", "locale", ")", ")", ".", "join", "(", "''", ")", "}", "`", ";", "// clang-format on", "}" ]

[ "Generate", "a", "file", "that", "contains", "all", "locale", "to", "import", "for", "closure", ".", "Tree", "shaking", "will", "only", "keep", "the", "data", "for", "the", "goog", ".", "LOCALE", "locale", "." ]

[ "function", "inlineTagDefs", "(", ")", "{", "const", "Parser", "=", "this", ".", "Parser", ";", "const", "inlineTokenizers", "=", "Parser", ".", "prototype", ".", "inlineTokenizers", ";", "const", "inlineMethods", "=", "Parser", ".", "prototype", ".", "inlineMethods", ";", "const", "blockTokenizers", "=", "Parser", ".", "prototype", ".", "blockTokenizers", ";", "const", "blockMethods", "=", "Parser", ".", "prototype", ".", "blockMethods", ";", "blockTokenizers", ".", "inlineTag", "=", "tokenizeInlineTag", ";", "blockMethods", ".", "splice", "(", "blockMethods", ".", "indexOf", "(", "'paragraph'", ")", ",", "0", ",", "'inlineTag'", ")", ";", "inlineTokenizers", ".", "inlineTag", "=", "tokenizeInlineTag", ";", "inlineMethods", ".", "splice", "(", "blockMethods", ".", "indexOf", "(", "'text'", ")", ",", "0", ",", "'inlineTag'", ")", ";", "tokenizeInlineTag", ".", "notInLink", "=", "true", ";", "tokenizeInlineTag", ".", "locator", "=", "inlineTagLocator", ";", "function", "tokenizeInlineTag", "(", "eat", ",", "value", ",", "silent", ")", "{", "const", "match", "=", "/", "^\\{@[^\\s\\}]+[^\\}]*\\}", "/", ".", "exec", "(", "value", ")", ";", "if", "(", "match", ")", "{", "if", "(", "silent", ")", "{", "return", "true", ";", "}", "return", "eat", "(", "match", "[", "0", "]", ")", "(", "{", "'type'", ":", "'inlineTag'", ",", "'value'", ":", "match", "[", "0", "]", "}", ")", ";", "}", "}", "function", "inlineTagLocator", "(", "value", ",", "fromIndex", ")", "{", "return", "value", ".", "indexOf", "(", "'{@'", ",", "fromIndex", ")", ";", "}", "}" ]

[ "Teach", "remark", "about", "inline", "tags", "so", "that", "it", "neither", "wraps", "block", "level", "tags", "in", "paragraphs", "nor", "processes", "the", "text", "within", "the", "tag", "." ]

[ "function", "plainHTMLBlocks", "(", ")", "{", "const", "plainBlocks", "=", "[", "'code-example'", ",", "'code-tabs'", "]", ";", "// Create matchers for each block", "const", "anyBlockMatcher", "=", "new", "RegExp", "(", "'^'", "+", "createOpenMatcher", "(", "`", "${", "plainBlocks", ".", "join", "(", "'|'", ")", "}", "`", ")", ")", ";", "const", "Parser", "=", "this", ".", "Parser", ";", "const", "blockTokenizers", "=", "Parser", ".", "prototype", ".", "blockTokenizers", ";", "const", "blockMethods", "=", "Parser", ".", "prototype", ".", "blockMethods", ";", "blockTokenizers", ".", "plainHTMLBlocks", "=", "tokenizePlainHTMLBlocks", ";", "blockMethods", ".", "splice", "(", "blockMethods", ".", "indexOf", "(", "'html'", ")", ",", "0", ",", "'plainHTMLBlocks'", ")", ";", "function", "tokenizePlainHTMLBlocks", "(", "eat", ",", "value", ",", "silent", ")", "{", "const", "openMatch", "=", "anyBlockMatcher", ".", "exec", "(", "value", ")", ";", "if", "(", "openMatch", ")", "{", "const", "blockName", "=", "openMatch", "[", "1", "]", ";", "try", "{", "const", "fullMatch", "=", "matchRecursiveRegExp", "(", "value", ",", "createOpenMatcher", "(", "blockName", ")", ",", "createCloseMatcher", "(", "blockName", ")", ")", "[", "0", "]", ";", "if", "(", "silent", "||", "!", "fullMatch", ")", "{", "// either we are not eating (silent) or the match failed", "return", "!", "!", "fullMatch", ";", "}", "return", "eat", "(", "fullMatch", "[", "0", "]", ")", "(", "{", "type", ":", "'html'", ",", "value", ":", "fullMatch", "[", "0", "]", "}", ")", ";", "}", "catch", "(", "e", ")", "{", "this", ".", "file", ".", "fail", "(", "'Unmatched plain HTML block tag '", "+", "e", ".", "message", ")", ";", "}", "}", "}", "}" ]

[ "Teach", "remark", "that", "some", "HTML", "blocks", "never", "include", "markdown" ]

[ "function", "setConf", "(", "conf", ",", "name", ",", "value", ",", "msg", ")", "{", "if", "(", "conf", "[", "name", "]", "&&", "conf", "[", "name", "]", "!==", "value", ")", "{", "console", ".", "warn", "(", "`", "${", "name", "}", "${", "msg", "}", "`", ")", ";", "}", "conf", "[", "name", "]", "=", "value", ";", "}" ]

[ "Helper", "function", "to", "warn", "when", "a", "user", "specified", "value", "is", "being", "overwritten" ]

[ "function", "runProtractorAoT", "(", "appDir", ",", "outputFile", ")", "{", "fs", ".", "appendFileSync", "(", "outputFile", ",", "'++ AoT version ++\\n'", ")", ";", "const", "aotBuildSpawnInfo", "=", "spawnExt", "(", "'yarn'", ",", "[", "'build:aot'", "]", ",", "{", "cwd", ":", "appDir", "}", ")", ";", "let", "promise", "=", "aotBuildSpawnInfo", ".", "promise", ";", "const", "copyFileCmd", "=", "'copy-dist-files.js'", ";", "if", "(", "fs", ".", "existsSync", "(", "appDir", "+", "'/'", "+", "copyFileCmd", ")", ")", "{", "promise", "=", "promise", ".", "then", "(", "(", ")", "=>", "spawnExt", "(", "'node'", ",", "[", "copyFileCmd", "]", ",", "{", "cwd", ":", "appDir", "}", ")", ".", "promise", ")", ";", "}", "const", "aotRunSpawnInfo", "=", "spawnExt", "(", "'yarn'", ",", "[", "'serve:aot'", "]", ",", "{", "cwd", ":", "appDir", "}", ",", "true", ")", ";", "return", "runProtractorSystemJS", "(", "promise", ",", "appDir", ",", "aotRunSpawnInfo", ",", "outputFile", ")", ";", "}" ]

[ "Run", "e2e", "tests", "over", "the", "AOT", "build", "for", "projects", "that", "examples", "it", "." ]

[ "function", "loadExampleConfig", "(", "exampleFolder", ")", "{", "// Default config.", "let", "config", "=", "{", "build", ":", "'build'", ",", "run", ":", "'serve:e2e'", "}", ";", "try", "{", "const", "exampleConfig", "=", "fs", ".", "readJsonSync", "(", "`", "${", "exampleFolder", "}", "${", "EXAMPLE_CONFIG_FILENAME", "}", "`", ")", ";", "Object", ".", "assign", "(", "config", ",", "exampleConfig", ")", ";", "}", "catch", "(", "e", ")", "{", "}", "return", "config", ";", "}" ]

[ "Load", "configuration", "for", "an", "example", ".", "Used", "for", "SystemJS" ]

[ "function", "formatOutput", "(", "output", ")", "{", "var", "indent", "=", "' '", ";", "var", "pad", "=", "' '", ";", "var", "results", "=", "[", "]", ";", "results", ".", "push", "(", "'AppDir:'", "+", "output", ".", "appDir", ")", ";", "output", ".", "suites", ".", "forEach", "(", "function", "(", "suite", ")", "{", "results", ".", "push", "(", "pad", "+", "'Suite: '", "+", "suite", ".", "description", "+", "' -- '", "+", "suite", ".", "status", ")", ";", "pad", "+=", "indent", ";", "suite", ".", "specs", ".", "forEach", "(", "function", "(", "spec", ")", "{", "results", ".", "push", "(", "pad", "+", "spec", ".", "status", "+", "' - '", "+", "spec", ".", "description", ")", ";", "if", "(", "spec", ".", "failedExpectations", ")", "{", "pad", "+=", "indent", ";", "spec", ".", "failedExpectations", ".", "forEach", "(", "function", "(", "fe", ")", "{", "results", ".", "push", "(", "pad", "+", "'message: '", "+", "fe", ".", "message", ")", ";", "}", ")", ";", "pad", "=", "pad", ".", "substr", "(", "2", ")", ";", "}", "}", ")", ";", "pad", "=", "pad", ".", "substr", "(", "2", ")", ";", "results", ".", "push", "(", "''", ")", ";", "}", ")", ";", "results", ".", "push", "(", "''", ")", ";", "return", "results", ".", "join", "(", "'\\n'", ")", ";", "}" ]

[ "for", "output", "file", "output" ]

[ "function", "gulpStatus", "(", ")", "{", "const", "Vinyl", "=", "require", "(", "'vinyl'", ")", ";", "const", "path", "=", "require", "(", "'path'", ")", ";", "const", "gulpGit", "=", "require", "(", "'gulp-git'", ")", ";", "const", "through", "=", "require", "(", "'through2'", ")", ";", "const", "srcStream", "=", "through", ".", "obj", "(", ")", ";", "const", "opt", "=", "{", "cwd", ":", "process", ".", "cwd", "(", ")", "}", ";", "// https://git-scm.com/docs/git-status#_short_format", "const", "RE_STATUS", "=", "/", "((\\s\\w)|(\\w+)|\\?{0,2})\\s([\\w\\+\\-\\/\\\\\\.]+)(\\s->\\s)?([\\w\\+\\-\\/\\\\\\.]+)*\\n{0,1}", "/", "gm", ";", "gulpGit", ".", "status", "(", "{", "args", ":", "'--porcelain'", ",", "quiet", ":", "true", "}", ",", "function", "(", "err", ",", "stdout", ")", "{", "if", "(", "err", ")", "return", "srcStream", ".", "emit", "(", "'error'", ",", "err", ")", ";", "const", "data", "=", "stdout", ".", "toString", "(", ")", ";", "let", "currentMatch", ";", "while", "(", "(", "currentMatch", "=", "RE_STATUS", ".", "exec", "(", "data", ")", ")", "!==", "null", ")", "{", "// status", "const", "status", "=", "currentMatch", "[", "1", "]", ".", "trim", "(", ")", ".", "toLowerCase", "(", ")", ";", "// We only care about untracked files and renamed files", "if", "(", "!", "new", "RegExp", "(", "/", "r|\\?", "/", "i", ")", ".", "test", "(", "status", ")", ")", "{", "continue", ";", "}", "// file path", "const", "currentFilePath", "=", "currentMatch", "[", "4", "]", ";", "// new file path in case its been moved", "const", "newFilePath", "=", "currentMatch", "[", "6", "]", ";", "const", "filePath", "=", "newFilePath", "||", "currentFilePath", ";", "srcStream", ".", "write", "(", "new", "Vinyl", "(", "{", "path", ":", "path", ".", "resolve", "(", "opt", ".", "cwd", ",", "filePath", ")", ",", "cwd", ":", "opt", ".", "cwd", ",", "}", ")", ")", ";", "RE_STATUS", ".", "lastIndex", "++", ";", "}", "srcStream", ".", "end", "(", ")", ";", "}", ")", ";", "return", "srcStream", ";", "}" ]

[ "Gulp", "stream", "that", "wraps", "the", "gulp", "-", "git", "status", "only", "returns", "untracked", "files", "and", "converts", "the", "stdout", "into", "a", "stream", "of", "files", "." ]

[ "function", "getAdditionalModulePaths", "(", "options", "=", "{", "}", ")", "{", "const", "baseUrl", "=", "options", ".", "baseUrl", ";", "// We need to explicitly check for null and undefined (and not a falsy value) because", "// TypeScript treats an empty string as `.`.", "if", "(", "baseUrl", "==", "null", ")", "{", "// If there's no baseUrl set we respect NODE_PATH", "// Note that NODE_PATH is deprecated and will be removed", "// in the next major release of create-react-app.", "const", "nodePath", "=", "process", ".", "env", ".", "NODE_PATH", "||", "''", ";", "return", "nodePath", ".", "split", "(", "path", ".", "delimiter", ")", ".", "filter", "(", "Boolean", ")", ";", "}", "const", "baseUrlResolved", "=", "path", ".", "resolve", "(", "paths", ".", "appPath", ",", "baseUrl", ")", ";", "// We don't need to do anything if `baseUrl` is set to `node_modules`. This is", "// the default behavior.", "if", "(", "path", ".", "relative", "(", "paths", ".", "appNodeModules", ",", "baseUrlResolved", ")", "===", "''", ")", "{", "return", "null", ";", "}", "// Allow the user set the `baseUrl` to `appSrc`.", "if", "(", "path", ".", "relative", "(", "paths", ".", "appSrc", ",", "baseUrlResolved", ")", "===", "''", ")", "{", "return", "[", "paths", ".", "appSrc", "]", ";", "}", "// Otherwise, throw an error.", "throw", "new", "Error", "(", "chalk", ".", "red", ".", "bold", "(", "\"Your project's `baseUrl` can only be set to `src` or `node_modules`.\"", "+", "' Create React App does not support other values at this time.'", ")", ")", ";", "}" ]

[ "Get", "the", "baseUrl", "of", "a", "compilerOptions", "object", "." ]

[ "function", "handleSuccess", "(", ")", "{", "clearOutdatedErrors", "(", ")", ";", "var", "isHotUpdate", "=", "!", "isFirstCompilation", ";", "isFirstCompilation", "=", "false", ";", "hasCompileErrors", "=", "false", ";", "// Attempt to apply hot updates or reload.", "if", "(", "isHotUpdate", ")", "{", "tryApplyUpdates", "(", "function", "onHotUpdateSuccess", "(", ")", "{", "// Only dismiss it when we're sure it's a hot update.", "// Otherwise it would flicker right before the reload.", "tryDismissErrorOverlay", "(", ")", ";", "}", ")", ";", "}", "}" ]

[ "Successful", "compilation", "." ]

[ "function", "printFileSizesAfterBuild", "(", "webpackStats", ",", "previousSizeMap", ",", "buildFolder", ",", "maxBundleGzipSize", ",", "maxChunkGzipSize", ")", "{", "var", "root", "=", "previousSizeMap", ".", "root", ";", "var", "sizes", "=", "previousSizeMap", ".", "sizes", ";", "var", "assets", "=", "(", "webpackStats", ".", "stats", "||", "[", "webpackStats", "]", ")", ".", "map", "(", "stats", "=>", "stats", ".", "toJson", "(", "{", "all", ":", "false", ",", "assets", ":", "true", "}", ")", ".", "assets", ".", "filter", "(", "asset", "=>", "canReadAsset", "(", "asset", ".", "name", ")", ")", ".", "map", "(", "asset", "=>", "{", "var", "fileContents", "=", "fs", ".", "readFileSync", "(", "path", ".", "join", "(", "root", ",", "asset", ".", "name", ")", ")", ";", "var", "size", "=", "gzipSize", "(", "fileContents", ")", ";", "var", "previousSize", "=", "sizes", "[", "removeFileNameHash", "(", "root", ",", "asset", ".", "name", ")", "]", ";", "var", "difference", "=", "getDifferenceLabel", "(", "size", ",", "previousSize", ")", ";", "return", "{", "folder", ":", "path", ".", "join", "(", "path", ".", "basename", "(", "buildFolder", ")", ",", "path", ".", "dirname", "(", "asset", ".", "name", ")", ")", ",", "name", ":", "path", ".", "basename", "(", "asset", ".", "name", ")", ",", "size", ":", "size", ",", "sizeLabel", ":", "filesize", "(", "size", ")", "+", "(", "difference", "?", "' ('", "+", "difference", "+", "')'", ":", "''", ")", ",", "}", ";", "}", ")", ")", ".", "reduce", "(", "(", "single", ",", "all", ")", "=>", "all", ".", "concat", "(", "single", ")", ",", "[", "]", ")", ";", "assets", ".", "sort", "(", "(", "a", ",", "b", ")", "=>", "b", ".", "size", "-", "a", ".", "size", ")", ";", "var", "longestSizeLabelLength", "=", "Math", ".", "max", ".", "apply", "(", "null", ",", "assets", ".", "map", "(", "a", "=>", "stripAnsi", "(", "a", ".", "sizeLabel", ")", ".", "length", ")", ")", ";", "var", "suggestBundleSplitting", "=", "false", ";", "assets", ".", "forEach", "(", "asset", "=>", "{", "var", "sizeLabel", "=", "asset", ".", "sizeLabel", ";", "var", "sizeLength", "=", "stripAnsi", "(", "sizeLabel", ")", ".", "length", ";", "if", "(", "sizeLength", "<", "longestSizeLabelLength", ")", "{", "var", "rightPadding", "=", "' '", ".", "repeat", "(", "longestSizeLabelLength", "-", "sizeLength", ")", ";", "sizeLabel", "+=", "rightPadding", ";", "}", "var", "isMainBundle", "=", "asset", ".", "name", ".", "indexOf", "(", "'main.'", ")", "===", "0", ";", "var", "maxRecommendedSize", "=", "isMainBundle", "?", "maxBundleGzipSize", ":", "maxChunkGzipSize", ";", "var", "isLarge", "=", "maxRecommendedSize", "&&", "asset", ".", "size", ">", "maxRecommendedSize", ";", "if", "(", "isLarge", "&&", "path", ".", "extname", "(", "asset", ".", "name", ")", "===", "'.js'", ")", "{", "suggestBundleSplitting", "=", "true", ";", "}", "console", ".", "log", "(", "' '", "+", "(", "isLarge", "?", "chalk", ".", "yellow", "(", "sizeLabel", ")", ":", "sizeLabel", ")", "+", "' '", "+", "chalk", ".", "dim", "(", "asset", ".", "folder", "+", "path", ".", "sep", ")", "+", "chalk", ".", "cyan", "(", "asset", ".", "name", ")", ")", ";", "}", ")", ";", "if", "(", "suggestBundleSplitting", ")", "{", "console", ".", "log", "(", ")", ";", "console", ".", "log", "(", "chalk", ".", "yellow", "(", "'The bundle size is significantly larger than recommended.'", ")", ")", ";", "console", ".", "log", "(", "chalk", ".", "yellow", "(", "'Consider reducing it with code splitting: https://goo.gl/9VhYWB'", ")", ")", ";", "console", ".", "log", "(", "chalk", ".", "yellow", "(", "'You can also analyze the project dependencies: https://goo.gl/LeUzfb'", ")", ")", ";", "}", "}" ]

[ "Prints", "a", "detailed", "summary", "of", "build", "files", "." ]

[ "function", "openBrowser", "(", "url", ")", "{", "const", "{", "action", ",", "value", "}", "=", "getBrowserEnv", "(", ")", ";", "switch", "(", "action", ")", "{", "case", "Actions", ".", "NONE", ":", "// Special case: BROWSER=\"none\" will prevent opening completely.", "return", "false", ";", "case", "Actions", ".", "SCRIPT", ":", "return", "executeNodeScript", "(", "value", ",", "url", ")", ";", "case", "Actions", ".", "BROWSER", ":", "return", "startBrowserProcess", "(", "value", ",", "url", ")", ";", "default", ":", "throw", "new", "Error", "(", "'Not implemented.'", ")", ";", "}", "}" ]

[ "Reads", "the", "BROWSER", "environment", "variable", "and", "decides", "what", "to", "do", "with", "it", ".", "Returns", "true", "if", "it", "opened", "a", "browser", "or", "ran", "a", "node", ".", "js", "script", "otherwise", "false", "." ]

[ "function", "onProxyError", "(", "proxy", ")", "{", "return", "(", "err", ",", "req", ",", "res", ")", "=>", "{", "const", "host", "=", "req", ".", "headers", "&&", "req", ".", "headers", ".", "host", ";", "console", ".", "log", "(", "chalk", ".", "red", "(", "'Proxy error:'", ")", "+", "' Could not proxy request '", "+", "chalk", ".", "cyan", "(", "req", ".", "url", ")", "+", "' from '", "+", "chalk", ".", "cyan", "(", "host", ")", "+", "' to '", "+", "chalk", ".", "cyan", "(", "proxy", ")", "+", "'.'", ")", ";", "console", ".", "log", "(", "'See https://nodejs.org/api/errors.html#errors_common_system_errors for more information ('", "+", "chalk", ".", "cyan", "(", "err", ".", "code", ")", "+", "').'", ")", ";", "console", ".", "log", "(", ")", ";", "// And immediately send the proper error response to the client.", "// Otherwise, the request will eventually timeout with ERR_EMPTY_RESPONSE on the client side.", "if", "(", "res", ".", "writeHead", "&&", "!", "res", ".", "headersSent", ")", "{", "res", ".", "writeHead", "(", "500", ")", ";", "}", "res", ".", "end", "(", "'Proxy error: Could not proxy request '", "+", "req", ".", "url", "+", "' from '", "+", "host", "+", "' to '", "+", "proxy", "+", "' ('", "+", "err", ".", "code", "+", "').'", ")", ";", "}", ";", "}" ]

[ "We", "need", "to", "provide", "a", "custom", "onError", "function", "for", "httpProxyMiddleware", ".", "It", "allows", "us", "to", "log", "custom", "error", "messages", "on", "the", "console", "." ]

[ "function", "finalizeCompile", "(", ")", "{", "if", "(", "fs", ".", "existsSync", "(", "path", ".", "join", "(", "__dirname", ",", "'./lib'", ")", ")", ")", "{", "// Build package.json version to lib/version/index.js", "// prevent json-loader needing in user-side", "const", "versionFilePath", "=", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'lib'", ",", "'version'", ",", "'index.js'", ")", ";", "const", "versionFileContent", "=", "fs", ".", "readFileSync", "(", "versionFilePath", ")", ".", "toString", "(", ")", ";", "fs", ".", "writeFileSync", "(", "versionFilePath", ",", "versionFileContent", ".", "replace", "(", "/", "require\\(('|\")\\.\\.\\/\\.\\.\\/package\\.json('|\")\\)", "/", ",", "`", "${", "packageInfo", ".", "version", "}", "`", ",", ")", ",", ")", ";", "// eslint-disable-next-line", "console", ".", "log", "(", "'Wrote version into lib/version/index.js'", ")", ";", "// Build package.json version to lib/version/index.d.ts", "// prevent https://github.com/ant-design/ant-design/issues/4935", "const", "versionDefPath", "=", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'lib'", ",", "'version'", ",", "'index.d.ts'", ")", ";", "fs", ".", "writeFileSync", "(", "versionDefPath", ",", "`", "${", "packageInfo", ".", "version", "}", "\\n", "\\n", "`", ",", ")", ";", "// eslint-disable-next-line", "console", ".", "log", "(", "'Wrote version into lib/version/index.d.ts'", ")", ";", "// Build a entry less file to dist/antd.less", "const", "componentsPath", "=", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'components'", ")", ";", "let", "componentsLessContent", "=", "''", ";", "// Build components in one file: lib/style/components.less", "fs", ".", "readdir", "(", "componentsPath", ",", "(", "err", ",", "files", ")", "=>", "{", "files", ".", "forEach", "(", "file", "=>", "{", "if", "(", "fs", ".", "existsSync", "(", "path", ".", "join", "(", "componentsPath", ",", "file", ",", "'style'", ",", "'index.less'", ")", ")", ")", "{", "componentsLessContent", "+=", "`", "${", "path", ".", "join", "(", "file", ",", "'style'", ",", "'index.less'", ")", "}", "\\n", "`", ";", "}", "}", ")", ";", "fs", ".", "writeFileSync", "(", "path", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'lib'", ",", "'style'", ",", "'components.less'", ")", ",", "componentsLessContent", ",", ")", ";", "}", ")", ";", "}", "}" ]

[ "We", "need", "compile", "additional", "content", "for", "antd", "user" ]

[ "async", "function", "build", "(", ")", "{", "console", ".", "time", "(", "'Packager'", ")", ";", "let", "requires", "=", "[", "]", ";", "let", "esmExportString", "=", "''", ";", "let", "cjsExportString", "=", "''", ";", "try", "{", "if", "(", "!", "fs", ".", "existsSync", "(", "DIST_PATH", ")", ")", "fs", ".", "mkdirSync", "(", "DIST_PATH", ")", ";", "fs", ".", "writeFileSync", "(", "ROLLUP_INPUT_FILE", ",", "''", ")", ";", "fs", ".", "writeFileSync", "(", "TEST_MODULE_FILE", ",", "''", ")", ";", "// All the snippets that are Node.js-based and will break in a browser", "// environment", "const", "nodeSnippets", "=", "fs", ".", "readFileSync", "(", "'tag_database'", ",", "'utf8'", ")", ".", "split", "(", "'\\n'", ")", ".", "filter", "(", "v", "=>", "v", ".", "search", "(", "/", ":.*node", "/", "g", ")", "!==", "-", "1", ")", ".", "map", "(", "v", "=>", "v", ".", "slice", "(", "0", ",", "v", ".", "indexOf", "(", "':'", ")", ")", ")", ";", "const", "snippets", "=", "fs", ".", "readdirSync", "(", "SNIPPETS_PATH", ")", ";", "const", "archivedSnippets", "=", "fs", ".", "readdirSync", "(", "SNIPPETS_ARCHIVE_PATH", ")", ".", "filter", "(", "v", "=>", "v", "!==", "'README.md'", ")", ";", "snippets", ".", "forEach", "(", "snippet", "=>", "{", "const", "rawSnippetString", "=", "getRawSnippetString", "(", "SNIPPETS_PATH", ",", "snippet", ")", ";", "const", "snippetName", "=", "snippet", ".", "replace", "(", "'.md'", ",", "''", ")", ";", "let", "code", "=", "getCode", "(", "rawSnippetString", ")", ";", "if", "(", "nodeSnippets", ".", "includes", "(", "snippetName", ")", ")", "{", "requires", ".", "push", "(", "code", ".", "match", "(", "/", "const.*=.*require\\(([^\\)]*)\\);", "/", "g", ")", ")", ";", "code", "=", "code", ".", "replace", "(", "/", "const.*=.*require\\(([^\\)]*)\\);", "/", "g", ",", "''", ")", ";", "}", "esmExportString", "+=", "`", "${", "code", "}", "`", ";", "cjsExportString", "+=", "code", ";", "}", ")", ";", "archivedSnippets", ".", "forEach", "(", "snippet", "=>", "{", "const", "rawSnippetString", "=", "getRawSnippetString", "(", "SNIPPETS_ARCHIVE_PATH", ",", "snippet", ")", ";", "cjsExportString", "+=", "getCode", "(", "rawSnippetString", ")", ";", "}", ")", ";", "requires", "=", "[", "...", "new", "Set", "(", "requires", ".", "filter", "(", "Boolean", ")", ".", "map", "(", "v", "=>", "v", "[", "0", "]", ".", "replace", "(", "'require('", ",", "'typeof require !== \"undefined\" && require('", ")", ")", ")", "]", ".", "join", "(", "'\\n'", ")", ";", "fs", ".", "writeFileSync", "(", "ROLLUP_INPUT_FILE", ",", "`", "${", "requires", "}", "\\n", "\\n", "${", "esmExportString", "}", "`", ")", ";", "const", "testExports", "=", "`", "${", "[", "...", "snippets", ",", "...", "archivedSnippets", "]", ".", "map", "(", "v", "=>", "v", ".", "replace", "(", "'.md'", ",", "''", ")", ")", ".", "join", "(", "','", ")", "}", "`", ";", "fs", ".", "writeFileSync", "(", "TEST_MODULE_FILE", ",", "`", "${", "requires", "}", "\\n", "\\n", "${", "cjsExportString", "}", "\\n", "\\n", "${", "testExports", "}", "`", ")", ";", "// Check Travis builds - Will skip builds on Travis if not CRON/API", "if", "(", "util", ".", "isTravisCI", "(", ")", "&&", "util", ".", "isNotTravisCronOrAPI", "(", ")", ")", "{", "fs", ".", "unlink", "(", "ROLLUP_INPUT_FILE", ")", ";", "console", ".", "log", "(", "`", "${", "chalk", ".", "green", "(", "'NOBUILD'", ")", "}", "`", ")", ";", "console", ".", "timeEnd", "(", "'Packager'", ")", ";", "process", ".", "exit", "(", "0", ")", ";", "}", "await", "doRollup", "(", ")", ";", "// Clean up the temporary input file Rollup used for building the module", "fs", ".", "unlink", "(", "ROLLUP_INPUT_FILE", ")", ";", "console", ".", "log", "(", "`", "${", "chalk", ".", "green", "(", "'SUCCESS!'", ")", "}", "`", ")", ";", "console", ".", "timeEnd", "(", "'Packager'", ")", ";", "}", "catch", "(", "err", ")", "{", "console", ".", "log", "(", "`", "${", "chalk", ".", "red", "(", "'ERROR!'", ")", "}", "${", "err", "}", "`", ")", ";", "process", ".", "exit", "(", "1", ")", ";", "}", "}" ]

[ "Starts", "the", "build", "process", "." ]

[ "function", "(", "embedder", ",", "params", ")", "{", "if", "(", "webViewManager", "==", "null", ")", "{", "webViewManager", "=", "process", ".", "electronBinding", "(", "'web_view_manager'", ")", "}", "const", "guest", "=", "webContents", ".", "create", "(", "{", "isGuest", ":", "true", ",", "partition", ":", "params", ".", "partition", ",", "embedder", ":", "embedder", "}", ")", "const", "guestInstanceId", "=", "guest", ".", "id", "guestInstances", "[", "guestInstanceId", "]", "=", "{", "guest", ":", "guest", ",", "embedder", ":", "embedder", "}", "// Clear the guest from map when it is destroyed.", "//", "// The guest WebContents is usually destroyed in 2 cases:", "// 1. The embedder frame is closed (reloaded or destroyed), and it", "// automatically closes the guest frame.", "// 2. The guest frame is detached dynamically via JS, and it is manually", "// destroyed when the renderer sends the GUEST_VIEW_MANAGER_DESTROY_GUEST", "// message.", "// The second case relies on the libcc patch:", "// https://github.com/electron/libchromiumcontent/pull/676", "// The patch was introduced to work around a bug in Chromium:", "// https://github.com/electron/electron/issues/14211", "// We should revisit the bug to see if we can remove our libcc patch, the", "// patch was introduced in Chrome 66.", "guest", ".", "once", "(", "'destroyed'", ",", "(", ")", "=>", "{", "if", "(", "guestInstanceId", "in", "guestInstances", ")", "{", "detachGuest", "(", "embedder", ",", "guestInstanceId", ")", "}", "}", ")", "// Init guest web view after attached.", "guest", ".", "once", "(", "'did-attach'", ",", "function", "(", "event", ")", "{", "params", "=", "this", ".", "attachParams", "delete", "this", ".", "attachParams", "const", "previouslyAttached", "=", "this", ".", "viewInstanceId", "!=", "null", "this", ".", "viewInstanceId", "=", "params", ".", "instanceId", "// Only load URL and set size on first attach", "if", "(", "previouslyAttached", ")", "{", "return", "}", "if", "(", "params", ".", "src", ")", "{", "const", "opts", "=", "{", "}", "if", "(", "params", ".", "httpreferrer", ")", "{", "opts", ".", "httpReferrer", "=", "params", ".", "httpreferrer", "}", "if", "(", "params", ".", "useragent", ")", "{", "opts", ".", "userAgent", "=", "params", ".", "useragent", "}", "this", ".", "loadURL", "(", "params", ".", "src", ",", "opts", ")", "}", "guest", ".", "allowPopups", "=", "params", ".", "allowpopups", "embedder", ".", "emit", "(", "'did-attach-webview'", ",", "event", ",", "guest", ")", "}", ")", "const", "sendToEmbedder", "=", "(", "channel", ",", "...", "args", ")", "=>", "{", "if", "(", "!", "embedder", ".", "isDestroyed", "(", ")", ")", "{", "embedder", ".", "_sendInternal", "(", "`", "${", "channel", "}", "${", "guest", ".", "viewInstanceId", "}", "`", ",", "...", "args", ")", "}", "}", "// Dispatch events to embedder.", "const", "fn", "=", "function", "(", "event", ")", "{", "guest", ".", "on", "(", "event", ",", "function", "(", "_", ",", "...", "args", ")", "{", "sendToEmbedder", "(", "'ELECTRON_GUEST_VIEW_INTERNAL_DISPATCH_EVENT'", ",", "event", ",", "...", "args", ")", "}", ")", "}", "for", "(", "const", "event", "of", "supportedWebViewEvents", ")", "{", "fn", "(", "event", ")", "}", "// Dispatch guest's IPC messages to embedder.", "guest", ".", "on", "(", "'ipc-message-host'", ",", "function", "(", "_", ",", "channel", ",", "args", ")", "{", "sendToEmbedder", "(", "'ELECTRON_GUEST_VIEW_INTERNAL_IPC_MESSAGE'", ",", "channel", ",", "...", "args", ")", "}", ")", "// Notify guest of embedder window visibility when it is ready", "// FIXME Remove once https://github.com/electron/electron/issues/6828 is fixed", "guest", ".", "on", "(", "'dom-ready'", ",", "function", "(", ")", "{", "const", "guestInstance", "=", "guestInstances", "[", "guestInstanceId", "]", "if", "(", "guestInstance", "!=", "null", "&&", "guestInstance", ".", "visibilityState", "!=", "null", ")", "{", "guest", ".", "_sendInternal", "(", "'ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE'", ",", "guestInstance", ".", "visibilityState", ")", "}", "}", ")", "// Forward internal web contents event to embedder to handle", "// native window.open setup", "guest", ".", "on", "(", "'-add-new-contents'", ",", "(", "...", "args", ")", "=>", "{", "if", "(", "guest", ".", "getLastWebPreferences", "(", ")", ".", "nativeWindowOpen", "===", "true", ")", "{", "const", "embedder", "=", "getEmbedder", "(", "guestInstanceId", ")", "if", "(", "embedder", "!=", "null", ")", "{", "embedder", ".", "emit", "(", "'-add-new-contents'", ",", "...", "args", ")", "}", "}", "}", ")", "return", "guestInstanceId", "}" ]

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

[ "function", "(", "embedder", ",", "guestInstanceId", ")", "{", "const", "guestInstance", "=", "guestInstances", "[", "guestInstanceId", "]", "if", "(", "embedder", "!==", "guestInstance", ".", "embedder", ")", "{", "return", "}", "webViewManager", ".", "removeGuest", "(", "embedder", ",", "guestInstanceId", ")", "delete", "guestInstances", "[", "guestInstanceId", "]", "const", "key", "=", "`", "${", "embedder", ".", "id", "}", "${", "guestInstance", ".", "elementInstanceId", "}", "`", "delete", "embedderElementsMap", "[", "key", "]", "}" ]

[ "Remove", "an", "guest", "-", "embedder", "relationship", "." ]

[ "function", "(", "visibilityState", ")", "{", "for", "(", "const", "guestInstanceId", "in", "guestInstances", ")", "{", "const", "guestInstance", "=", "guestInstances", "[", "guestInstanceId", "]", "guestInstance", ".", "visibilityState", "=", "visibilityState", "if", "(", "guestInstance", ".", "embedder", "===", "embedder", ")", "{", "guestInstance", ".", "guest", ".", "_sendInternal", "(", "'ELECTRON_GUEST_INSTANCE_VISIBILITY_CHANGE'", ",", "visibilityState", ")", "}", "}", "}" ]

[ "Forward", "embedder", "window", "visiblity", "change", "events", "to", "guest" ]

[ "function", "(", "guestInstanceId", ",", "contents", ")", "{", "const", "guest", "=", "getGuest", "(", "guestInstanceId", ")", "if", "(", "!", "guest", ")", "{", "throw", "new", "Error", "(", "`", "${", "guestInstanceId", "}", "`", ")", "}", "if", "(", "guest", ".", "hostWebContents", "!==", "contents", ")", "{", "throw", "new", "Error", "(", "`", "${", "guestInstanceId", "}", "`", ")", "}", "return", "guest", "}" ]

[ "Returns", "WebContents", "from", "its", "guest", "id", "hosted", "in", "given", "webContents", "." ]

[ "async", "function", "changesToRelease", "(", ")", "{", "const", "lastCommitWasRelease", "=", "new", "RegExp", "(", "`", "`", ",", "'g'", ")", "const", "lastCommit", "=", "await", "GitProcess", ".", "exec", "(", "[", "'log'", ",", "'-n'", ",", "'1'", ",", "`", "`", "]", ",", "gitDir", ")", "return", "!", "lastCommitWasRelease", ".", "test", "(", "lastCommit", ".", "stdout", ")", "}" ]

[ "function", "to", "determine", "if", "there", "have", "been", "commits", "to", "master", "since", "the", "last", "release" ]

[ "async", "function", "runRetryable", "(", "fn", ",", "maxRetries", ")", "{", "let", "lastError", "for", "(", "let", "i", "=", "0", ";", "i", "<", "maxRetries", ";", "i", "++", ")", "{", "try", "{", "return", "await", "fn", "(", ")", "}", "catch", "(", "error", ")", "{", "await", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "setTimeout", "(", "resolve", ",", "CHECK_INTERVAL", ")", ")", "lastError", "=", "error", "}", "}", "// Silently eat 404s.", "if", "(", "lastError", ".", "status", "!==", "404", ")", "throw", "lastError", "}" ]

[ "helper", "function", "to", "add", "some", "resiliency", "to", "volatile", "GH", "api", "endpoints" ]

[ "function", "wrapArgs", "(", "args", ",", "visited", "=", "new", "Set", "(", ")", ")", "{", "const", "valueToMeta", "=", "(", "value", ")", "=>", "{", "// Check for circular reference.", "if", "(", "visited", ".", "has", "(", "value", ")", ")", "{", "return", "{", "type", ":", "'value'", ",", "value", ":", "null", "}", "}", "if", "(", "Array", ".", "isArray", "(", "value", ")", ")", "{", "visited", ".", "add", "(", "value", ")", "const", "meta", "=", "{", "type", ":", "'array'", ",", "value", ":", "wrapArgs", "(", "value", ",", "visited", ")", "}", "visited", ".", "delete", "(", "value", ")", "return", "meta", "}", "else", "if", "(", "bufferUtils", ".", "isBuffer", "(", "value", ")", ")", "{", "return", "{", "type", ":", "'buffer'", ",", "value", ":", "bufferUtils", ".", "bufferToMeta", "(", "value", ")", "}", "}", "else", "if", "(", "value", "instanceof", "Date", ")", "{", "return", "{", "type", ":", "'date'", ",", "value", ":", "value", ".", "getTime", "(", ")", "}", "}", "else", "if", "(", "(", "value", "!=", "null", ")", "&&", "typeof", "value", "===", "'object'", ")", "{", "if", "(", "isPromise", "(", "value", ")", ")", "{", "return", "{", "type", ":", "'promise'", ",", "then", ":", "valueToMeta", "(", "function", "(", "onFulfilled", ",", "onRejected", ")", "{", "value", ".", "then", "(", "onFulfilled", ",", "onRejected", ")", "}", ")", "}", "}", "else", "if", "(", "v8Util", ".", "getHiddenValue", "(", "value", ",", "'atomId'", ")", ")", "{", "return", "{", "type", ":", "'remote-object'", ",", "id", ":", "v8Util", ".", "getHiddenValue", "(", "value", ",", "'atomId'", ")", "}", "}", "const", "meta", "=", "{", "type", ":", "'object'", ",", "name", ":", "value", ".", "constructor", "?", "value", ".", "constructor", ".", "name", ":", "''", ",", "members", ":", "[", "]", "}", "visited", ".", "add", "(", "value", ")", "for", "(", "const", "prop", "in", "value", ")", "{", "meta", ".", "members", ".", "push", "(", "{", "name", ":", "prop", ",", "value", ":", "valueToMeta", "(", "value", "[", "prop", "]", ")", "}", ")", "}", "visited", ".", "delete", "(", "value", ")", "return", "meta", "}", "else", "if", "(", "typeof", "value", "===", "'function'", "&&", "v8Util", ".", "getHiddenValue", "(", "value", ",", "'returnValue'", ")", ")", "{", "return", "{", "type", ":", "'function-with-return-value'", ",", "value", ":", "valueToMeta", "(", "value", "(", ")", ")", "}", "}", "else", "if", "(", "typeof", "value", "===", "'function'", ")", "{", "return", "{", "type", ":", "'function'", ",", "id", ":", "callbacksRegistry", ".", "add", "(", "value", ")", ",", "location", ":", "v8Util", ".", "getHiddenValue", "(", "value", ",", "'location'", ")", ",", "length", ":", "value", ".", "length", "}", "}", "else", "{", "return", "{", "type", ":", "'value'", ",", "value", ":", "value", "}", "}", "}", "return", "args", ".", "map", "(", "valueToMeta", ")", "}" ]

[ "Convert", "the", "arguments", "object", "into", "an", "array", "of", "meta", "data", "." ]

[ "function", "setObjectMembers", "(", "ref", ",", "object", ",", "metaId", ",", "members", ")", "{", "if", "(", "!", "Array", ".", "isArray", "(", "members", ")", ")", "return", "for", "(", "const", "member", "of", "members", ")", "{", "if", "(", "object", ".", "hasOwnProperty", "(", "member", ".", "name", ")", ")", "continue", "const", "descriptor", "=", "{", "enumerable", ":", "member", ".", "enumerable", "}", "if", "(", "member", ".", "type", "===", "'method'", ")", "{", "const", "remoteMemberFunction", "=", "function", "(", "...", "args", ")", "{", "let", "command", "if", "(", "this", "&&", "this", ".", "constructor", "===", "remoteMemberFunction", ")", "{", "command", "=", "'ELECTRON_BROWSER_MEMBER_CONSTRUCTOR'", "}", "else", "{", "command", "=", "'ELECTRON_BROWSER_MEMBER_CALL'", "}", "const", "ret", "=", "ipcRendererInternal", ".", "sendSync", "(", "command", ",", "contextId", ",", "metaId", ",", "member", ".", "name", ",", "wrapArgs", "(", "args", ")", ")", "return", "metaToValue", "(", "ret", ")", "}", "let", "descriptorFunction", "=", "proxyFunctionProperties", "(", "remoteMemberFunction", ",", "metaId", ",", "member", ".", "name", ")", "descriptor", ".", "get", "=", "(", ")", "=>", "{", "descriptorFunction", ".", "ref", "=", "ref", "// The member should reference its object.", "return", "descriptorFunction", "}", "// Enable monkey-patch the method", "descriptor", ".", "set", "=", "(", "value", ")", "=>", "{", "descriptorFunction", "=", "value", "return", "value", "}", "descriptor", ".", "configurable", "=", "true", "}", "else", "if", "(", "member", ".", "type", "===", "'get'", ")", "{", "descriptor", ".", "get", "=", "(", ")", "=>", "{", "const", "command", "=", "'ELECTRON_BROWSER_MEMBER_GET'", "const", "meta", "=", "ipcRendererInternal", ".", "sendSync", "(", "command", ",", "contextId", ",", "metaId", ",", "member", ".", "name", ")", "return", "metaToValue", "(", "meta", ")", "}", "if", "(", "member", ".", "writable", ")", "{", "descriptor", ".", "set", "=", "(", "value", ")", "=>", "{", "const", "args", "=", "wrapArgs", "(", "[", "value", "]", ")", "const", "command", "=", "'ELECTRON_BROWSER_MEMBER_SET'", "const", "meta", "=", "ipcRendererInternal", ".", "sendSync", "(", "command", ",", "contextId", ",", "metaId", ",", "member", ".", "name", ",", "args", ")", "if", "(", "meta", "!=", "null", ")", "metaToValue", "(", "meta", ")", "return", "value", "}", "}", "}", "Object", ".", "defineProperty", "(", "object", ",", "member", ".", "name", ",", "descriptor", ")", "}", "}" ]

[ "Populate", "object", "s", "members", "from", "descriptors", ".", "The", "|ref|", "will", "be", "kept", "referenced", "by", "|members|", ".", "This", "matches", "|getObjectMemebers|", "in", "rpc", "-", "server", "." ]

[ "function", "setObjectPrototype", "(", "ref", ",", "object", ",", "metaId", ",", "descriptor", ")", "{", "if", "(", "descriptor", "===", "null", ")", "return", "const", "proto", "=", "{", "}", "setObjectMembers", "(", "ref", ",", "proto", ",", "metaId", ",", "descriptor", ".", "members", ")", "setObjectPrototype", "(", "ref", ",", "proto", ",", "metaId", ",", "descriptor", ".", "proto", ")", "Object", ".", "setPrototypeOf", "(", "object", ",", "proto", ")", "}" ]

[ "Populate", "object", "s", "prototype", "from", "descriptor", ".", "This", "matches", "|getObjectPrototype|", "in", "rpc", "-", "server", "." ]

[ "function", "proxyFunctionProperties", "(", "remoteMemberFunction", ",", "metaId", ",", "name", ")", "{", "let", "loaded", "=", "false", "// Lazily load function properties", "const", "loadRemoteProperties", "=", "(", ")", "=>", "{", "if", "(", "loaded", ")", "return", "loaded", "=", "true", "const", "command", "=", "'ELECTRON_BROWSER_MEMBER_GET'", "const", "meta", "=", "ipcRendererInternal", ".", "sendSync", "(", "command", ",", "contextId", ",", "metaId", ",", "name", ")", "setObjectMembers", "(", "remoteMemberFunction", ",", "remoteMemberFunction", ",", "meta", ".", "id", ",", "meta", ".", "members", ")", "}", "return", "new", "Proxy", "(", "remoteMemberFunction", ",", "{", "set", ":", "(", "target", ",", "property", ",", "value", ",", "receiver", ")", "=>", "{", "if", "(", "property", "!==", "'ref'", ")", "loadRemoteProperties", "(", ")", "target", "[", "property", "]", "=", "value", "return", "true", "}", ",", "get", ":", "(", "target", ",", "property", ",", "receiver", ")", "=>", "{", "if", "(", "!", "target", ".", "hasOwnProperty", "(", "property", ")", ")", "loadRemoteProperties", "(", ")", "const", "value", "=", "target", "[", "property", "]", "if", "(", "property", "===", "'toString'", "&&", "typeof", "value", "===", "'function'", ")", "{", "return", "value", ".", "bind", "(", "target", ")", "}", "return", "value", "}", ",", "ownKeys", ":", "(", "target", ")", "=>", "{", "loadRemoteProperties", "(", ")", "return", "Object", ".", "getOwnPropertyNames", "(", "target", ")", "}", ",", "getOwnPropertyDescriptor", ":", "(", "target", ",", "property", ")", "=>", "{", "const", "descriptor", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "target", ",", "property", ")", "if", "(", "descriptor", ")", "return", "descriptor", "loadRemoteProperties", "(", ")", "return", "Object", ".", "getOwnPropertyDescriptor", "(", "target", ",", "property", ")", "}", "}", ")", "}" ]

[ "Wrap", "function", "in", "Proxy", "for", "accessing", "remote", "properties" ]

[ "function", "metaToValue", "(", "meta", ")", "{", "const", "types", "=", "{", "value", ":", "(", ")", "=>", "meta", ".", "value", ",", "array", ":", "(", ")", "=>", "meta", ".", "members", ".", "map", "(", "(", "member", ")", "=>", "metaToValue", "(", "member", ")", ")", ",", "buffer", ":", "(", ")", "=>", "bufferUtils", ".", "metaToBuffer", "(", "meta", ".", "value", ")", ",", "promise", ":", "(", ")", "=>", "resolvePromise", "(", "{", "then", ":", "metaToValue", "(", "meta", ".", "then", ")", "}", ")", ",", "error", ":", "(", ")", "=>", "metaToPlainObject", "(", "meta", ")", ",", "date", ":", "(", ")", "=>", "new", "Date", "(", "meta", ".", "value", ")", ",", "exception", ":", "(", ")", "=>", "{", "throw", "errorUtils", ".", "deserialize", "(", "meta", ".", "value", ")", "}", "}", "if", "(", "meta", ".", "type", "in", "types", ")", "{", "return", "types", "[", "meta", ".", "type", "]", "(", ")", "}", "else", "{", "let", "ret", "if", "(", "remoteObjectCache", ".", "has", "(", "meta", ".", "id", ")", ")", "{", "v8Util", ".", "addRemoteObjectRef", "(", "contextId", ",", "meta", ".", "id", ")", "return", "remoteObjectCache", ".", "get", "(", "meta", ".", "id", ")", "}", "// A shadow class to represent the remote function object.", "if", "(", "meta", ".", "type", "===", "'function'", ")", "{", "const", "remoteFunction", "=", "function", "(", "...", "args", ")", "{", "let", "command", "if", "(", "this", "&&", "this", ".", "constructor", "===", "remoteFunction", ")", "{", "command", "=", "'ELECTRON_BROWSER_CONSTRUCTOR'", "}", "else", "{", "command", "=", "'ELECTRON_BROWSER_FUNCTION_CALL'", "}", "const", "obj", "=", "ipcRendererInternal", ".", "sendSync", "(", "command", ",", "contextId", ",", "meta", ".", "id", ",", "wrapArgs", "(", "args", ")", ")", "return", "metaToValue", "(", "obj", ")", "}", "ret", "=", "remoteFunction", "}", "else", "{", "ret", "=", "{", "}", "}", "setObjectMembers", "(", "ret", ",", "ret", ",", "meta", ".", "id", ",", "meta", ".", "members", ")", "setObjectPrototype", "(", "ret", ",", "ret", ",", "meta", ".", "id", ",", "meta", ".", "proto", ")", "Object", ".", "defineProperty", "(", "ret", ".", "constructor", ",", "'name'", ",", "{", "value", ":", "meta", ".", "name", "}", ")", "// Track delegate obj's lifetime & tell browser to clean up when object is GCed.", "v8Util", ".", "setRemoteObjectFreer", "(", "ret", ",", "contextId", ",", "meta", ".", "id", ")", "v8Util", ".", "setHiddenValue", "(", "ret", ",", "'atomId'", ",", "meta", ".", "id", ")", "v8Util", ".", "addRemoteObjectRef", "(", "contextId", ",", "meta", ".", "id", ")", "remoteObjectCache", ".", "set", "(", "meta", ".", "id", ",", "ret", ")", "return", "ret", "}", "}" ]

[ "Convert", "meta", "data", "from", "browser", "into", "real", "value", "." ]

[ "function", "metaToPlainObject", "(", "meta", ")", "{", "const", "obj", "=", "(", "(", ")", "=>", "meta", ".", "type", "===", "'error'", "?", "new", "Error", "(", ")", ":", "{", "}", ")", "(", ")", "for", "(", "let", "i", "=", "0", ";", "i", "<", "meta", ".", "members", ".", "length", ";", "i", "++", ")", "{", "const", "{", "name", ",", "value", "}", "=", "meta", ".", "members", "[", "i", "]", "obj", "[", "name", "]", "=", "value", "}", "return", "obj", "}" ]

[ "Construct", "a", "plain", "object", "from", "the", "meta", "." ]

[ "function", "(", "srcDirectory", ")", "{", "let", "manifest", "let", "manifestContent", "try", "{", "manifestContent", "=", "fs", ".", "readFileSync", "(", "path", ".", "join", "(", "srcDirectory", ",", "'manifest.json'", ")", ")", "}", "catch", "(", "readError", ")", "{", "console", ".", "warn", "(", "`", "${", "path", ".", "join", "(", "srcDirectory", ",", "'manifest.json'", ")", "}", "`", ")", "console", ".", "warn", "(", "readError", ".", "stack", "||", "readError", ")", "throw", "readError", "}", "try", "{", "manifest", "=", "JSON", ".", "parse", "(", "manifestContent", ")", "}", "catch", "(", "parseError", ")", "{", "console", ".", "warn", "(", "`", "${", "path", ".", "join", "(", "srcDirectory", ",", "'manifest.json'", ")", "}", "`", ")", "console", ".", "warn", "(", "parseError", ".", "stack", "||", "parseError", ")", "throw", "parseError", "}", "if", "(", "!", "manifestNameMap", "[", "manifest", ".", "name", "]", ")", "{", "const", "extensionId", "=", "generateExtensionIdFromName", "(", "manifest", ".", "name", ")", "manifestMap", "[", "extensionId", "]", "=", "manifestNameMap", "[", "manifest", ".", "name", "]", "=", "manifest", "Object", ".", "assign", "(", "manifest", ",", "{", "srcDirectory", ":", "srcDirectory", ",", "extensionId", ":", "extensionId", ",", "// We can not use 'file://' directly because all resources in the extension", "// will be treated as relative to the root in Chrome.", "startPage", ":", "url", ".", "format", "(", "{", "protocol", ":", "'chrome-extension'", ",", "slashes", ":", "true", ",", "hostname", ":", "extensionId", ",", "pathname", ":", "manifest", ".", "devtools_page", "}", ")", "}", ")", "return", "manifest", "}", "else", "if", "(", "manifest", "&&", "manifest", ".", "name", ")", "{", "console", ".", "warn", "(", "`", "${", "manifest", ".", "name", "}", "`", ")", "return", "manifest", "}", "}" ]

[ "Create", "or", "get", "manifest", "object", "from", "|srcDirectory|", "." ]

[ "function", "(", "webContents", ")", "{", "const", "tabId", "=", "webContents", ".", "id", "sendToBackgroundPages", "(", "'CHROME_TABS_ONCREATED'", ")", "webContents", ".", "on", "(", "'will-navigate'", ",", "(", "event", ",", "url", ")", "=>", "{", "sendToBackgroundPages", "(", "'CHROME_WEBNAVIGATION_ONBEFORENAVIGATE'", ",", "{", "frameId", ":", "0", ",", "parentFrameId", ":", "-", "1", ",", "processId", ":", "webContents", ".", "getProcessId", "(", ")", ",", "tabId", ":", "tabId", ",", "timeStamp", ":", "Date", ".", "now", "(", ")", ",", "url", ":", "url", "}", ")", "}", ")", "webContents", ".", "on", "(", "'did-navigate'", ",", "(", "event", ",", "url", ")", "=>", "{", "sendToBackgroundPages", "(", "'CHROME_WEBNAVIGATION_ONCOMPLETED'", ",", "{", "frameId", ":", "0", ",", "parentFrameId", ":", "-", "1", ",", "processId", ":", "webContents", ".", "getProcessId", "(", ")", ",", "tabId", ":", "tabId", ",", "timeStamp", ":", "Date", ".", "now", "(", ")", ",", "url", ":", "url", "}", ")", "}", ")", "webContents", ".", "once", "(", "'destroyed'", ",", "(", ")", "=>", "{", "sendToBackgroundPages", "(", "'CHROME_TABS_ONREMOVED'", ",", "tabId", ")", "}", ")", "}" ]

[ "Dispatch", "web", "contents", "events", "to", "Chrome", "APIs" ]

[ "function", "(", "manifest", ")", "{", "return", "{", "startPage", ":", "manifest", ".", "startPage", ",", "srcDirectory", ":", "manifest", ".", "srcDirectory", ",", "name", ":", "manifest", ".", "name", ",", "exposeExperimentalAPIs", ":", "true", "}", "}" ]

[ "Transfer", "the", "|manifest|", "to", "a", "format", "that", "can", "be", "recognized", "by", "the", "|DevToolsAPI", ".", "addExtensions|", "." ]

[ "function", "preloadRequire", "(", "module", ")", "{", "if", "(", "loadedModules", ".", "has", "(", "module", ")", ")", "{", "return", "loadedModules", ".", "get", "(", "module", ")", "}", "throw", "new", "Error", "(", "`", "${", "module", "}", "`", ")", "}" ]

[ "This", "is", "the", "require", "function", "that", "will", "be", "visible", "to", "the", "preload", "script" ]

[ "function", "generateGroupId", "(", "items", ",", "pos", ")", "{", "if", "(", "pos", ">", "0", ")", "{", "for", "(", "let", "idx", "=", "pos", "-", "1", ";", "idx", ">=", "0", ";", "idx", "--", ")", "{", "if", "(", "items", "[", "idx", "]", ".", "type", "===", "'radio'", ")", "return", "items", "[", "idx", "]", ".", "groupId", "if", "(", "items", "[", "idx", "]", ".", "type", "===", "'separator'", ")", "break", "}", "}", "else", "if", "(", "pos", "<", "items", ".", "length", ")", "{", "for", "(", "let", "idx", "=", "pos", ";", "idx", "<=", "items", ".", "length", "-", "1", ";", "idx", "++", ")", "{", "if", "(", "items", "[", "idx", "]", ".", "type", "===", "'radio'", ")", "return", "items", "[", "idx", "]", ".", "groupId", "if", "(", "items", "[", "idx", "]", ".", "type", "===", "'separator'", ")", "break", "}", "}", "groupIdIndex", "+=", "1", "return", "groupIdIndex", "}" ]

[ "Search", "between", "separators", "to", "find", "a", "radio", "menu", "item", "and", "return", "its", "group", "id" ]

[ "function", "(", "args", ",", "detached", ",", "callback", ")", "{", "let", "error", ",", "errorEmitted", ",", "stderr", ",", "stdout", "try", "{", "// Ensure we don't spawn multiple squirrel processes", "// Process spawned, same args: Attach events to alread running process", "// Process spawned, different args: Return with error", "// No process spawned: Spawn new process", "if", "(", "spawnedProcess", "&&", "!", "isSameArgs", "(", "args", ")", ")", "{", "// Disabled for backwards compatibility:", "// eslint-disable-next-line standard/no-callback-literal", "return", "callback", "(", "`", "${", "args", "}", "`", ")", "}", "else", "if", "(", "!", "spawnedProcess", ")", "{", "spawnedProcess", "=", "spawn", "(", "updateExe", ",", "args", ",", "{", "detached", ":", "detached", ",", "windowsHide", ":", "true", "}", ")", "spawnedArgs", "=", "args", "||", "[", "]", "}", "}", "catch", "(", "error1", ")", "{", "error", "=", "error1", "// Shouldn't happen, but still guard it.", "process", ".", "nextTick", "(", "function", "(", ")", "{", "return", "callback", "(", "error", ")", "}", ")", "return", "}", "stdout", "=", "''", "stderr", "=", "''", "spawnedProcess", ".", "stdout", ".", "on", "(", "'data'", ",", "(", "data", ")", "=>", "{", "stdout", "+=", "data", "}", ")", "spawnedProcess", ".", "stderr", ".", "on", "(", "'data'", ",", "(", "data", ")", "=>", "{", "stderr", "+=", "data", "}", ")", "errorEmitted", "=", "false", "spawnedProcess", ".", "on", "(", "'error'", ",", "(", "error", ")", "=>", "{", "errorEmitted", "=", "true", "callback", "(", "error", ")", "}", ")", "return", "spawnedProcess", ".", "on", "(", "'exit'", ",", "function", "(", "code", ",", "signal", ")", "{", "spawnedProcess", "=", "undefined", "spawnedArgs", "=", "[", "]", "// We may have already emitted an error.", "if", "(", "errorEmitted", ")", "{", "return", "}", "// Process terminated with error.", "if", "(", "code", "!==", "0", ")", "{", "// Disabled for backwards compatibility:", "// eslint-disable-next-line standard/no-callback-literal", "return", "callback", "(", "`", "${", "signal", "!=", "null", "?", "signal", ":", "code", "}", "\\n", "${", "stderr", "}", "`", ")", "}", "// Success.", "callback", "(", "null", ",", "stdout", ")", "}", ")", "}" ]

[ "Spawn", "a", "command", "and", "invoke", "the", "callback", "when", "it", "completes", "with", "an", "error", "and", "the", "output", "from", "standard", "out", "." ]

[ "function", "sortTopologically", "(", "originalOrder", ",", "edgesById", ")", "{", "const", "sorted", "=", "[", "]", "const", "marked", "=", "new", "Set", "(", ")", "const", "visit", "=", "(", "mark", ")", "=>", "{", "if", "(", "marked", ".", "has", "(", "mark", ")", ")", "return", "marked", ".", "add", "(", "mark", ")", "const", "edges", "=", "edgesById", ".", "get", "(", "mark", ")", "if", "(", "edges", "!=", "null", ")", "{", "edges", ".", "forEach", "(", "visit", ")", "}", "sorted", ".", "push", "(", "mark", ")", "}", "originalOrder", ".", "forEach", "(", "visit", ")", "return", "sorted", "}" ]

[ "Sort", "nodes", "topologically", "using", "a", "depth", "-", "first", "approach", ".", "Encountered", "cycles", "are", "broken", "." ]

[ "function", "(", "object", ")", "{", "const", "proto", "=", "Object", ".", "getPrototypeOf", "(", "object", ")", "if", "(", "proto", "===", "null", "||", "proto", "===", "Object", ".", "prototype", ")", "return", "null", "return", "{", "members", ":", "getObjectMembers", "(", "proto", ")", ",", "proto", ":", "getObjectPrototype", "(", "proto", ")", "}", "}" ]

[ "Return", "the", "description", "of", "object", "s", "prototype", "." ]

[ "function", "(", "sender", ",", "contextId", ",", "value", ",", "optimizeSimpleObject", "=", "false", ")", "{", "// Determine the type of value.", "const", "meta", "=", "{", "type", ":", "typeof", "value", "}", "if", "(", "meta", ".", "type", "===", "'object'", ")", "{", "// Recognize certain types of objects.", "if", "(", "value", "===", "null", ")", "{", "meta", ".", "type", "=", "'value'", "}", "else", "if", "(", "bufferUtils", ".", "isBuffer", "(", "value", ")", ")", "{", "meta", ".", "type", "=", "'buffer'", "}", "else", "if", "(", "Array", ".", "isArray", "(", "value", ")", ")", "{", "meta", ".", "type", "=", "'array'", "}", "else", "if", "(", "value", "instanceof", "Error", ")", "{", "meta", ".", "type", "=", "'error'", "}", "else", "if", "(", "value", "instanceof", "Date", ")", "{", "meta", ".", "type", "=", "'date'", "}", "else", "if", "(", "isPromise", "(", "value", ")", ")", "{", "meta", ".", "type", "=", "'promise'", "}", "else", "if", "(", "hasProp", ".", "call", "(", "value", ",", "'callee'", ")", "&&", "value", ".", "length", "!=", "null", ")", "{", "// Treat the arguments object as array.", "meta", ".", "type", "=", "'array'", "}", "else", "if", "(", "optimizeSimpleObject", "&&", "v8Util", ".", "getHiddenValue", "(", "value", ",", "'simple'", ")", ")", "{", "// Treat simple objects as value.", "meta", ".", "type", "=", "'value'", "}", "}", "// Fill the meta object according to value's type.", "if", "(", "meta", ".", "type", "===", "'array'", ")", "{", "meta", ".", "members", "=", "value", ".", "map", "(", "(", "el", ")", "=>", "valueToMeta", "(", "sender", ",", "contextId", ",", "el", ",", "optimizeSimpleObject", ")", ")", "}", "else", "if", "(", "meta", ".", "type", "===", "'object'", "||", "meta", ".", "type", "===", "'function'", ")", "{", "meta", ".", "name", "=", "value", ".", "constructor", "?", "value", ".", "constructor", ".", "name", ":", "''", "// Reference the original value if it's an object, because when it's", "// passed to renderer we would assume the renderer keeps a reference of", "// it.", "meta", ".", "id", "=", "objectsRegistry", ".", "add", "(", "sender", ",", "contextId", ",", "value", ")", "meta", ".", "members", "=", "getObjectMembers", "(", "value", ")", "meta", ".", "proto", "=", "getObjectPrototype", "(", "value", ")", "}", "else", "if", "(", "meta", ".", "type", "===", "'buffer'", ")", "{", "meta", ".", "value", "=", "bufferUtils", ".", "bufferToMeta", "(", "value", ")", "}", "else", "if", "(", "meta", ".", "type", "===", "'promise'", ")", "{", "// Add default handler to prevent unhandled rejections in main process", "// Instead they should appear in the renderer process", "value", ".", "then", "(", "function", "(", ")", "{", "}", ",", "function", "(", ")", "{", "}", ")", "meta", ".", "then", "=", "valueToMeta", "(", "sender", ",", "contextId", ",", "function", "(", "onFulfilled", ",", "onRejected", ")", "{", "value", ".", "then", "(", "onFulfilled", ",", "onRejected", ")", "}", ")", "}", "else", "if", "(", "meta", ".", "type", "===", "'error'", ")", "{", "meta", ".", "members", "=", "plainObjectToMeta", "(", "value", ")", "// Error.name is not part of own properties.", "meta", ".", "members", ".", "push", "(", "{", "name", ":", "'name'", ",", "value", ":", "value", ".", "name", "}", ")", "}", "else", "if", "(", "meta", ".", "type", "===", "'date'", ")", "{", "meta", ".", "value", "=", "value", ".", "getTime", "(", ")", "}", "else", "{", "meta", ".", "type", "=", "'value'", "meta", ".", "value", "=", "value", "}", "return", "meta", "}" ]

[ "Convert", "a", "real", "value", "into", "meta", "data", "." ]

[ "function", "(", "obj", ")", "{", "return", "Object", ".", "getOwnPropertyNames", "(", "obj", ")", ".", "map", "(", "function", "(", "name", ")", "{", "return", "{", "name", ":", "name", ",", "value", ":", "obj", "[", "name", "]", "}", "}", ")", "}" ]

[ "Convert", "object", "to", "meta", "by", "value", "." ]

[ "function", "(", "sender", ",", "frameId", ",", "contextId", ",", "args", ")", "{", "const", "metaToValue", "=", "function", "(", "meta", ")", "{", "switch", "(", "meta", ".", "type", ")", "{", "case", "'value'", ":", "return", "meta", ".", "value", "case", "'remote-object'", ":", "return", "objectsRegistry", ".", "get", "(", "meta", ".", "id", ")", "case", "'array'", ":", "return", "unwrapArgs", "(", "sender", ",", "frameId", ",", "contextId", ",", "meta", ".", "value", ")", "case", "'buffer'", ":", "return", "bufferUtils", ".", "metaToBuffer", "(", "meta", ".", "value", ")", "case", "'date'", ":", "return", "new", "Date", "(", "meta", ".", "value", ")", "case", "'promise'", ":", "return", "Promise", ".", "resolve", "(", "{", "then", ":", "metaToValue", "(", "meta", ".", "then", ")", "}", ")", "case", "'object'", ":", "{", "const", "ret", "=", "{", "}", "Object", ".", "defineProperty", "(", "ret", ".", "constructor", ",", "'name'", ",", "{", "value", ":", "meta", ".", "name", "}", ")", "for", "(", "const", "{", "name", ",", "value", "}", "of", "meta", ".", "members", ")", "{", "ret", "[", "name", "]", "=", "metaToValue", "(", "value", ")", "}", "return", "ret", "}", "case", "'function-with-return-value'", ":", "const", "returnValue", "=", "metaToValue", "(", "meta", ".", "value", ")", "return", "function", "(", ")", "{", "return", "returnValue", "}", "case", "'function'", ":", "{", "// Merge contextId and meta.id, since meta.id can be the same in", "// different webContents.", "const", "objectId", "=", "[", "contextId", ",", "meta", ".", "id", "]", "// Cache the callbacks in renderer.", "if", "(", "rendererFunctions", ".", "has", "(", "objectId", ")", ")", "{", "return", "rendererFunctions", ".", "get", "(", "objectId", ")", "}", "const", "callIntoRenderer", "=", "function", "(", "...", "args", ")", "{", "let", "succeed", "=", "false", "if", "(", "!", "sender", ".", "isDestroyed", "(", ")", ")", "{", "succeed", "=", "sender", ".", "_sendToFrameInternal", "(", "frameId", ",", "'ELECTRON_RENDERER_CALLBACK'", ",", "contextId", ",", "meta", ".", "id", ",", "valueToMeta", "(", "sender", ",", "contextId", ",", "args", ")", ")", "}", "if", "(", "!", "succeed", ")", "{", "removeRemoteListenersAndLogWarning", "(", "this", ",", "callIntoRenderer", ")", "}", "}", "v8Util", ".", "setHiddenValue", "(", "callIntoRenderer", ",", "'location'", ",", "meta", ".", "location", ")", "Object", ".", "defineProperty", "(", "callIntoRenderer", ",", "'length'", ",", "{", "value", ":", "meta", ".", "length", "}", ")", "v8Util", ".", "setRemoteCallbackFreer", "(", "callIntoRenderer", ",", "contextId", ",", "meta", ".", "id", ",", "sender", ")", "rendererFunctions", ".", "set", "(", "objectId", ",", "callIntoRenderer", ")", "return", "callIntoRenderer", "}", "default", ":", "throw", "new", "TypeError", "(", "`", "${", "meta", ".", "type", "}", "`", ")", "}", "}", "return", "args", ".", "map", "(", "metaToValue", ")", "}" ]

[ "Convert", "array", "of", "meta", "data", "from", "renderer", "into", "array", "of", "real", "values", "." ]

[ "function", "isValid", "(", "options", ")", "{", "const", "types", "=", "options", "?", "options", ".", "types", ":", "undefined", "return", "Array", ".", "isArray", "(", "types", ")", "}" ]

[ "|options", ".", "types|", "can", "t", "be", "empty", "and", "must", "be", "an", "array" ]

[ "async", "function", "updateVersion", "(", "version", ")", "{", "const", "versionPath", "=", "path", ".", "resolve", "(", "__dirname", ",", "'..'", ",", "'ELECTRON_VERSION'", ")", "await", "writeFile", "(", "versionPath", ",", "version", ",", "'utf8'", ")", "}" ]

[ "update", "VERSION", "file", "with", "latest", "release", "info" ]

[ "async", "function", "updatePackageJSON", "(", "version", ")", "{", "[", "'package.json'", "]", ".", "forEach", "(", "async", "fileName", "=>", "{", "const", "filePath", "=", "path", ".", "resolve", "(", "__dirname", ",", "'..'", ",", "fileName", ")", "const", "file", "=", "require", "(", "filePath", ")", "file", ".", "version", "=", "version", "await", "writeFile", "(", "filePath", ",", "JSON", ".", "stringify", "(", "file", ",", "null", ",", "2", ")", ")", "}", ")", "}" ]

[ "update", "package", "metadata", "files", "with", "new", "version" ]

[ "async", "function", "commitVersionBump", "(", "version", ")", "{", "const", "gitDir", "=", "path", ".", "resolve", "(", "__dirname", ",", "'..'", ")", "const", "gitArgs", "=", "[", "'commit'", ",", "'-a'", ",", "'-m'", ",", "`", "${", "version", "}", "`", ",", "'-n'", "]", "await", "GitProcess", ".", "exec", "(", "gitArgs", ",", "gitDir", ")", "}" ]

[ "push", "bump", "commit", "to", "release", "branch" ]

[ "async", "function", "updateWinRC", "(", "components", ")", "{", "const", "filePath", "=", "path", ".", "resolve", "(", "__dirname", ",", "'..'", ",", "'atom'", ",", "'browser'", ",", "'resources'", ",", "'win'", ",", "'atom.rc'", ")", "const", "data", "=", "await", "readFile", "(", "filePath", ",", "'utf8'", ")", "const", "arr", "=", "data", ".", "split", "(", "'\\n'", ")", "arr", ".", "forEach", "(", "(", "line", ",", "idx", ")", "=>", "{", "if", "(", "line", ".", "includes", "(", "'FILEVERSION'", ")", ")", "{", "arr", "[", "idx", "]", "=", "`", "${", "utils", ".", "makeVersion", "(", "components", ",", "','", ",", "utils", ".", "preType", ".", "PARTIAL", ")", "}", "`", "arr", "[", "idx", "+", "1", "]", "=", "`", "${", "utils", ".", "makeVersion", "(", "components", ",", "','", ",", "utils", ".", "preType", ".", "PARTIAL", ")", "}", "`", "}", "else", "if", "(", "line", ".", "includes", "(", "'FileVersion'", ")", ")", "{", "arr", "[", "idx", "]", "=", "`", "${", "utils", ".", "makeVersion", "(", "components", ",", "'.'", ")", "}", "`", "arr", "[", "idx", "+", "5", "]", "=", "`", "${", "utils", ".", "makeVersion", "(", "components", ",", "'.'", ")", "}", "`", "}", "}", ")", "await", "writeFile", "(", "filePath", ",", "arr", ".", "join", "(", "'\\n'", ")", ")", "}" ]

[ "updates", "atom", ".", "rc", "file", "with", "new", "semver", "values" ]

[ "function", "(", "child", ",", "parent", ",", "visited", ")", "{", "// Check for circular reference.", "if", "(", "visited", "==", "null", ")", "visited", "=", "new", "Set", "(", ")", "if", "(", "visited", ".", "has", "(", "parent", ")", ")", "return", "visited", ".", "add", "(", "parent", ")", "for", "(", "const", "key", "in", "parent", ")", "{", "if", "(", "key", "===", "'isBrowserView'", ")", "continue", "if", "(", "!", "hasProp", ".", "call", "(", "parent", ",", "key", ")", ")", "continue", "if", "(", "key", "in", "child", "&&", "key", "!==", "'webPreferences'", ")", "continue", "const", "value", "=", "parent", "[", "key", "]", "if", "(", "typeof", "value", "===", "'object'", ")", "{", "child", "[", "key", "]", "=", "mergeOptions", "(", "child", "[", "key", "]", "||", "{", "}", ",", "value", ",", "visited", ")", "}", "else", "{", "child", "[", "key", "]", "=", "value", "}", "}", "visited", ".", "delete", "(", "parent", ")", "return", "child", "}" ]

[ "Copy", "attribute", "of", "|parent|", "to", "|child|", "if", "it", "is", "not", "defined", "in", "|child|", "." ]

[ "function", "(", "embedder", ",", "options", ")", "{", "if", "(", "options", ".", "webPreferences", "==", "null", ")", "{", "options", ".", "webPreferences", "=", "{", "}", "}", "if", "(", "embedder", ".", "browserWindowOptions", "!=", "null", ")", "{", "let", "parentOptions", "=", "embedder", ".", "browserWindowOptions", "// if parent's visibility is available, that overrides 'show' flag (#12125)", "const", "win", "=", "BrowserWindow", ".", "fromWebContents", "(", "embedder", ".", "webContents", ")", "if", "(", "win", "!=", "null", ")", "{", "parentOptions", "=", "{", "...", "embedder", ".", "browserWindowOptions", ",", "show", ":", "win", ".", "isVisible", "(", ")", "}", "}", "// Inherit the original options if it is a BrowserWindow.", "mergeOptions", "(", "options", ",", "parentOptions", ")", "}", "else", "{", "// Or only inherit webPreferences if it is a webview.", "mergeOptions", "(", "options", ".", "webPreferences", ",", "embedder", ".", "getLastWebPreferences", "(", ")", ")", "}", "// Inherit certain option values from parent window", "const", "webPreferences", "=", "embedder", ".", "getLastWebPreferences", "(", ")", "for", "(", "const", "[", "name", ",", "value", "]", "of", "inheritedWebPreferences", ")", "{", "if", "(", "webPreferences", "[", "name", "]", "===", "value", ")", "{", "options", ".", "webPreferences", "[", "name", "]", "=", "value", "}", "}", "// Sets correct openerId here to give correct options to 'new-window' event handler", "options", ".", "webPreferences", ".", "openerId", "=", "embedder", ".", "id", "return", "options", "}" ]

[ "Merge", "|options|", "with", "the", "|embedder|", "s", "window", "s", "options", "." ]

[ "function", "(", "embedder", ",", "frameName", ",", "guest", ",", "options", ")", "{", "// When |embedder| is destroyed we should also destroy attached guest, and if", "// guest is closed by user then we should prevent |embedder| from double", "// closing guest.", "const", "guestId", "=", "guest", ".", "webContents", ".", "id", "const", "closedByEmbedder", "=", "function", "(", ")", "{", "guest", ".", "removeListener", "(", "'closed'", ",", "closedByUser", ")", "guest", ".", "destroy", "(", ")", "}", "const", "closedByUser", "=", "function", "(", ")", "{", "embedder", ".", "_sendInternal", "(", "'ELECTRON_GUEST_WINDOW_MANAGER_WINDOW_CLOSED_'", "+", "guestId", ")", "embedder", ".", "removeListener", "(", "'current-render-view-deleted'", ",", "closedByEmbedder", ")", "}", "embedder", ".", "once", "(", "'current-render-view-deleted'", ",", "closedByEmbedder", ")", "guest", ".", "once", "(", "'closed'", ",", "closedByUser", ")", "if", "(", "frameName", ")", "{", "frameToGuest", ".", "set", "(", "frameName", ",", "guest", ")", "guest", ".", "frameName", "=", "frameName", "guest", ".", "once", "(", "'closed'", ",", "function", "(", ")", "{", "frameToGuest", ".", "delete", "(", "frameName", ")", "}", ")", "}", "return", "guestId", "}" ]

[ "Setup", "a", "new", "guest", "with", "|embedder|" ]

[ "function", "(", "embedder", ",", "url", ",", "referrer", ",", "frameName", ",", "options", ",", "postData", ")", "{", "let", "guest", "=", "frameToGuest", ".", "get", "(", "frameName", ")", "if", "(", "frameName", "&&", "(", "guest", "!=", "null", ")", ")", "{", "guest", ".", "loadURL", "(", "url", ")", "return", "guest", ".", "webContents", ".", "id", "}", "// Remember the embedder window's id.", "if", "(", "options", ".", "webPreferences", "==", "null", ")", "{", "options", ".", "webPreferences", "=", "{", "}", "}", "guest", "=", "new", "BrowserWindow", "(", "options", ")", "if", "(", "!", "options", ".", "webContents", ")", "{", "// We should not call `loadURL` if the window was constructed from an", "// existing webContents (window.open in a sandboxed renderer).", "//", "// Navigating to the url when creating the window from an existing", "// webContents is not necessary (it will navigate there anyway).", "const", "loadOptions", "=", "{", "httpReferrer", ":", "referrer", "}", "if", "(", "postData", "!=", "null", ")", "{", "loadOptions", ".", "postData", "=", "postData", "loadOptions", ".", "extraHeaders", "=", "'content-type: application/x-www-form-urlencoded'", "if", "(", "postData", ".", "length", ">", "0", ")", "{", "const", "postDataFront", "=", "postData", "[", "0", "]", ".", "bytes", ".", "toString", "(", ")", "const", "boundary", "=", "/", "^--.*[^-\\r\\n]", "/", ".", "exec", "(", "postDataFront", ")", "if", "(", "boundary", "!=", "null", ")", "{", "loadOptions", ".", "extraHeaders", "=", "`", "${", "boundary", "[", "0", "]", ".", "substr", "(", "2", ")", "}", "`", "}", "}", "}", "guest", ".", "loadURL", "(", "url", ",", "loadOptions", ")", "}", "return", "setupGuest", "(", "embedder", ",", "frameName", ",", "guest", ",", "options", ")", "}" ]

[ "Create", "a", "new", "guest", "created", "by", "|embedder|", "with", "|options|", "." ]

[ "function", "getRenderedTree", "(", "story", ")", "{", "const", "{", "Component", ",", "props", "}", "=", "story", ".", "render", "(", ")", ";", "const", "DefaultCompatComponent", "=", "Component", ".", "default", "||", "Component", ";", "// We need to create a target to mount onto.", "const", "target", "=", "document", ".", "createElement", "(", "'section'", ")", ";", "new", "DefaultCompatComponent", "(", "{", "target", ",", "props", "}", ")", ";", "// eslint-disable-line", "// Classify the target so that it is clear where the markup", "// originates from, and that it is specific for snapshot tests.", "target", ".", "className", "=", "'storybook-snapshot-container'", ";", "return", "target", ";", "}" ]

[ "Provides", "functionality", "to", "convert", "your", "raw", "story", "to", "the", "resulting", "markup", "." ]

[ "function", "showException", "(", "exception", ")", "{", "addons", ".", "getChannel", "(", ")", ".", "emit", "(", "Events", ".", "STORY_THREW_EXCEPTION", ",", "exception", ")", ";", "showErrorDisplay", "(", "exception", ")", ";", "// Log the stack to the console. So, user could check the source code.", "logger", ".", "error", "(", "exception", ".", "stack", ")", ";", "}" ]

[ "showException", "is", "used", "if", "we", "fail", "to", "render", "the", "story", "and", "it", "is", "uncaught", "by", "the", "app", "layer" ]

[ "function", "loadFromPath", "(", "babelConfigPath", ")", "{", "let", "config", ";", "if", "(", "fs", ".", "existsSync", "(", "babelConfigPath", ")", ")", "{", "const", "content", "=", "fs", ".", "readFileSync", "(", "babelConfigPath", ",", "'utf-8'", ")", ";", "try", "{", "config", "=", "JSON5", ".", "parse", "(", "content", ")", ";", "config", ".", "babelrc", "=", "false", ";", "logger", ".", "info", "(", "'=> Loading custom .babelrc'", ")", ";", "}", "catch", "(", "e", ")", "{", "logger", ".", "error", "(", "`", "${", "e", ".", "message", "}", "`", ")", ";", "throw", "e", ";", "}", "}", "if", "(", "!", "config", ")", "return", "null", ";", "// Remove react-hmre preset.", "// It causes issues with react-storybook.", "// We don't really need it.", "// Earlier, we fix this by running storybook in the production mode.", "// But, that hide some useful debug messages.", "if", "(", "config", ".", "presets", ")", "{", "removeReactHmre", "(", "config", ".", "presets", ")", ";", "}", "if", "(", "config", ".", "env", "&&", "config", ".", "env", ".", "development", "&&", "config", ".", "env", ".", "development", ".", "presets", ")", "{", "removeReactHmre", "(", "config", ".", "env", ".", "development", ".", "presets", ")", ";", "}", "return", "config", ";", "}" ]

[ "Tries", "to", "load", "a", ".", "babelrc", "and", "returns", "the", "parsed", "object", "if", "successful" ]

[ "function", "importAll", "(", "context", ")", "{", "const", "storyStore", "=", "window", ".", "__STORYBOOK_CLIENT_API__", ".", "_storyStore", ";", "// eslint-disable-line no-undef, no-underscore-dangle", "context", ".", "keys", "(", ")", ".", "forEach", "(", "filename", "=>", "{", "const", "fileExports", "=", "context", "(", "filename", ")", ";", "// A old-style story file", "if", "(", "!", "fileExports", ".", "default", ")", "{", "return", ";", "}", "const", "{", "default", ":", "component", ",", "...", "examples", "}", "=", "fileExports", ";", "let", "componentOptions", "=", "component", ";", "if", "(", "component", ".", "prototype", "&&", "component", ".", "prototype", ".", "isReactComponent", ")", "{", "componentOptions", "=", "{", "component", "}", ";", "}", "const", "kindName", "=", "componentOptions", ".", "title", "||", "componentOptions", ".", "component", ".", "displayName", ";", "if", "(", "previousExports", "[", "filename", "]", ")", "{", "if", "(", "previousExports", "[", "filename", "]", "===", "fileExports", ")", "{", "return", ";", "}", "// Otherwise clear this kind", "storyStore", ".", "removeStoryKind", "(", "kindName", ")", ";", "storyStore", ".", "incrementRevision", "(", ")", ";", "}", "// We pass true here to avoid the warning about HMR. It's cool clientApi, we got this", "const", "kind", "=", "storiesOf", "(", "kindName", ",", "true", ")", ";", "(", "componentOptions", ".", "decorators", "||", "[", "]", ")", ".", "forEach", "(", "decorator", "=>", "{", "kind", ".", "addDecorator", "(", "decorator", ")", ";", "}", ")", ";", "if", "(", "componentOptions", ".", "parameters", ")", "{", "kind", ".", "addParameters", "(", "componentOptions", ".", "parameters", ")", ";", "}", "Object", ".", "keys", "(", "examples", ")", ".", "forEach", "(", "key", "=>", "{", "const", "example", "=", "examples", "[", "key", "]", ";", "const", "{", "title", "=", "key", ",", "parameters", "}", "=", "example", ";", "kind", ".", "add", "(", "title", ",", "example", ",", "parameters", ")", ";", "}", ")", ";", "previousExports", "[", "filename", "]", "=", "fileExports", ";", "}", ")", ";", "}" ]

[ "The", "simplest", "version", "of", "examples", "would", "just", "export", "this", "function", "for", "users", "to", "use" ]

[ "function", "extractRange", "(", "ranges", ",", "coord", ")", "{", "var", "axis", ",", "from", ",", "to", ",", "key", ",", "axes", "=", "plot", ".", "getAxes", "(", ")", ";", "for", "(", "var", "k", "in", "axes", ")", "{", "axis", "=", "axes", "[", "k", "]", ";", "if", "(", "axis", ".", "direction", "==", "coord", ")", "{", "key", "=", "coord", "+", "axis", ".", "n", "+", "\"axis\"", ";", "if", "(", "!", "ranges", "[", "key", "]", "&&", "axis", ".", "n", "==", "1", ")", "key", "=", "coord", "+", "\"axis\"", ";", "// support x1axis as xaxis", "if", "(", "ranges", "[", "key", "]", ")", "{", "from", "=", "ranges", "[", "key", "]", ".", "from", ";", "to", "=", "ranges", "[", "key", "]", ".", "to", ";", "break", ";", "}", "}", "}", "// backwards-compat stuff - to be removed in future", "if", "(", "!", "ranges", "[", "key", "]", ")", "{", "axis", "=", "coord", "==", "\"x\"", "?", "plot", ".", "getXAxes", "(", ")", "[", "0", "]", ":", "plot", ".", "getYAxes", "(", ")", "[", "0", "]", ";", "from", "=", "ranges", "[", "coord", "+", "\"1\"", "]", ";", "to", "=", "ranges", "[", "coord", "+", "\"2\"", "]", ";", "}", "// auto-reverse as an added bonus", "if", "(", "from", "!=", "null", "&&", "to", "!=", "null", "&&", "from", ">", "to", ")", "{", "var", "tmp", "=", "from", ";", "from", "=", "to", ";", "to", "=", "tmp", ";", "}", "return", "{", "from", ":", "from", ",", "to", ":", "to", ",", "axis", ":", "axis", "}", ";", "}" ]

[ "function", "taken", "from", "markings", "support", "in", "Flot" ]

[ "function", "(", "values", ")", "{", "var", "max", "=", "Number", ".", "MIN_VALUE", ",", "min", "=", "Number", ".", "MAX_VALUE", ",", "val", ",", "cc", ",", "attrs", "=", "{", "}", ";", "if", "(", "!", "(", "this", ".", "scale", "instanceof", "jvm", ".", "OrdinalScale", ")", "&&", "!", "(", "this", ".", "scale", "instanceof", "jvm", ".", "SimpleScale", ")", ")", "{", "if", "(", "!", "this", ".", "params", ".", "min", "||", "!", "this", ".", "params", ".", "max", ")", "{", "for", "(", "cc", "in", "values", ")", "{", "val", "=", "parseFloat", "(", "values", "[", "cc", "]", ")", ";", "if", "(", "val", ">", "max", ")", "max", "=", "values", "[", "cc", "]", ";", "if", "(", "val", "<", "min", ")", "min", "=", "val", ";", "}", "if", "(", "!", "this", ".", "params", ".", "min", ")", "{", "this", ".", "scale", ".", "setMin", "(", "min", ")", ";", "}", "if", "(", "!", "this", ".", "params", ".", "max", ")", "{", "this", ".", "scale", ".", "setMax", "(", "max", ")", ";", "}", "this", ".", "params", ".", "min", "=", "min", ";", "this", ".", "params", ".", "max", "=", "max", ";", "}", "for", "(", "cc", "in", "values", ")", "{", "val", "=", "parseFloat", "(", "values", "[", "cc", "]", ")", ";", "if", "(", "!", "isNaN", "(", "val", ")", ")", "{", "attrs", "[", "cc", "]", "=", "this", ".", "scale", ".", "getValue", "(", "val", ")", ";", "}", "else", "{", "attrs", "[", "cc", "]", "=", "this", ".", "elements", "[", "cc", "]", ".", "element", ".", "style", ".", "initial", "[", "this", ".", "params", ".", "attribute", "]", ";", "}", "}", "}", "else", "{", "for", "(", "cc", "in", "values", ")", "{", "if", "(", "values", "[", "cc", "]", ")", "{", "attrs", "[", "cc", "]", "=", "this", ".", "scale", ".", "getValue", "(", "values", "[", "cc", "]", ")", ";", "}", "else", "{", "attrs", "[", "cc", "]", "=", "this", ".", "elements", "[", "cc", "]", ".", "element", ".", "style", ".", "initial", "[", "this", ".", "params", ".", "attribute", "]", ";", "}", "}", "}", "this", ".", "setAttributes", "(", "attrs", ")", ";", "jvm", ".", "$", ".", "extend", "(", "this", ".", "values", ",", "values", ")", ";", "}" ]

[ "Set", "values", "for", "the", "data", "set", "." ]

[ "function", "(", "node", ")", "{", "assertRangeValid", "(", "this", ")", ";", "var", "parent", "=", "node", ".", "parentNode", ";", "var", "nodeIndex", "=", "getNodeIndex", "(", "node", ")", ";", "if", "(", "!", "parent", ")", "{", "throw", "new", "DOMException", "(", "\"NOT_FOUND_ERR\"", ")", ";", "}", "var", "startComparison", "=", "this", ".", "comparePoint", "(", "parent", ",", "nodeIndex", ")", ",", "endComparison", "=", "this", ".", "comparePoint", "(", "parent", ",", "nodeIndex", "+", "1", ")", ";", "if", "(", "startComparison", "<", "0", ")", "{", "// Node starts before", "return", "(", "endComparison", ">", "0", ")", "?", "n_b_a", ":", "n_b", ";", "}", "else", "{", "return", "(", "endComparison", ">", "0", ")", "?", "n_a", ":", "n_i", ";", "}", "}" ]

[ "The", "methods", "below", "are", "all", "non", "-", "standard", ".", "The", "following", "batch", "were", "introduced", "by", "Mozilla", "but", "have", "since", "been", "removed", "from", "Mozilla", "." ]

[ "function", "(", "sel", ",", "range", ")", "{", "var", "ranges", "=", "sel", ".", "getAllRanges", "(", ")", ";", "sel", ".", "removeAllRanges", "(", ")", ";", "for", "(", "var", "i", "=", "0", ",", "len", "=", "ranges", ".", "length", ";", "i", "<", "len", ";", "++", "i", ")", "{", "if", "(", "!", "rangesEqual", "(", "range", ",", "ranges", "[", "i", "]", ")", ")", "{", "sel", ".", "addRange", "(", "ranges", "[", "i", "]", ")", ";", "}", "}", "if", "(", "!", "sel", ".", "rangeCount", ")", "{", "updateEmptySelection", "(", "sel", ")", ";", "}", "}" ]

[ "Removal", "of", "a", "single", "range" ]

[ "function", "(", "context", ")", "{", "var", "element", "=", "context", ".", "createElement", "(", "\"div\"", ")", ",", "html5", "=", "\"<article>foo</article>\"", ";", "element", ".", "innerHTML", "=", "html5", ";", "return", "element", ".", "innerHTML", ".", "toLowerCase", "(", ")", "===", "html5", ";", "}" ]

[ "Everything", "below", "IE9", "doesn", "t", "know", "how", "to", "treat", "HTML5", "tags" ]

[ "function", "(", ")", "{", "var", "clonedTestElement", "=", "testElement", ".", "cloneNode", "(", "false", ")", ",", "returnValue", ",", "innerHTML", ";", "clonedTestElement", ".", "innerHTML", "=", "\"<p><div></div>\"", ";", "innerHTML", "=", "clonedTestElement", ".", "innerHTML", ".", "toLowerCase", "(", ")", ";", "returnValue", "=", "innerHTML", "===", "\"<p></p><div></div>\"", "||", "innerHTML", "===", "\"<p><div></div></p>\"", ";", "// Cache result by overwriting current function", "this", ".", "autoClosesUnclosedTags", "=", "function", "(", ")", "{", "return", "returnValue", ";", "}", ";", "return", "returnValue", ";", "}" ]

[ "Check", "whether", "the", "browser", "automatically", "closes", "tags", "that", "don", "t", "need", "to", "be", "opened" ]

[ "function", "(", "needle", ")", "{", "if", "(", "Array", ".", "isArray", "(", "needle", ")", ")", "{", "for", "(", "var", "i", "=", "needle", ".", "length", ";", "i", "--", ";", ")", "{", "if", "(", "wysihtml5", ".", "lang", ".", "array", "(", "arr", ")", ".", "indexOf", "(", "needle", "[", "i", "]", ")", "!==", "-", "1", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "else", "{", "return", "wysihtml5", ".", "lang", ".", "array", "(", "arr", ")", ".", "indexOf", "(", "needle", ")", "!==", "-", "1", ";", "}", "}" ]

[ "Check", "whether", "a", "given", "object", "exists", "in", "an", "array" ]

[ "function", "(", "needle", ")", "{", "if", "(", "arr", ".", "indexOf", ")", "{", "return", "arr", ".", "indexOf", "(", "needle", ")", ";", "}", "else", "{", "for", "(", "var", "i", "=", "0", ",", "length", "=", "arr", ".", "length", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "arr", "[", "i", "]", "===", "needle", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}", "}" ]

[ "Check", "whether", "a", "given", "object", "exists", "in", "an", "array", "and", "return", "index", "If", "no", "elelemt", "found", "returns", "-", "1" ]

[ "function", "(", "arrayToSubstract", ")", "{", "arrayToSubstract", "=", "wysihtml5", ".", "lang", ".", "array", "(", "arrayToSubstract", ")", ";", "var", "newArr", "=", "[", "]", ",", "i", "=", "0", ",", "length", "=", "arr", ".", "length", ";", "for", "(", ";", "i", "<", "length", ";", "i", "++", ")", "{", "if", "(", "!", "arrayToSubstract", ".", "contains", "(", "arr", "[", "i", "]", ")", ")", "{", "newArr", ".", "push", "(", "arr", "[", "i", "]", ")", ";", "}", "}", "return", "newArr", ";", "}" ]

[ "Substract", "one", "array", "from", "another" ]

[ "function", "(", ")", "{", "var", "i", "=", "0", ",", "length", "=", "arr", ".", "length", ",", "newArray", "=", "[", "]", ";", "for", "(", ";", "i", "<", "length", ";", "i", "++", ")", "{", "newArray", ".", "push", "(", "arr", "[", "i", "]", ")", ";", "}", "return", "newArray", ";", "}" ]

[ "Return", "a", "clean", "native", "array" ]

[ "function", "(", "callback", ",", "thisArg", ")", "{", "if", "(", "Array", ".", "prototype", ".", "map", ")", "{", "return", "arr", ".", "map", "(", "callback", ",", "thisArg", ")", ";", "}", "else", "{", "var", "len", "=", "arr", ".", "length", ">>>", "0", ",", "A", "=", "new", "Array", "(", "len", ")", ",", "i", "=", "0", ";", "for", "(", ";", "i", "<", "len", ";", "i", "++", ")", "{", "A", "[", "i", "]", "=", "callback", ".", "call", "(", "thisArg", ",", "arr", "[", "i", "]", ",", "i", ",", "arr", ")", ";", "}", "return", "A", ";", "}", "}" ]

[ "Creates", "a", "new", "array", "with", "the", "results", "of", "calling", "a", "provided", "function", "on", "every", "element", "in", "this", "array", ".", "optionally", "this", "can", "be", "provided", "as", "second", "argument" ]

[ "function", "_convertUrlsToLinks", "(", "str", ")", "{", "return", "str", ".", "replace", "(", "URL_REG_EXP", ",", "function", "(", "match", ",", "url", ")", "{", "var", "punctuation", "=", "(", "url", ".", "match", "(", "TRAILING_CHAR_REG_EXP", ")", "||", "[", "]", ")", "[", "1", "]", "||", "\"\"", ",", "opening", "=", "BRACKETS", "[", "punctuation", "]", ";", "url", "=", "url", ".", "replace", "(", "TRAILING_CHAR_REG_EXP", ",", "\"\"", ")", ";", "if", "(", "url", ".", "split", "(", "opening", ")", ".", "length", ">", "url", ".", "split", "(", "punctuation", ")", ".", "length", ")", "{", "url", "=", "url", "+", "punctuation", ";", "punctuation", "=", "\"\"", ";", "}", "var", "realUrl", "=", "url", ",", "displayUrl", "=", "url", ";", "if", "(", "url", ".", "length", ">", "MAX_DISPLAY_LENGTH", ")", "{", "displayUrl", "=", "displayUrl", ".", "substr", "(", "0", ",", "MAX_DISPLAY_LENGTH", ")", "+", "\"...\"", ";", "}", "// Add http prefix if necessary", "if", "(", "realUrl", ".", "substr", "(", "0", ",", "4", ")", "===", "\"www.\"", ")", "{", "realUrl", "=", "\"http://\"", "+", "realUrl", ";", "}", "return", "'<a href=\"'", "+", "realUrl", "+", "'\">'", "+", "displayUrl", "+", "'</a>'", "+", "punctuation", ";", "}", ")", ";", "}" ]

[ "This", "is", "basically", "a", "rebuild", "of", "the", "rails", "auto_link_urls", "text", "helper" ]

[ "function", "_wrapMatchesInNode", "(", "textNode", ")", "{", "var", "parentNode", "=", "textNode", ".", "parentNode", ",", "nodeValue", "=", "wysihtml5", ".", "lang", ".", "string", "(", "textNode", ".", "data", ")", ".", "escapeHTML", "(", ")", ",", "tempElement", "=", "_getTempElement", "(", "parentNode", ".", "ownerDocument", ")", ";", "// We need to insert an empty/temporary <span /> to fix IE quirks", "// Elsewise IE would strip white space in the beginning", "tempElement", ".", "innerHTML", "=", "\"<span></span>\"", "+", "_convertUrlsToLinks", "(", "nodeValue", ")", ";", "tempElement", ".", "removeChild", "(", "tempElement", ".", "firstChild", ")", ";", "while", "(", "tempElement", ".", "firstChild", ")", "{", "// inserts tempElement.firstChild before textNode", "parentNode", ".", "insertBefore", "(", "tempElement", ".", "firstChild", ",", "textNode", ")", ";", "}", "parentNode", ".", "removeChild", "(", "textNode", ")", ";", "}" ]

[ "Replaces", "the", "original", "text", "nodes", "with", "the", "newly", "auto", "-", "linked", "dom", "tree" ]

[ "function", "(", "context", ")", "{", "if", "(", "context", ".", "_wysihtml5_supportsHTML5Tags", ")", "{", "return", ";", "}", "for", "(", "var", "i", "=", "0", ",", "length", "=", "HTML5_ELEMENTS", ".", "length", ";", "i", "<", "length", ";", "i", "++", ")", "{", "context", ".", "createElement", "(", "HTML5_ELEMENTS", "[", "i", "]", ")", ";", "}", "context", ".", "_wysihtml5_supportsHTML5Tags", "=", "true", ";", "}" ]

[ "Make", "sure", "IE", "supports", "HTML5", "tags", "which", "is", "accomplished", "by", "simply", "creating", "one", "instance", "of", "each", "element" ]

[ "function", "parse", "(", "elementOrHtml", ",", "config", ")", "{", "wysihtml5", ".", "lang", ".", "object", "(", "currentRules", ")", ".", "merge", "(", "defaultRules", ")", ".", "merge", "(", "config", ".", "rules", ")", ".", "get", "(", ")", ";", "var", "context", "=", "config", ".", "context", "||", "elementOrHtml", ".", "ownerDocument", "||", "document", ",", "fragment", "=", "context", ".", "createDocumentFragment", "(", ")", ",", "isString", "=", "typeof", "(", "elementOrHtml", ")", "===", "\"string\"", ",", "clearInternals", "=", "false", ",", "element", ",", "newNode", ",", "firstChild", ";", "if", "(", "config", ".", "clearInternals", "===", "true", ")", "{", "clearInternals", "=", "true", ";", "}", "if", "(", "isString", ")", "{", "element", "=", "wysihtml5", ".", "dom", ".", "getAsDom", "(", "elementOrHtml", ",", "context", ")", ";", "}", "else", "{", "element", "=", "elementOrHtml", ";", "}", "if", "(", "currentRules", ".", "selectors", ")", "{", "_applySelectorRules", "(", "element", ",", "currentRules", ".", "selectors", ")", ";", "}", "while", "(", "element", ".", "firstChild", ")", "{", "firstChild", "=", "element", ".", "firstChild", ";", "newNode", "=", "_convert", "(", "firstChild", ",", "config", ".", "cleanUp", ",", "clearInternals", ",", "config", ".", "uneditableClass", ")", ";", "if", "(", "newNode", ")", "{", "fragment", ".", "appendChild", "(", "newNode", ")", ";", "}", "if", "(", "firstChild", "!==", "newNode", ")", "{", "element", ".", "removeChild", "(", "firstChild", ")", ";", "}", "}", "if", "(", "config", ".", "unjoinNbsps", ")", "{", "// replace joined non-breakable spaces with unjoined", "var", "txtnodes", "=", "wysihtml5", ".", "dom", ".", "getTextNodes", "(", "fragment", ")", ";", "for", "(", "var", "n", "=", "txtnodes", ".", "length", ";", "n", "--", ";", ")", "{", "txtnodes", "[", "n", "]", ".", "nodeValue", "=", "txtnodes", "[", "n", "]", ".", "nodeValue", ".", "replace", "(", "/", "([\\S\\u00A0])\\u00A0", "/", "gi", ",", "\"$1 \"", ")", ";", "}", "}", "// Clear element contents", "element", ".", "innerHTML", "=", "\"\"", ";", "// Insert new DOM tree", "element", ".", "appendChild", "(", "fragment", ")", ";", "return", "isString", "?", "wysihtml5", ".", "quirks", ".", "getCorrectInnerHTML", "(", "element", ")", ":", "element", ";", "}" ]

[ "Iterates", "over", "all", "childs", "of", "the", "element", "recreates", "them", "appends", "them", "into", "a", "document", "fragment", "which", "later", "replaces", "the", "entire", "body", "content" ]

[ "function", "(", ")", "{", "var", "that", "=", "this", ",", "iframe", "=", "doc", ".", "createElement", "(", "\"iframe\"", ")", ";", "iframe", ".", "className", "=", "\"wysihtml5-sandbox\"", ";", "wysihtml5", ".", "dom", ".", "setAttributes", "(", "{", "\"security\"", ":", "\"restricted\"", ",", "\"allowtransparency\"", ":", "\"true\"", ",", "\"frameborder\"", ":", "0", ",", "\"width\"", ":", "0", ",", "\"height\"", ":", "0", ",", "\"marginwidth\"", ":", "0", ",", "\"marginheight\"", ":", "0", "}", ")", ".", "on", "(", "iframe", ")", ";", "// Setting the src like this prevents ssl warnings in IE6", "if", "(", "wysihtml5", ".", "browser", ".", "throwsMixedContentWarningWhenIframeSrcIsEmpty", "(", ")", ")", "{", "iframe", ".", "src", "=", "\"javascript:'<html></html>'\"", ";", "}", "iframe", ".", "onload", "=", "function", "(", ")", "{", "iframe", ".", "onreadystatechange", "=", "iframe", ".", "onload", "=", "null", ";", "that", ".", "_onLoadIframe", "(", "iframe", ")", ";", "}", ";", "iframe", ".", "onreadystatechange", "=", "function", "(", ")", "{", "if", "(", "/", "loaded|complete", "/", ".", "test", "(", "iframe", ".", "readyState", ")", ")", "{", "iframe", ".", "onreadystatechange", "=", "iframe", ".", "onload", "=", "null", ";", "that", ".", "_onLoadIframe", "(", "iframe", ")", ";", "}", "}", ";", "return", "iframe", ";", "}" ]

[ "Creates", "the", "sandbox", "iframe" ]

[ "function", "(", "contentEditable", ")", "{", "contentEditable", ".", "className", "=", "(", "contentEditable", ".", "className", "&&", "contentEditable", ".", "className", "!=", "''", ")", "?", "contentEditable", ".", "className", "+", "\" wysihtml5-sandbox\"", ":", "\"wysihtml5-sandbox\"", ";", "this", ".", "_loadElement", "(", "contentEditable", ",", "true", ")", ";", "return", "contentEditable", ";", "}" ]

[ "initiates", "an", "allready", "existent", "contenteditable" ]

[ "function", "(", "cell", ")", "{", "if", "(", "cell", ".", "isColspan", ")", "{", "var", "colspan", "=", "parseInt", "(", "api", ".", "getAttribute", "(", "cell", ".", "el", ",", "'colspan'", ")", "||", "1", ",", "10", ")", ",", "cType", "=", "cell", ".", "el", ".", "tagName", ".", "toLowerCase", "(", ")", ";", "if", "(", "colspan", ">", "1", ")", "{", "var", "newCells", "=", "this", ".", "createCells", "(", "cType", ",", "colspan", "-", "1", ")", ";", "insertAfter", "(", "cell", ".", "el", ",", "newCells", ")", ";", "}", "cell", ".", "el", ".", "removeAttribute", "(", "'colspan'", ")", ";", "}", "}" ]

[ "Splits", "merged", "cell", "on", "row", "to", "unique", "cells" ]

[ "function", "(", ")", "{", "var", "oldRow", "=", "api", ".", "getParentElement", "(", "this", ".", "cell", ",", "{", "nodeName", ":", "[", "\"TR\"", "]", "}", ")", ";", "if", "(", "oldRow", ")", "{", "this", ".", "setTableMap", "(", ")", ";", "this", ".", "idx", "=", "this", ".", "getMapIndex", "(", "this", ".", "cell", ")", ";", "if", "(", "this", ".", "idx", "!==", "false", ")", "{", "var", "modRow", "=", "this", ".", "map", "[", "this", ".", "idx", ".", "row", "]", ";", "for", "(", "var", "cidx", "=", "0", ",", "cmax", "=", "modRow", ".", "length", ";", "cidx", "<", "cmax", ";", "cidx", "++", ")", "{", "if", "(", "!", "modRow", "[", "cidx", "]", ".", "modified", ")", "{", "this", ".", "setCellAsModified", "(", "modRow", "[", "cidx", "]", ")", ";", "this", ".", "removeRowCell", "(", "modRow", "[", "cidx", "]", ")", ";", "}", "}", "}", "removeElement", "(", "oldRow", ")", ";", "}", "}" ]

[ "Removes", "the", "row", "of", "selected", "cell" ]

[ "function", "removeCellSelections", "(", ")", "{", "if", "(", "editable", ")", "{", "var", "selectedCells", "=", "editable", ".", "querySelectorAll", "(", "'.'", "+", "selection_class", ")", ";", "if", "(", "selectedCells", ".", "length", ">", "0", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "selectedCells", ".", "length", ";", "i", "++", ")", "{", "dom", ".", "removeClass", "(", "selectedCells", "[", "i", "]", ",", "selection_class", ")", ";", "}", "}", "}", "}" ]

[ "remove", "all", "selection", "classes" ]

[ "function", "getDepth", "(", "ancestor", ",", "descendant", ")", "{", "var", "ret", "=", "0", ";", "while", "(", "descendant", "!==", "ancestor", ")", "{", "ret", "++", ";", "descendant", "=", "descendant", ".", "parentNode", ";", "if", "(", "!", "descendant", ")", "throw", "new", "Error", "(", "\"not a descendant of ancestor!\"", ")", ";", "}", "return", "ret", ";", "}" ]

[ "Provides", "the", "depth", "of", "descendant", "relative", "to", "ancestor" ]

[ "function", "expandRangeToSurround", "(", "range", ")", "{", "if", "(", "range", ".", "canSurroundContents", "(", ")", ")", "return", ";", "var", "common", "=", "range", ".", "commonAncestorContainer", ",", "start_depth", "=", "getDepth", "(", "common", ",", "range", ".", "startContainer", ")", ",", "end_depth", "=", "getDepth", "(", "common", ",", "range", ".", "endContainer", ")", ";", "while", "(", "!", "range", ".", "canSurroundContents", "(", ")", ")", "{", "// In the following branches, we cannot just decrement the depth variables because the setStartBefore/setEndAfter may move the start or end of the range more than one level relative to ``common``. So we need to recompute the depth.", "if", "(", "start_depth", ">", "end_depth", ")", "{", "range", ".", "setStartBefore", "(", "range", ".", "startContainer", ")", ";", "start_depth", "=", "getDepth", "(", "common", ",", "range", ".", "startContainer", ")", ";", "}", "else", "{", "range", ".", "setEndAfter", "(", "range", ".", "endContainer", ")", ";", "end_depth", "=", "getDepth", "(", "common", ",", "range", ".", "endContainer", ")", ";", "}", "}", "}" ]

[ "Should", "fix", "the", "obtained", "ranges", "that", "cannot", "surrond", "contents", "normally", "to", "apply", "changes", "upon", "Being", "considerate", "to", "firefox", "that", "sets", "range", "start", "start", "out", "of", "span", "and", "end", "inside", "on", "doubleclick", "initiated", "selection" ]

[ "function", "(", "node", ")", "{", "var", "range", "=", "rangy", ".", "createRange", "(", "this", ".", "doc", ")", ";", "range", ".", "setStartBefore", "(", "node", ")", ";", "range", ".", "setEndBefore", "(", "node", ")", ";", "return", "this", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "Set", "the", "caret", "in", "front", "of", "the", "given", "node" ]

[ "function", "(", "node", ")", "{", "var", "range", "=", "rangy", ".", "createRange", "(", "this", ".", "doc", ")", ";", "range", ".", "setStartAfter", "(", "node", ")", ";", "range", ".", "setEndAfter", "(", "node", ")", ";", "return", "this", ".", "setSelection", "(", "range", ")", ";", "}" ]

[ "Set", "the", "caret", "after", "the", "given", "node" ]

[ "function", "(", "controlRange", ")", "{", "var", "selection", ",", "range", ";", "if", "(", "controlRange", "&&", "this", ".", "doc", ".", "selection", "&&", "this", ".", "doc", ".", "selection", ".", "type", "===", "\"Control\"", ")", "{", "range", "=", "this", ".", "doc", ".", "selection", ".", "createRange", "(", ")", ";", "if", "(", "range", "&&", "range", ".", "length", ")", "{", "return", "range", ".", "item", "(", "0", ")", ";", "}", "}", "selection", "=", "this", ".", "getSelection", "(", "this", ".", "doc", ")", ";", "if", "(", "selection", ".", "focusNode", "===", "selection", ".", "anchorNode", ")", "{", "return", "selection", ".", "focusNode", ";", "}", "else", "{", "range", "=", "this", ".", "getRange", "(", "this", ".", "doc", ")", ";", "return", "range", "?", "range", ".", "commonAncestorContainer", ":", "this", ".", "doc", ".", "body", ";", "}", "}" ]

[ "Get", "the", "node", "which", "contains", "the", "selection" ]