Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "copyResources", "(", "output", ",", "plugin", ")", "{", "var", "logger", "=", "output", ".", "getLogger", "(", ")", ";", "var", "options", "=", "output", ".", "getOptions", "(", ")", ";", "var", "outputRoot", "=", "options", ".", "get", "(", "'root'", ")", ";", "var", "state", "=", "output", ".", "getState", "(", ")", ";", "var", "resources", "=", "state", ".", "getResources", "(", ")", ";", "var", "pluginRoot", "=", "plugin", ".", "getPath", "(", ")", ";", "var", "pluginResources", "=", "resources", ".", "get", "(", "plugin", ".", "getName", "(", ")", ")", ";", "var", "assetsFolder", "=", "pluginResources", ".", "get", "(", "'assets'", ")", ";", "var", "assetOutputFolder", "=", "path", ".", "join", "(", "outputRoot", ",", "'gitbook'", ",", "plugin", ".", "getNpmID", "(", ")", ")", ";", "if", "(", "!", "assetsFolder", ")", "{", "return", "Promise", "(", ")", ";", "}", "// Resolve assets folder", "assetsFolder", "=", "path", ".", "resolve", "(", "pluginRoot", ",", "assetsFolder", ")", ";", "if", "(", "!", "fs", ".", "existsSync", "(", "assetsFolder", ")", ")", "{", "logger", ".", "warn", ".", "ln", "(", "'assets folder for plugin \"'", "+", "plugin", ".", "getName", "(", ")", "+", "'\" doesn\\'t exist'", ")", ";", "return", "Promise", "(", ")", ";", "}", "logger", ".", "debug", ".", "ln", "(", "'copy resources from plugin'", ",", "assetsFolder", ")", ";", "return", "fs", ".", "copyDir", "(", "assetsFolder", ",", "assetOutputFolder", ",", "{", "deleteFirst", ":", "false", ",", "overwrite", ":", "true", ",", "confirm", ":", "true", "}", ")", ";", "}" ]

[ "Copy", "resources", "from", "a", "plugin" ]

[ "function", "writeFile", "(", "output", ",", "filePath", ",", "content", ")", "{", "var", "rootFolder", "=", "output", ".", "getRoot", "(", ")", ";", "filePath", "=", "path", ".", "join", "(", "rootFolder", ",", "filePath", ")", ";", "return", "fs", ".", "ensureFile", "(", "filePath", ")", ".", "then", "(", "function", "(", ")", "{", "return", "fs", ".", "writeFile", "(", "filePath", ",", "content", ")", ";", "}", ")", ".", "thenResolve", "(", "output", ")", ";", "}" ]

[ "Write", "a", "file", "to", "the", "output", "folder" ]

[ "function", "encodeProgress", "(", "output", ",", "page", ")", "{", "var", "current", "=", "page", ".", "getPath", "(", ")", ";", "var", "navigation", "=", "encodeNavigation", "(", "output", ")", ";", "navigation", "=", "Immutable", ".", "Map", "(", "navigation", ")", ";", "var", "n", "=", "navigation", ".", "size", ";", "var", "percent", "=", "0", ",", "prevPercent", "=", "0", ",", "currentChapter", "=", "null", ";", "var", "done", "=", "true", ";", "var", "chapters", "=", "navigation", ".", "map", "(", "function", "(", "nav", ",", "chapterPath", ")", "{", "nav", ".", "path", "=", "chapterPath", ";", "return", "nav", ";", "}", ")", ".", "valueSeq", "(", ")", ".", "sortBy", "(", "function", "(", "nav", ")", "{", "return", "nav", ".", "index", ";", "}", ")", ".", "map", "(", "function", "(", "nav", ",", "i", ")", "{", "// Calcul percent", "nav", ".", "percent", "=", "(", "i", "*", "100", ")", "/", "Math", ".", "max", "(", "(", "n", "-", "1", ")", ",", "1", ")", ";", "// Is it done", "nav", ".", "done", "=", "done", ";", "if", "(", "nav", ".", "path", "==", "current", ")", "{", "currentChapter", "=", "nav", ";", "percent", "=", "nav", ".", "percent", ";", "done", "=", "false", ";", "}", "else", "if", "(", "done", ")", "{", "prevPercent", "=", "nav", ".", "percent", ";", "}", "return", "nav", ";", "}", ")", ".", "toJS", "(", ")", ";", "return", "{", "// Previous percent", "prevPercent", ":", "prevPercent", ",", "// Current percent", "percent", ":", "percent", ",", "// List of chapter with progress", "chapters", ":", "chapters", ",", "// Current chapter", "current", ":", "currentChapter", "}", ";", "}" ]

[ "page", ".", "progress", "is", "a", "deprecated", "property", "from", "GitBook", "v2" ]

[ "function", "inlineAssets", "(", "rootFolder", ",", "currentFile", ")", "{", "return", "function", "(", "$", ")", "{", "return", "Promise", "(", ")", "// Resolving images and fetching external images should be", "// done before svg conversion", ".", "then", "(", "resolveImages", ".", "bind", "(", "null", ",", "currentFile", ",", "$", ")", ")", ".", "then", "(", "fetchRemoteImages", ".", "bind", "(", "null", ",", "rootFolder", ",", "currentFile", ",", "$", ")", ")", ".", "then", "(", "svgToImg", ".", "bind", "(", "null", ",", "rootFolder", ",", "currentFile", ",", "$", ")", ")", ".", "then", "(", "svgToPng", ".", "bind", "(", "null", ",", "rootFolder", ",", "currentFile", ",", "$", ")", ")", ".", "then", "(", "inlinePng", ".", "bind", "(", "null", ",", "rootFolder", ",", "currentFile", ",", "$", ")", ")", ";", "}", ";", "}" ]

[ "Inline", "all", "assets", "in", "a", "page" ]

[ "function", "findForBook", "(", "book", ")", "{", "return", "timing", ".", "measure", "(", "'plugins.findForBook'", ",", "Promise", ".", "all", "(", "[", "findInstalled", "(", "locateRootFolder", "(", ")", ")", ",", "findInstalled", "(", "book", ".", "getRoot", "(", ")", ")", "]", ")", "// Merge all plugins", ".", "then", "(", "function", "(", "results", ")", "{", "return", "Immutable", ".", "List", "(", "results", ")", ".", "reduce", "(", "function", "(", "out", ",", "result", ")", "{", "return", "out", ".", "merge", "(", "result", ")", ";", "}", ",", "Immutable", ".", "OrderedMap", "(", ")", ")", ";", "}", ")", ")", ";", "}" ]

[ "List", "all", "plugins", "installed", "in", "a", "book" ]

[ "function", "parseIgnore", "(", "book", ")", "{", "if", "(", "book", ".", "isLanguageBook", "(", ")", ")", "{", "return", "Promise", ".", "reject", "(", "new", "Error", "(", "'Ignore files could be parsed for language books'", ")", ")", ";", "}", "var", "fs", "=", "book", ".", "getFS", "(", ")", ";", "var", "ignore", "=", "book", ".", "getIgnore", "(", ")", ";", "ignore", "=", "ignore", ".", "add", "(", "DEFAULT_IGNORES", ")", ";", "return", "Promise", ".", "serie", "(", "IGNORE_FILES", ",", "function", "(", "filename", ")", "{", "return", "fs", ".", "readAsString", "(", "filename", ")", ".", "then", "(", "function", "(", "content", ")", "{", "ignore", "=", "ignore", ".", "add", "(", "content", ".", "toString", "(", ")", ".", "split", "(", "/", "\\r?\\n", "/", ")", ")", ";", "}", ",", "function", "(", "err", ")", "{", "return", "Promise", "(", ")", ";", "}", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "return", "book", ".", "setIgnore", "(", "ignore", ")", ";", "}", ")", ";", "}" ]

[ "Parse", "ignore", "files" ]

[ "function", "getOutputFolder", "(", "args", ")", "{", "var", "bookRoot", "=", "path", ".", "resolve", "(", "args", "[", "0", "]", "||", "process", ".", "cwd", "(", ")", ")", ";", "var", "defaultOutputRoot", "=", "path", ".", "join", "(", "bookRoot", ",", "'_book'", ")", ";", "var", "outputFolder", "=", "args", "[", "1", "]", "?", "path", ".", "resolve", "(", "process", ".", "cwd", "(", ")", ",", "args", "[", "1", "]", ")", ":", "defaultOutputRoot", ";", "return", "outputFolder", ";", "}" ]

[ "Return", "path", "to", "output", "folder" ]

[ "function", "decodeGlobal", "(", "config", ",", "result", ")", "{", "var", "values", "=", "result", ".", "values", ";", "delete", "values", ".", "generator", ";", "delete", "values", ".", "output", ";", "return", "config", ".", "updateValues", "(", "values", ")", ";", "}" ]

[ "Decode", "changes", "from", "a", "JS", "API", "to", "a", "config", "object" ]

[ "function", "encodeNavigation", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "pages", "=", "output", ".", "getPages", "(", ")", ";", "var", "summary", "=", "book", ".", "getSummary", "(", ")", ";", "var", "articles", "=", "summary", ".", "getArticlesAsList", "(", ")", ";", "var", "navigation", "=", "articles", ".", "map", "(", "function", "(", "article", ",", "i", ")", "{", "var", "ref", "=", "article", ".", "getRef", "(", ")", ";", "if", "(", "!", "ref", ")", "{", "return", "undefined", ";", "}", "var", "prev", "=", "articles", ".", "get", "(", "i", "-", "1", ")", ";", "var", "next", "=", "articles", ".", "get", "(", "i", "+", "1", ")", ";", "return", "[", "ref", ",", "{", "index", ":", "i", ",", "title", ":", "article", ".", "getTitle", "(", ")", ",", "introduction", ":", "(", "i", "===", "0", ")", ",", "prev", ":", "prev", "?", "encodeArticle", "(", "pages", ",", "prev", ")", ":", "undefined", ",", "next", ":", "next", "?", "encodeArticle", "(", "pages", ",", "next", ")", ":", "undefined", ",", "level", ":", "article", ".", "getLevel", "(", ")", "}", "]", ";", "}", ")", ".", "filter", "(", "function", "(", "e", ")", "{", "return", "Boolean", "(", "e", ")", ";", "}", ")", ";", "return", "Immutable", ".", "Map", "(", "navigation", ")", ".", "toJS", "(", ")", ";", "}" ]

[ "this", ".", "navigation", "is", "a", "deprecated", "property", "from", "GitBook", "v2" ]

[ "function", "encodeOutputToJson", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "generator", "=", "output", ".", "getGenerator", "(", ")", ";", "var", "options", "=", "output", ".", "getOptions", "(", ")", ";", "var", "result", "=", "encodeBook", "(", "book", ")", ";", "result", ".", "output", "=", "{", "name", ":", "generator", "}", ";", "result", ".", "options", "=", "options", ".", "toJS", "(", ")", ";", "return", "result", ";", "}" ]

[ "Encode", "an", "output", "to", "JSON" ]

[ "function", "parsePage", "(", "book", ",", "page", ")", "{", "var", "fs", "=", "book", ".", "getContentFS", "(", ")", ";", "var", "file", "=", "page", ".", "getFile", "(", ")", ";", "return", "fs", ".", "readAsString", "(", "file", ".", "getPath", "(", ")", ")", ".", "then", "(", "function", "(", "content", ")", "{", "return", "parsePageFromString", "(", "page", ",", "content", ")", ";", "}", ")", ";", "}" ]

[ "Parse", "a", "page", "read", "its", "content", "and", "parse", "the", "YAMl", "header" ]

[ "function", "listAssets", "(", "book", ",", "pages", ")", "{", "var", "fs", "=", "book", ".", "getContentFS", "(", ")", ";", "var", "summary", "=", "book", ".", "getSummary", "(", ")", ";", "var", "summaryFile", "=", "summary", ".", "getFile", "(", ")", ".", "getPath", "(", ")", ";", "var", "glossary", "=", "book", ".", "getGlossary", "(", ")", ";", "var", "glossaryFile", "=", "glossary", ".", "getFile", "(", ")", ".", "getPath", "(", ")", ";", "var", "langs", "=", "book", ".", "getLanguages", "(", ")", ";", "var", "langsFile", "=", "langs", ".", "getFile", "(", ")", ".", "getPath", "(", ")", ";", "var", "config", "=", "book", ".", "getConfig", "(", ")", ";", "var", "configFile", "=", "config", ".", "getFile", "(", ")", ".", "getPath", "(", ")", ";", "function", "filterFile", "(", "file", ")", "{", "return", "!", "(", "file", "===", "summaryFile", "||", "file", "===", "glossaryFile", "||", "file", "===", "langsFile", "||", "file", "===", "configFile", "||", "book", ".", "isContentFileIgnored", "(", "file", ")", "||", "pages", ".", "has", "(", "file", ")", ")", ";", "}", "return", "timing", ".", "measure", "(", "'parse.listAssets'", ",", "fs", ".", "listAllFiles", "(", "'.'", ",", "filterFile", ")", ")", ";", "}" ]

[ "List", "all", "assets", "in", "a", "book", "Assets", "are", "file", "not", "ignored", "and", "not", "a", "page" ]

[ "function", "createMockFS", "(", "files", ")", "{", "files", "=", "Immutable", ".", "fromJS", "(", "files", ")", ";", "var", "mtime", "=", "new", "Date", "(", ")", ";", "function", "getFile", "(", "filePath", ")", "{", "var", "parts", "=", "path", ".", "normalize", "(", "filePath", ")", ".", "split", "(", "path", ".", "sep", ")", ";", "return", "parts", ".", "reduce", "(", "function", "(", "list", ",", "part", ",", "i", ")", "{", "if", "(", "!", "list", ")", "return", "null", ";", "var", "file", ";", "if", "(", "!", "part", "||", "part", "===", "'.'", ")", "file", "=", "list", ";", "else", "file", "=", "list", ".", "get", "(", "part", ")", ";", "if", "(", "!", "file", ")", "return", "null", ";", "if", "(", "is", ".", "string", "(", "file", ")", ")", "{", "if", "(", "i", "===", "(", "parts", ".", "length", "-", "1", ")", ")", "return", "file", ";", "else", "return", "null", ";", "}", "return", "file", ";", "}", ",", "files", ")", ";", "}", "function", "fsExists", "(", "filePath", ")", "{", "return", "Boolean", "(", "getFile", "(", "filePath", ")", "!==", "null", ")", ";", "}", "function", "fsReadFile", "(", "filePath", ")", "{", "var", "file", "=", "getFile", "(", "filePath", ")", ";", "if", "(", "!", "is", ".", "string", "(", "file", ")", ")", "{", "throw", "error", ".", "FileNotFoundError", "(", "{", "filename", ":", "filePath", "}", ")", ";", "}", "return", "new", "Buffer", "(", "file", ",", "'utf8'", ")", ";", "}", "function", "fsStatFile", "(", "filePath", ")", "{", "var", "file", "=", "getFile", "(", "filePath", ")", ";", "if", "(", "!", "file", ")", "{", "throw", "error", ".", "FileNotFoundError", "(", "{", "filename", ":", "filePath", "}", ")", ";", "}", "return", "{", "mtime", ":", "mtime", "}", ";", "}", "function", "fsReadDir", "(", "filePath", ")", "{", "var", "dir", "=", "getFile", "(", "filePath", ")", ";", "if", "(", "!", "dir", "||", "is", ".", "string", "(", "dir", ")", ")", "{", "throw", "error", ".", "FileNotFoundError", "(", "{", "filename", ":", "filePath", "}", ")", ";", "}", "return", "dir", ".", "map", "(", "function", "(", "content", ",", "name", ")", "{", "if", "(", "!", "is", ".", "string", "(", "content", ")", ")", "{", "name", "=", "name", "+", "'/'", ";", "}", "return", "name", ";", "}", ")", ".", "valueSeq", "(", ")", ";", "}", "return", "FS", ".", "create", "(", "{", "root", ":", "''", ",", "fsExists", ":", "fsExists", ",", "fsReadFile", ":", "fsReadFile", ",", "fsStatFile", ":", "fsStatFile", ",", "fsReadDir", ":", "fsReadDir", "}", ")", ";", "}" ]

[ "Create", "a", "fake", "filesystem", "for", "unit", "testing", "GitBook", "." ]

[ "function", "fileExists", "(", "filename", ")", "{", "var", "d", "=", "Promise", ".", "defer", "(", ")", ";", "fs", ".", "exists", "(", "filename", ",", "function", "(", "exists", ")", "{", "d", ".", "resolve", "(", "exists", ")", ";", "}", ")", ";", "return", "d", ".", "promise", ";", "}" ]

[ "Return", "a", "promise", "resolved", "with", "a", "boolean" ]

[ "function", "ensureFile", "(", "filename", ")", "{", "var", "base", "=", "path", ".", "dirname", "(", "filename", ")", ";", "return", "Promise", ".", "nfcall", "(", "mkdirp", ",", "base", ")", ";", "}" ]

[ "Create", "all", "required", "folder", "to", "create", "a", "file" ]

[ "function", "pickFile", "(", "rootFolder", ",", "fileName", ")", "{", "var", "result", "=", "path", ".", "join", "(", "rootFolder", ",", "fileName", ")", ";", "if", "(", "fs", ".", "existsSync", "(", "result", ")", ")", "{", "return", "result", ";", "}", "return", "undefined", ";", "}" ]

[ "Pick", "a", "file", "returns", "the", "absolute", "path", "if", "exists", "undefined", "otherwise" ]

[ "function", "ensureFolder", "(", "rootFolder", ")", "{", "return", "rmDir", "(", "rootFolder", ")", ".", "fail", "(", "function", "(", ")", "{", "return", "Promise", "(", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "return", "Promise", ".", "nfcall", "(", "mkdirp", ",", "rootFolder", ")", ";", "}", ")", ";", "}" ]

[ "Ensure", "that", "a", "directory", "exists", "and", "is", "empty" ]

[ "function", "decodeGlobal", "(", "output", ",", "result", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "config", "=", "book", ".", "getConfig", "(", ")", ";", "// Update config", "config", "=", "decodeConfig", "(", "config", ",", "result", ".", "config", ")", ";", "book", "=", "book", ".", "set", "(", "'config'", ",", "config", ")", ";", "return", "output", ".", "set", "(", "'book'", ",", "book", ")", ";", "}" ]

[ "Decode", "changes", "from", "a", "JS", "API", "to", "a", "output", "object", ".", "Only", "the", "configuration", "can", "be", "edited", "by", "plugin", "s", "hooks" ]

[ "function", "encodeFileToJson", "(", "file", ")", "{", "var", "filePath", "=", "file", ".", "getPath", "(", ")", ";", "if", "(", "!", "filePath", ")", "{", "return", "undefined", ";", "}", "return", "{", "path", ":", "filePath", ",", "mtime", ":", "file", ".", "getMTime", "(", ")", ",", "type", ":", "file", ".", "getType", "(", ")", "}", ";", "}" ]

[ "Return", "a", "JSON", "representation", "of", "a", "file" ]

[ "function", "parseLanguages", "(", "book", ")", "{", "var", "logger", "=", "book", ".", "getLogger", "(", ")", ";", "return", "parseStructureFile", "(", "book", ",", "'langs'", ")", ".", "spread", "(", "function", "(", "file", ",", "result", ")", "{", "if", "(", "!", "file", ")", "{", "return", "book", ";", "}", "var", "languages", "=", "Languages", ".", "createFromList", "(", "file", ",", "result", ")", ";", "logger", ".", "debug", ".", "ln", "(", "'languages index file found at'", ",", "file", ".", "getPath", "(", ")", ")", ";", "logger", ".", "info", ".", "ln", "(", "'parsing multilingual book, with'", ",", "languages", ".", "getList", "(", ")", ".", "size", ",", "'languages'", ")", ";", "return", "book", ".", "set", "(", "'languages'", ",", "languages", ")", ";", "}", ")", ";", "}" ]

[ "Parse", "languages", "list", "from", "book" ]

[ "function", "onFinish", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "options", "=", "output", ".", "getOptions", "(", ")", ";", "var", "prefix", "=", "options", ".", "get", "(", "'prefix'", ")", ";", "if", "(", "!", "book", ".", "isMultilingual", "(", ")", ")", "{", "return", "Promise", "(", "output", ")", ";", "}", "var", "filePath", "=", "'index.html'", ";", "var", "engine", "=", "createTemplateEngine", "(", "output", ",", "filePath", ")", ";", "var", "context", "=", "JSONUtils", ".", "encodeOutput", "(", "output", ")", ";", "// Render the theme", "return", "Templating", ".", "renderFile", "(", "engine", ",", "prefix", "+", "'/languages.html'", ",", "context", ")", "// Write it to the disk", ".", "then", "(", "function", "(", "tplOut", ")", "{", "return", "writeFile", "(", "output", ",", "filePath", ",", "tplOut", ".", "getContent", "(", ")", ")", ";", "}", ")", ";", "}" ]

[ "Finish", "the", "generation", "write", "the", "languages", "index" ]

[ "function", "generatePages", "(", "generator", ",", "output", ")", "{", "var", "pages", "=", "output", ".", "getPages", "(", ")", ";", "var", "logger", "=", "output", ".", "getLogger", "(", ")", ";", "// Is generator ignoring assets?", "if", "(", "!", "generator", ".", "onPage", ")", "{", "return", "Promise", "(", "output", ")", ";", "}", "return", "Promise", ".", "reduce", "(", "pages", ",", "function", "(", "out", ",", "page", ")", "{", "var", "file", "=", "page", ".", "getFile", "(", ")", ";", "logger", ".", "debug", ".", "ln", "(", "'generate page \"'", "+", "file", ".", "getPath", "(", ")", "+", "'\"'", ")", ";", "return", "generatePage", "(", "out", ",", "page", ")", ".", "then", "(", "function", "(", "resultPage", ")", "{", "return", "generator", ".", "onPage", "(", "out", ",", "resultPage", ")", ";", "}", ")", ".", "fail", "(", "function", "(", "err", ")", "{", "logger", ".", "error", ".", "ln", "(", "'error while generating page \"'", "+", "file", ".", "getPath", "(", ")", "+", "'\":'", ")", ";", "throw", "err", ";", "}", ")", ";", "}", ",", "output", ")", ";", "}" ]

[ "Output", "all", "pages", "using", "a", "generator" ]

[ "function", "addPlugin", "(", "config", ",", "pluginName", ",", "version", ")", "{", "// For default plugin, we only ensure it is enabled", "if", "(", "isDefaultPlugin", "(", "pluginName", ",", "version", ")", ")", "{", "return", "togglePlugin", "(", "config", ",", "pluginName", ",", "true", ")", ";", "}", "var", "deps", "=", "config", ".", "getPluginDependencies", "(", ")", ";", "var", "dep", "=", "PluginDependency", ".", "create", "(", "pluginName", ",", "version", ")", ";", "deps", "=", "deps", ".", "push", "(", "dep", ")", ";", "return", "config", ".", "setPluginDependencies", "(", "deps", ")", ";", "}" ]

[ "Add", "a", "plugin", "to", "a", "book", "s", "configuration" ]

[ "function", "prepareAssets", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "pages", "=", "output", ".", "getPages", "(", ")", ";", "var", "logger", "=", "output", ".", "getLogger", "(", ")", ";", "return", "Parse", ".", "listAssets", "(", "book", ",", "pages", ")", ".", "then", "(", "function", "(", "assets", ")", "{", "logger", ".", "info", ".", "ln", "(", "'found'", ",", "assets", ".", "size", ",", "'asset files'", ")", ";", "return", "output", ".", "set", "(", "'assets'", ",", "assets", ")", ";", "}", ")", ";", "}" ]

[ "List", "all", "assets", "in", "the", "book" ]

[ "function", "encodeGlossary", "(", "glossary", ")", "{", "var", "file", "=", "glossary", ".", "getFile", "(", ")", ";", "var", "entries", "=", "glossary", ".", "getEntries", "(", ")", ";", "return", "{", "file", ":", "encodeFile", "(", "file", ")", ",", "entries", ":", "entries", ".", "map", "(", "encodeGlossaryEntry", ")", ".", "toJS", "(", ")", "}", ";", "}" ]

[ "Encode", "a", "glossary", "to", "JSON" ]

[ "function", "measure", "(", "type", ",", "p", ")", "{", "timers", "[", "type", "]", "=", "timers", "[", "type", "]", "||", "{", "type", ":", "type", ",", "count", ":", "0", ",", "total", ":", "0", ",", "min", ":", "undefined", ",", "max", ":", "0", "}", ";", "var", "start", "=", "Date", ".", "now", "(", ")", ";", "return", "p", ".", "fin", "(", "function", "(", ")", "{", "var", "end", "=", "Date", ".", "now", "(", ")", ";", "var", "duration", "=", "(", "end", "-", "start", ")", ";", "timers", "[", "type", "]", ".", "count", "++", ";", "timers", "[", "type", "]", ".", "total", "+=", "duration", ";", "if", "(", "is", ".", "undefined", "(", "timers", "[", "type", "]", ".", "min", ")", ")", "{", "timers", "[", "type", "]", ".", "min", "=", "duration", ";", "}", "else", "{", "timers", "[", "type", "]", ".", "min", "=", "Math", ".", "min", "(", "timers", "[", "type", "]", ".", "min", ",", "duration", ")", ";", "}", "timers", "[", "type", "]", ".", "max", "=", "Math", ".", "max", "(", "timers", "[", "type", "]", ".", "max", ",", "duration", ")", ";", "}", ")", ";", "}" ]

[ "Mesure", "an", "operation" ]

[ "function", "dump", "(", "logger", ")", "{", "var", "prefix", "=", "' > '", ";", "var", "measured", "=", "0", ";", "var", "totalDuration", "=", "Date", ".", "now", "(", ")", "-", "startDate", ";", "// Enable debug logging", "var", "logLevel", "=", "logger", ".", "getLevel", "(", ")", ";", "logger", ".", "setLevel", "(", "'debug'", ")", ";", "Immutable", ".", "Map", "(", "timers", ")", ".", "valueSeq", "(", ")", ".", "sortBy", "(", "function", "(", "timer", ")", "{", "measured", "+=", "timer", ".", "total", ";", "return", "timer", ".", "total", ";", "}", ")", ".", "forEach", "(", "function", "(", "timer", ")", "{", "var", "percent", "=", "(", "timer", ".", "total", "*", "100", ")", "/", "totalDuration", ";", "logger", ".", "debug", ".", "ln", "(", "(", "percent", ".", "toFixed", "(", "1", ")", ")", "+", "'% of time spent in \"'", "+", "timer", ".", "type", "+", "'\" ('", "+", "timer", ".", "count", "+", "' times) :'", ")", ";", "logger", ".", "debug", ".", "ln", "(", "prefix", "+", "'Total: '", "+", "time", "(", "timer", ".", "total", ")", "+", "' | Average: '", "+", "time", "(", "timer", ".", "total", "/", "timer", ".", "count", ")", ")", ";", "logger", ".", "debug", ".", "ln", "(", "prefix", "+", "'Min: '", "+", "time", "(", "timer", ".", "min", ")", "+", "' | Max: '", "+", "time", "(", "timer", ".", "max", ")", ")", ";", "logger", ".", "debug", ".", "ln", "(", "'---------------------------'", ")", ";", "}", ")", ";", "logger", ".", "debug", ".", "ln", "(", "time", "(", "totalDuration", "-", "measured", ")", "+", "' spent in non-mesured sections'", ")", ";", "// Rollback to previous level", "logger", ".", "setLevel", "(", "logLevel", ")", ";", "}" ]

[ "Dump", "all", "timers", "to", "a", "logger" ]

[ "function", "loadPlugin", "(", "book", ",", "plugin", ")", "{", "var", "logger", "=", "book", ".", "getLogger", "(", ")", ";", "var", "name", "=", "plugin", ".", "getName", "(", ")", ";", "var", "pkgPath", "=", "plugin", ".", "getPath", "(", ")", ";", "// Try loading plugins from different location", "var", "p", "=", "Promise", "(", ")", ".", "then", "(", "function", "(", ")", "{", "var", "packageContent", ";", "var", "packageMain", ";", "var", "content", ";", "// Locate plugin and load package.json", "try", "{", "var", "res", "=", "resolve", ".", "sync", "(", "'./package.json'", ",", "{", "basedir", ":", "pkgPath", "}", ")", ";", "pkgPath", "=", "path", ".", "dirname", "(", "res", ")", ";", "packageContent", "=", "require", "(", "res", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "!", "isModuleNotFound", "(", "err", ")", ")", "throw", "err", ";", "packageContent", "=", "undefined", ";", "content", "=", "undefined", ";", "return", ";", "}", "// Locate the main package", "try", "{", "var", "indexJs", "=", "path", ".", "normalize", "(", "packageContent", ".", "main", "||", "'index.js'", ")", ";", "packageMain", "=", "resolve", ".", "sync", "(", "'./'", "+", "indexJs", ",", "{", "basedir", ":", "pkgPath", "}", ")", ";", "}", "catch", "(", "err", ")", "{", "if", "(", "!", "isModuleNotFound", "(", "err", ")", ")", "throw", "err", ";", "packageMain", "=", "undefined", ";", "}", "// Load plugin JS content", "if", "(", "packageMain", ")", "{", "try", "{", "content", "=", "require", "(", "packageMain", ")", ";", "}", "catch", "(", "err", ")", "{", "throw", "new", "error", ".", "PluginError", "(", "err", ",", "{", "plugin", ":", "name", "}", ")", ";", "}", "}", "// Update plugin", "return", "plugin", ".", "merge", "(", "{", "'package'", ":", "Immutable", ".", "fromJS", "(", "packageContent", ")", ",", "'content'", ":", "Immutable", ".", "fromJS", "(", "content", "||", "{", "}", ")", "}", ")", ";", "}", ")", ".", "then", "(", "validatePlugin", ")", ";", "p", "=", "timing", ".", "measure", "(", "'plugin.load'", ",", "p", ")", ";", "logger", ".", "info", "(", "'loading plugin \"'", "+", "name", "+", "'\"... '", ")", ";", "return", "logger", ".", "info", ".", "promise", "(", "p", ")", ";", "}" ]

[ "Load", "a", "plugin", "in", "a", "book" ]

[ "function", "installPlugin", "(", "book", ",", "plugin", ")", "{", "var", "logger", "=", "book", ".", "getLogger", "(", ")", ";", "var", "installFolder", "=", "book", ".", "getRoot", "(", ")", ";", "var", "name", "=", "plugin", ".", "getName", "(", ")", ";", "var", "requirement", "=", "plugin", ".", "getVersion", "(", ")", ";", "logger", ".", "info", ".", "ln", "(", "''", ")", ";", "logger", ".", "info", ".", "ln", "(", "'installing plugin \"'", "+", "name", "+", "'\"'", ")", ";", "// Find a version to install", "return", "resolveVersion", "(", "plugin", ")", ".", "then", "(", "function", "(", "version", ")", "{", "if", "(", "!", "version", ")", "{", "throw", "new", "Error", "(", "'Found no satisfactory version for plugin \"'", "+", "name", "+", "'\" with requirement \"'", "+", "requirement", "+", "'\"'", ")", ";", "}", "logger", ".", "info", ".", "ln", "(", "'install plugin \"'", "+", "name", "+", "'\" ('", "+", "requirement", "+", "') from NPM with version'", ",", "version", ")", ";", "return", "Promise", ".", "nfcall", "(", "npmi", ",", "{", "'name'", ":", "plugin", ".", "getNpmID", "(", ")", ",", "'version'", ":", "version", ",", "'path'", ":", "installFolder", ",", "'npmLoad'", ":", "{", "'loglevel'", ":", "'silent'", ",", "'loaded'", ":", "true", ",", "'prefix'", ":", "installFolder", "}", "}", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "logger", ".", "info", ".", "ok", "(", "'plugin \"'", "+", "name", "+", "'\" installed with success'", ")", ";", "}", ")", ";", "}" ]

[ "Install", "a", "plugin", "for", "a", "book" ]

[ "function", "encodeSummary", "(", "output", ",", "summary", ")", "{", "var", "result", "=", "{", "/**\n Iterate over the summary, it stops when the \"iter\" returns false\n\n @param {Function} iter\n */", "walk", ":", "function", "(", "iter", ")", "{", "summary", ".", "getArticle", "(", "function", "(", "article", ")", "{", "var", "jsonArticle", "=", "encodeSummaryArticle", "(", "article", ",", "false", ")", ";", "return", "iter", "(", "jsonArticle", ")", ";", "}", ")", ";", "}", ",", "/**\n Get an article by its level\n\n @param {String} level\n @return {Object}\n */", "getArticleByLevel", ":", "function", "(", "level", ")", "{", "var", "article", "=", "summary", ".", "getByLevel", "(", "level", ")", ";", "return", "(", "article", "?", "encodeSummaryArticle", "(", "article", ")", ":", "undefined", ")", ";", "}", ",", "/**\n Get an article by its path\n\n @param {String} level\n @return {Object}\n */", "getArticleByPath", ":", "function", "(", "level", ")", "{", "var", "article", "=", "summary", ".", "getByPath", "(", "level", ")", ";", "return", "(", "article", "?", "encodeSummaryArticle", "(", "article", ")", ":", "undefined", ")", ";", "}", "}", ";", "return", "result", ";", "}" ]

[ "Encode", "summary", "to", "provide", "an", "API", "to", "plugin" ]

[ "function", "(", "iter", ")", "{", "summary", ".", "getArticle", "(", "function", "(", "article", ")", "{", "var", "jsonArticle", "=", "encodeSummaryArticle", "(", "article", ",", "false", ")", ";", "return", "iter", "(", "jsonArticle", ")", ";", "}", ")", ";", "}" ]

[ "Iterate", "over", "the", "summary", "it", "stops", "when", "the", "iter", "returns", "false" ]

[ "function", "indexLevels", "(", "summary", ")", "{", "var", "parts", "=", "summary", ".", "getParts", "(", ")", ";", "parts", "=", "parts", ".", "map", "(", "indexPartLevels", ")", ";", "return", "summary", ".", "set", "(", "'parts'", ",", "parts", ")", ";", "}" ]

[ "Index", "all", "levels", "in", "the", "summary" ]

[ "function", "extractKwargs", "(", "args", ")", "{", "var", "last", "=", "args", "[", "args", ".", "length", "-", "1", "]", ";", "return", "(", "is", ".", "object", "(", "last", ")", "&&", "last", ".", "__keywords", ")", "?", "args", ".", "pop", "(", ")", ":", "{", "}", ";", "}" ]

[ "Extract", "kwargs", "from", "an", "arguments", "array" ]

[ "function", "encodePage", "(", "page", ",", "summary", ")", "{", "var", "file", "=", "page", ".", "getFile", "(", ")", ";", "var", "attributes", "=", "page", ".", "getAttributes", "(", ")", ";", "var", "article", "=", "summary", ".", "getByPath", "(", "file", ".", "getPath", "(", ")", ")", ";", "var", "result", "=", "attributes", ".", "toJS", "(", ")", ";", "if", "(", "article", ")", "{", "result", ".", "title", "=", "article", ".", "getTitle", "(", ")", ";", "result", ".", "level", "=", "article", ".", "getLevel", "(", ")", ";", "result", ".", "depth", "=", "article", ".", "getDepth", "(", ")", ";", "var", "nextArticle", "=", "summary", ".", "getNextArticle", "(", "article", ")", ";", "if", "(", "nextArticle", ")", "{", "result", ".", "next", "=", "encodeSummaryArticle", "(", "nextArticle", ")", ";", "}", "var", "prevArticle", "=", "summary", ".", "getPrevArticle", "(", "article", ")", ";", "if", "(", "prevArticle", ")", "{", "result", ".", "previous", "=", "encodeSummaryArticle", "(", "prevArticle", ")", ";", "}", "}", "result", ".", "content", "=", "page", ".", "getContent", "(", ")", ";", "result", ".", "dir", "=", "page", ".", "getDir", "(", ")", ";", "return", "result", ";", "}" ]

[ "Return", "a", "JSON", "representation", "of", "a", "page" ]

[ "function", "findInstalled", "(", "folder", ")", "{", "var", "options", "=", "{", "dev", ":", "false", ",", "log", ":", "function", "(", ")", "{", "}", ",", "depth", ":", "4", "}", ";", "var", "results", "=", "Immutable", ".", "OrderedMap", "(", ")", ";", "function", "onPackage", "(", "pkg", ",", "parent", ")", "{", "if", "(", "!", "pkg", ".", "name", ")", "return", ";", "var", "name", "=", "pkg", ".", "name", ";", "var", "version", "=", "pkg", ".", "version", ";", "var", "pkgPath", "=", "pkg", ".", "realPath", ";", "var", "depth", "=", "pkg", ".", "depth", ";", "var", "dependencies", "=", "pkg", ".", "dependencies", ";", "var", "pluginName", "=", "name", ".", "slice", "(", "PREFIX", ".", "length", ")", ";", "if", "(", "!", "validateId", "(", "name", ")", ")", "{", "if", "(", "parent", ")", "return", ";", "}", "else", "{", "results", "=", "results", ".", "set", "(", "pluginName", ",", "Plugin", "(", "{", "name", ":", "pluginName", ",", "version", ":", "version", ",", "path", ":", "pkgPath", ",", "depth", ":", "depth", ",", "parent", ":", "parent", "}", ")", ")", ";", "}", "Immutable", ".", "Map", "(", "dependencies", ")", ".", "forEach", "(", "function", "(", "dep", ")", "{", "onPackage", "(", "dep", ",", "pluginName", ")", ";", "}", ")", ";", "}", "// Search for gitbook-plugins in node_modules folder", "var", "node_modules", "=", "path", ".", "join", "(", "folder", ",", "'node_modules'", ")", ";", "// List all folders in node_modules", "return", "fs", ".", "readdir", "(", "node_modules", ")", ".", "fail", "(", "function", "(", ")", "{", "return", "Promise", "(", "[", "]", ")", ";", "}", ")", ".", "then", "(", "function", "(", "modules", ")", "{", "return", "Promise", ".", "serie", "(", "modules", ",", "function", "(", "module", ")", "{", "// Not a gitbook-plugin", "if", "(", "!", "validateId", "(", "module", ")", ")", "{", "return", "Promise", "(", ")", ";", "}", "// Read gitbook-plugin package details", "var", "module_folder", "=", "path", ".", "join", "(", "node_modules", ",", "module", ")", ";", "return", "Promise", ".", "nfcall", "(", "readInstalled", ",", "module_folder", ",", "options", ")", ".", "then", "(", "function", "(", "data", ")", "{", "onPackage", "(", "data", ")", ";", "}", ")", ";", "}", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "// Return installed plugins", "return", "results", ";", "}", ")", ";", "}" ]

[ "List", "all", "packages", "installed", "inside", "a", "folder" ]

[ "function", "encodePage", "(", "output", ",", "page", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "summary", "=", "book", ".", "getSummary", "(", ")", ";", "var", "fs", "=", "book", ".", "getContentFS", "(", ")", ";", "var", "file", "=", "page", ".", "getFile", "(", ")", ";", "// JS Page is based on the JSON output", "var", "result", "=", "JSONUtils", ".", "encodePage", "(", "page", ",", "summary", ")", ";", "result", ".", "type", "=", "file", ".", "getType", "(", ")", ";", "result", ".", "path", "=", "file", ".", "getPath", "(", ")", ";", "result", ".", "rawPath", "=", "fs", ".", "resolve", "(", "result", ".", "path", ")", ";", "deprecate", ".", "field", "(", "output", ",", "'page.progress'", ",", "result", ",", "'progress'", ",", "function", "(", ")", "{", "return", "encodeProgress", "(", "output", ",", "page", ")", ";", "}", ",", "'\"page.progress\" property is deprecated'", ")", ";", "deprecate", ".", "field", "(", "output", ",", "'page.sections'", ",", "result", ",", "'sections'", ",", "[", "{", "content", ":", "result", ".", "content", ",", "type", ":", "'normal'", "}", "]", ",", "'\"sections\" property is deprecated, use page.content instead'", ")", ";", "return", "result", ";", "}" ]

[ "Encode", "a", "page", "in", "a", "context", "to", "a", "JS", "API" ]

[ "function", "logNotice", "(", "book", ",", "key", ",", "message", ")", "{", "if", "(", "logged", "[", "key", "]", "||", "disabled", "[", "key", "]", ")", "return", ";", "logged", "[", "key", "]", "=", "true", ";", "var", "logger", "=", "book", ".", "getLogger", "(", ")", ";", "logger", ".", "warn", ".", "ln", "(", "message", ")", ";", "}" ]

[ "Log", "a", "deprecated", "notice" ]

[ "function", "deprecateMethod", "(", "book", ",", "key", ",", "fn", ",", "msg", ")", "{", "return", "function", "(", ")", "{", "logNotice", "(", "book", ",", "key", ",", "msg", ")", ";", "return", "fn", ".", "apply", "(", "this", ",", "arguments", ")", ";", "}", ";", "}" ]

[ "Deprecate", "a", "function" ]

[ "function", "deprecateField", "(", "book", ",", "key", ",", "instance", ",", "property", ",", "value", ",", "msg", ")", "{", "var", "store", "=", "undefined", ";", "var", "prepare", "=", "function", "(", ")", "{", "if", "(", "!", "is", ".", "undefined", "(", "store", ")", ")", "return", ";", "if", "(", "is", ".", "fn", "(", "value", ")", ")", "store", "=", "value", "(", ")", ";", "else", "store", "=", "value", ";", "}", ";", "var", "getter", "=", "function", "(", ")", "{", "prepare", "(", ")", ";", "logNotice", "(", "book", ",", "key", ",", "msg", ")", ";", "return", "store", ";", "}", ";", "var", "setter", "=", "function", "(", "v", ")", "{", "prepare", "(", ")", ";", "logNotice", "(", "book", ",", "key", ",", "msg", ")", ";", "store", "=", "v", ";", "return", "store", ";", "}", ";", "Object", ".", "defineProperty", "(", "instance", ",", "property", ",", "{", "get", ":", "getter", ",", "set", ":", "setter", ",", "enumerable", ":", "true", ",", "configurable", ":", "true", "}", ")", ";", "}" ]

[ "Deprecate", "a", "property", "of", "an", "object" ]

[ "function", "deprecateRenamedMethod", "(", "book", ",", "key", ",", "instance", ",", "oldName", ",", "newName", ",", "msg", ")", "{", "msg", "=", "msg", "||", "(", "'\"'", "+", "oldName", "+", "'\" is deprecated, use \"'", "+", "newName", "+", "'()\" instead'", ")", ";", "var", "fn", "=", "objectPath", ".", "get", "(", "instance", ",", "newName", ")", ";", "instance", "[", "oldName", "]", "=", "deprecateMethod", "(", "book", ",", "key", ",", "fn", ",", "msg", ")", ";", "}" ]

[ "Deprecate", "a", "method", "in", "favor", "of", "another", "one" ]

[ "function", "modifyHTML", "(", "page", ",", "operations", ")", "{", "var", "html", "=", "page", ".", "getContent", "(", ")", ";", "var", "$", "=", "cheerio", ".", "load", "(", "html", ")", ";", "return", "Promise", ".", "forEach", "(", "operations", ",", "function", "(", "op", ")", "{", "return", "op", "(", "$", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "var", "resultHTML", "=", "$", ".", "html", "(", ")", ";", "return", "page", ".", "set", "(", "'content'", ",", "resultHTML", ")", ";", "}", ")", ";", "}" ]

[ "Apply", "a", "list", "of", "operations", "to", "a", "page", "and", "output", "the", "new", "page", "." ]

[ "function", "validateConfig", "(", "bookJson", ")", "{", "var", "v", "=", "new", "jsonschema", ".", "Validator", "(", ")", ";", "var", "result", "=", "v", ".", "validate", "(", "bookJson", ",", "schema", ",", "{", "propertyName", ":", "'config'", "}", ")", ";", "// Throw error", "if", "(", "result", ".", "errors", ".", "length", ">", "0", ")", "{", "throw", "new", "error", ".", "ConfigurationError", "(", "new", "Error", "(", "result", ".", "errors", "[", "0", "]", ".", "stack", ")", ")", ";", "}", "// Insert default values", "var", "defaults", "=", "jsonSchemaDefaults", "(", "schema", ")", ";", "return", "mergeDefaults", "(", "bookJson", ",", "defaults", ")", ";", "}" ]

[ "Validate", "a", "book", ".", "json", "content", "And", "return", "a", "mix", "with", "the", "default", "value" ]

[ "function", "locateRootFolder", "(", ")", "{", "var", "firstDefaultPlugin", "=", "DEFAULT_PLUGINS", ".", "first", "(", ")", ";", "var", "pluginPath", "=", "resolve", ".", "sync", "(", "firstDefaultPlugin", ".", "getNpmID", "(", ")", "+", "'/package.json'", ",", "{", "basedir", ":", "__dirname", "}", ")", ";", "var", "nodeModules", "=", "path", ".", "resolve", "(", "pluginPath", ",", "'../../..'", ")", ";", "return", "nodeModules", ";", "}" ]

[ "Resolve", "the", "root", "folder", "containing", "for", "node_modules", "since", "gitbook", "can", "be", "used", "as", "a", "library", "and", "dependency", "can", "be", "flattened", "." ]

[ "function", "generateBook", "(", "generator", ",", "book", ",", "options", ")", "{", "options", "=", "generator", ".", "Options", "(", "options", ")", ";", "var", "state", "=", "generator", ".", "State", "?", "generator", ".", "State", "(", "{", "}", ")", ":", "Immutable", ".", "Map", "(", ")", ";", "var", "start", "=", "Date", ".", "now", "(", ")", ";", "return", "Promise", "(", "new", "Output", "(", "{", "book", ":", "book", ",", "options", ":", "options", ",", "state", ":", "state", ",", "generator", ":", "generator", ".", "name", "}", ")", ")", "// Cleanup output folder", ".", "then", "(", "function", "(", "output", ")", "{", "var", "logger", "=", "output", ".", "getLogger", "(", ")", ";", "var", "rootFolder", "=", "output", ".", "getRoot", "(", ")", ";", "logger", ".", "debug", ".", "ln", "(", "'cleanup folder \"'", "+", "rootFolder", "+", "'\"'", ")", ";", "return", "fs", ".", "ensureFolder", "(", "rootFolder", ")", ".", "thenResolve", "(", "output", ")", ";", "}", ")", ".", "then", "(", "processOutput", ".", "bind", "(", "null", ",", "generator", ")", ")", "// Log duration and end message", ".", "then", "(", "function", "(", "output", ")", "{", "var", "logger", "=", "output", ".", "getLogger", "(", ")", ";", "var", "end", "=", "Date", ".", "now", "(", ")", ";", "var", "duration", "=", "(", "end", "-", "start", ")", "/", "1000", ";", "logger", ".", "info", ".", "ok", "(", "'generation finished with success in '", "+", "duration", ".", "toFixed", "(", "1", ")", "+", "'s !'", ")", ";", "return", "output", ";", "}", ")", ";", "}" ]

[ "Generate", "a", "book", "using", "a", "generator", "." ]

[ "function", "encodeConfig", "(", "output", ",", "config", ")", "{", "var", "result", "=", "{", "values", ":", "config", ".", "getValues", "(", ")", ".", "toJS", "(", ")", ",", "get", ":", "function", "(", "key", ",", "defaultValue", ")", "{", "return", "objectPath", ".", "get", "(", "result", ".", "values", ",", "key", ",", "defaultValue", ")", ";", "}", ",", "set", ":", "function", "(", "key", ",", "value", ")", "{", "return", "objectPath", ".", "set", "(", "result", ".", "values", ",", "key", ",", "value", ")", ";", "}", "}", ";", "deprecate", ".", "field", "(", "output", ",", "'config.options'", ",", "result", ",", "'options'", ",", "result", ".", "values", ",", "'\"config.options\" property is deprecated, use \"config.get(key)\" instead'", ")", ";", "deprecate", ".", "field", "(", "output", ",", "'config.options.generator'", ",", "result", ".", "values", ",", "'generator'", ",", "output", ".", "getGenerator", "(", ")", ",", "'\"options.generator\" property is deprecated, use \"output.name\" instead'", ")", ";", "deprecate", ".", "field", "(", "output", ",", "'config.options.generator'", ",", "result", ".", "values", ",", "'output'", ",", "output", ".", "getRoot", "(", ")", ",", "'\"options.output\" property is deprecated, use \"output.root()\" instead'", ")", ";", "return", "result", ";", "}" ]

[ "Encode", "a", "config", "object", "into", "a", "JS", "config", "api" ]

[ "function", "getPluginConfig", "(", "config", ",", "pluginName", ")", "{", "var", "pluginsConfig", "=", "config", ".", "getValues", "(", ")", ".", "get", "(", "'pluginsConfig'", ")", ";", "if", "(", "pluginsConfig", "===", "undefined", ")", "{", "return", "{", "}", ";", "}", "var", "pluginConf", "=", "pluginsConfig", ".", "get", "(", "pluginName", ")", ";", "if", "(", "pluginConf", "===", "undefined", ")", "{", "return", "{", "}", ";", "}", "else", "{", "return", "pluginConf", ".", "toJS", "(", ")", ";", "}", "}" ]

[ "Return", "the", "configuration", "for", "a", "plugin" ]

[ "function", "encodeLanguages", "(", "languages", ")", "{", "var", "file", "=", "languages", ".", "getFile", "(", ")", ";", "var", "list", "=", "languages", ".", "getList", "(", ")", ";", "return", "{", "file", ":", "encodeFile", "(", "file", ")", ",", "list", ":", "list", ".", "valueSeq", "(", ")", ".", "map", "(", "function", "(", "lang", ")", "{", "return", "{", "id", ":", "lang", ".", "getID", "(", ")", ",", "title", ":", "lang", ".", "getTitle", "(", ")", "}", ";", "}", ")", ".", "toJS", "(", ")", "}", ";", "}" ]

[ "Encode", "a", "languages", "listing", "to", "JSON" ]

[ "function", "createFromDependency", "(", "pluginName", ")", "{", "var", "npmID", "=", "PluginDependency", ".", "nameToNpmID", "(", "pluginName", ")", ";", "var", "version", "=", "pkg", ".", "dependencies", "[", "npmID", "]", ";", "return", "PluginDependency", ".", "create", "(", "pluginName", ",", "version", ")", ";", "}" ]

[ "Create", "a", "PluginDependency", "from", "a", "dependency", "of", "gitbook" ]

[ "function", "parseFile", "(", "fs", ",", "file", ",", "type", ")", "{", "var", "filepath", "=", "file", ".", "getPath", "(", ")", ";", "var", "parser", "=", "file", ".", "getParser", "(", ")", ";", "if", "(", "!", "parser", ")", "{", "return", "Promise", ".", "reject", "(", "error", ".", "FileNotParsableError", "(", "{", "filename", ":", "filepath", "}", ")", ")", ";", "}", "return", "fs", ".", "readAsString", "(", "filepath", ")", ".", "then", "(", "function", "(", "content", ")", "{", "if", "(", "type", "===", "'readme'", ")", "{", "return", "parser", ".", "parseReadme", "(", "content", ")", ";", "}", "else", "if", "(", "type", "===", "'glossary'", ")", "{", "return", "parser", ".", "parseGlossary", "(", "content", ")", ";", "}", "else", "if", "(", "type", "===", "'summary'", ")", "{", "return", "parser", ".", "parseSummary", "(", "content", ")", ";", "}", "else", "if", "(", "type", "===", "'langs'", ")", "{", "return", "parser", ".", "parseLanguages", "(", "content", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "'Parsing invalid type \"'", "+", "type", "+", "'\"'", ")", ";", "}", "}", ")", ".", "then", "(", "function", "(", "result", ")", "{", "return", "[", "file", ",", "result", "]", ";", "}", ")", ";", "}" ]

[ "Parse", "a", "ParsableFile", "using", "a", "specific", "method" ]

[ "function", "listFilters", "(", "plugins", ")", "{", "return", "plugins", ".", "reverse", "(", ")", ".", "reduce", "(", "function", "(", "result", ",", "plugin", ")", "{", "return", "result", ".", "merge", "(", "plugin", ".", "getFilters", "(", ")", ")", ";", "}", ",", "Immutable", ".", "Map", "(", ")", ")", ";", "}" ]

[ "List", "filters", "from", "a", "list", "of", "plugins" ]

[ "function", "preparePlugins", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "return", "Promise", "(", ")", "// Only load plugins for main book", ".", "then", "(", "function", "(", ")", "{", "if", "(", "book", ".", "isLanguageBook", "(", ")", ")", "{", "return", "output", ".", "getPlugins", "(", ")", ";", "}", "else", "{", "return", "Plugins", ".", "loadForBook", "(", "book", ")", ";", "}", "}", ")", "// Update book's configuration using the plugins", ".", "then", "(", "function", "(", "plugins", ")", "{", "return", "Plugins", ".", "validateConfig", "(", "book", ",", "plugins", ")", ".", "then", "(", "function", "(", "newBook", ")", "{", "return", "output", ".", "merge", "(", "{", "book", ":", "newBook", ",", "plugins", ":", "plugins", "}", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Load", "and", "setup", "plugins" ]

[ "function", "encodeSummary", "(", "summary", ")", "{", "var", "file", "=", "summary", ".", "getFile", "(", ")", ";", "var", "parts", "=", "summary", ".", "getParts", "(", ")", ";", "return", "{", "file", ":", "encodeFile", "(", "file", ")", ",", "parts", ":", "parts", ".", "map", "(", "encodeSummaryPart", ")", ".", "toJS", "(", ")", "}", ";", "}" ]

[ "Encode", "a", "summary", "to", "JSON" ]

[ "function", "indexArticleLevels", "(", "article", ",", "baseLevel", ")", "{", "baseLevel", "=", "baseLevel", "||", "article", ".", "getLevel", "(", ")", ";", "var", "articles", "=", "article", ".", "getArticles", "(", ")", ";", "articles", "=", "articles", ".", "map", "(", "function", "(", "inner", ",", "i", ")", "{", "return", "indexArticleLevels", "(", "inner", ",", "baseLevel", "+", "'.'", "+", "(", "i", "+", "1", ")", ")", ";", "}", ")", ";", "return", "article", ".", "merge", "(", "{", "level", ":", "baseLevel", ",", "articles", ":", "articles", "}", ")", ";", "}" ]

[ "Index", "levels", "in", "an", "article", "tree" ]

[ "function", "callHook", "(", "name", ",", "getArgument", ",", "handleResult", ",", "output", ")", "{", "getArgument", "=", "getArgument", "||", "defaultGetArgument", ";", "handleResult", "=", "handleResult", "||", "defaultHandleResult", ";", "var", "logger", "=", "output", ".", "getLogger", "(", ")", ";", "var", "plugins", "=", "output", ".", "getPlugins", "(", ")", ";", "logger", ".", "debug", ".", "ln", "(", "'calling hook \"'", "+", "name", "+", "'\"'", ")", ";", "// Create the JS context for plugins", "var", "context", "=", "Api", ".", "encodeGlobal", "(", "output", ")", ";", "return", "timing", ".", "measure", "(", "'call.hook.'", "+", "name", ",", "// Get the arguments", "Promise", "(", "getArgument", "(", "output", ")", ")", "// Call the hooks in serie", ".", "then", "(", "function", "(", "arg", ")", "{", "return", "Promise", ".", "reduce", "(", "plugins", ",", "function", "(", "prev", ",", "plugin", ")", "{", "var", "hook", "=", "plugin", ".", "getHook", "(", "name", ")", ";", "if", "(", "!", "hook", ")", "{", "return", "prev", ";", "}", "return", "hook", ".", "call", "(", "context", ",", "prev", ")", ";", "}", ",", "arg", ")", ";", "}", ")", "// Handle final result", ".", "then", "(", "function", "(", "result", ")", "{", "output", "=", "Api", ".", "decodeGlobal", "(", "output", ",", "context", ")", ";", "return", "handleResult", "(", "output", ",", "result", ")", ";", "}", ")", ")", ";", "}" ]

[ "Call", "a", "global", "hook", "for", "an", "output" ]

[ "function", "redirect", "(", ")", "{", "var", "resultURL", "=", "urlTransform", "(", "req", ".", "url", ",", "function", "(", "parsed", ")", "{", "parsed", ".", "pathname", "+=", "'/'", ";", "return", "parsed", ";", "}", ")", ";", "res", ".", "statusCode", "=", "301", ";", "res", ".", "setHeader", "(", "'Location'", ",", "resultURL", ")", ";", "res", ".", "end", "(", "'Redirecting to '", "+", "resultURL", ")", ";", "}" ]

[ "Redirect", "to", "directory", "s", "index", ".", "html" ]

[ "function", "editArticleInList", "(", "articles", ",", "level", ",", "newArticle", ")", "{", "return", "articles", ".", "map", "(", "function", "(", "article", ")", "{", "var", "articleLevel", "=", "article", ".", "getLevel", "(", ")", ";", "if", "(", "articleLevel", "===", "level", ")", "{", "// it is the article to edit", "return", "article", ".", "merge", "(", "newArticle", ")", ";", "}", "else", "if", "(", "level", ".", "indexOf", "(", "articleLevel", ")", "===", "0", ")", "{", "// it is a parent", "var", "articles", "=", "editArticleInList", "(", "article", ".", "getArticles", "(", ")", ",", "level", ",", "newArticle", ")", ";", "return", "article", ".", "set", "(", "'articles'", ",", "articles", ")", ";", "}", "else", "{", "// This is not the article you are looking for", "return", "article", ";", "}", "}", ")", ";", "}" ]

[ "Edit", "a", "list", "of", "articles" ]

[ "function", "editArticleInPart", "(", "part", ",", "level", ",", "newArticle", ")", "{", "var", "articles", "=", "part", ".", "getArticles", "(", ")", ";", "articles", "=", "editArticleInList", "(", "articles", ",", "level", ",", "newArticle", ")", ";", "return", "part", ".", "set", "(", "'articles'", ",", "articles", ")", ";", "}" ]

[ "Edit", "an", "article", "in", "a", "part" ]

[ "function", "mergeAtLevel", "(", "summary", ",", "level", ",", "newValue", ")", "{", "var", "levelParts", "=", "level", ".", "split", "(", "'.'", ")", ";", "var", "partIndex", "=", "Number", "(", "levelParts", "[", "0", "]", ")", "-", "1", ";", "var", "parts", "=", "summary", ".", "getParts", "(", ")", ";", "var", "part", "=", "parts", ".", "get", "(", "partIndex", ")", ";", "if", "(", "!", "part", ")", "{", "return", "summary", ";", "}", "var", "isEditingPart", "=", "levelParts", ".", "length", "<", "2", ";", "if", "(", "isEditingPart", ")", "{", "part", "=", "part", ".", "merge", "(", "newValue", ")", ";", "}", "else", "{", "part", "=", "editArticleInPart", "(", "part", ",", "level", ",", "newValue", ")", ";", "}", "parts", "=", "parts", ".", "set", "(", "partIndex", ",", "part", ")", ";", "return", "summary", ".", "set", "(", "'parts'", ",", "parts", ")", ";", "}" ]

[ "Edit", "an", "article", "or", "a", "part", "in", "a", "summary", ".", "Does", "a", "shallow", "merge", "." ]

[ "function", "isExternal", "(", "href", ")", "{", "try", "{", "return", "Boolean", "(", "url", ".", "parse", "(", "href", ")", ".", "protocol", ")", "&&", "!", "isDataURI", "(", "href", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "false", ";", "}", "}" ]

[ "Is", "the", "url", "an", "external", "url" ]

[ "function", "isAnchor", "(", "href", ")", "{", "try", "{", "var", "parsed", "=", "url", ".", "parse", "(", "href", ")", ";", "return", "!", "!", "(", "!", "parsed", ".", "protocol", "&&", "!", "parsed", ".", "path", "&&", "parsed", ".", "hash", ")", ";", "}", "catch", "(", "err", ")", "{", "return", "false", ";", "}", "}" ]

[ "Return", "true", "if", "the", "link", "is", "an", "achor" ]

[ "function", "toAbsolute", "(", "_href", ",", "dir", ",", "outdir", ")", "{", "if", "(", "isExternal", "(", "_href", ")", "||", "isDataURI", "(", "_href", ")", ")", "{", "return", "_href", ";", "}", "outdir", "=", "outdir", "==", "undefined", "?", "dir", ":", "outdir", ";", "_href", "=", "normalize", "(", "_href", ")", ";", "dir", "=", "normalize", "(", "dir", ")", ";", "outdir", "=", "normalize", "(", "outdir", ")", ";", "// Path \"_href\" inside the base folder", "var", "hrefInRoot", "=", "normalize", "(", "path", ".", "join", "(", "dir", ",", "_href", ")", ")", ";", "if", "(", "_href", "[", "0", "]", "==", "'/'", ")", "{", "hrefInRoot", "=", "normalize", "(", "_href", ".", "slice", "(", "1", ")", ")", ";", "}", "// Make it relative to output", "_href", "=", "path", ".", "relative", "(", "outdir", ",", "hrefInRoot", ")", ";", "// Normalize windows paths", "_href", "=", "normalize", "(", "_href", ")", ";", "return", "_href", ";", "}" ]

[ "Convert", "a", "relative", "path", "to", "absolute" ]

[ "function", "parsePageFromString", "(", "page", ",", "content", ")", "{", "// Parse page YAML", "var", "parsed", "=", "fm", "(", "content", ")", ";", "return", "page", ".", "merge", "(", "{", "content", ":", "parsed", ".", "body", ",", "attributes", ":", "Immutable", ".", "fromJS", "(", "parsed", ".", "attributes", ")", ",", "dir", ":", "direction", "(", "parsed", ".", "body", ")", "}", ")", ";", "}" ]

[ "Parse", "a", "page", "its", "content", "and", "the", "YAMl", "header" ]

[ "function", "onFinish", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "outputRoot", "=", "output", ".", "getRoot", "(", ")", ";", "if", "(", "!", "book", ".", "isMultilingual", "(", ")", ")", "{", "return", "Promise", "(", "output", ")", ";", "}", "// Get main language", "var", "languages", "=", "book", ".", "getLanguages", "(", ")", ";", "var", "mainLanguage", "=", "languages", ".", "getDefaultLanguage", "(", ")", ";", "// Read the main JSON", "return", "fs", ".", "readFile", "(", "path", ".", "resolve", "(", "outputRoot", ",", "mainLanguage", ".", "getID", "(", ")", ",", "'README.json'", ")", ",", "'utf8'", ")", "// Extend the JSON", ".", "then", "(", "function", "(", "content", ")", "{", "var", "json", "=", "JSON", ".", "parse", "(", "content", ")", ";", "json", ".", "languages", "=", "JSONUtils", ".", "encodeLanguages", "(", "languages", ")", ";", "return", "json", ";", "}", ")", ".", "then", "(", "function", "(", "json", ")", "{", "return", "fs", ".", "writeFile", "(", "path", ".", "resolve", "(", "outputRoot", ",", "'README.json'", ")", ",", "JSON", ".", "stringify", "(", "json", ",", "null", ",", "4", ")", ")", ";", "}", ")", ".", "thenResolve", "(", "output", ")", ";", "}" ]

[ "Finish", "the", "generation" ]

[ "function", "removeArticle", "(", "summary", ",", "level", ")", "{", "// Coerce to level", "level", "=", "is", ".", "string", "(", "level", ")", "?", "level", ":", "level", ".", "getLevel", "(", ")", ";", "var", "parent", "=", "summary", ".", "getParent", "(", "level", ")", ";", "var", "articles", "=", "parent", ".", "getArticles", "(", ")", ";", "// Find the index to remove", "var", "index", "=", "articles", ".", "findIndex", "(", "function", "(", "art", ")", "{", "return", "art", ".", "getLevel", "(", ")", "===", "level", ";", "}", ")", ";", "if", "(", "index", "===", "-", "1", ")", "{", "return", "summary", ";", "}", "// Remove from children", "articles", "=", "articles", ".", "remove", "(", "index", ")", ";", "parent", "=", "parent", ".", "set", "(", "'articles'", ",", "articles", ")", ";", "// Reindex the level from here", "parent", "=", "indexArticleLevels", "(", "parent", ")", ";", "return", "mergeAtLevel", "(", "summary", ",", "parent", ".", "getLevel", "(", ")", ",", "parent", ")", ";", "}" ]

[ "Remove", "an", "article", "from", "a", "level", "." ]

[ "function", "editPartTitle", "(", "summary", ",", "index", ",", "newTitle", ")", "{", "var", "parts", "=", "summary", ".", "getParts", "(", ")", ";", "var", "part", "=", "parts", ".", "get", "(", "index", ")", ";", "if", "(", "!", "part", ")", "{", "return", "summary", ";", "}", "part", "=", "part", ".", "set", "(", "'title'", ",", "newTitle", ")", ";", "parts", "=", "parts", ".", "set", "(", "index", ",", "part", ")", ";", "return", "summary", ".", "set", "(", "'parts'", ",", "parts", ")", ";", "}" ]

[ "Edit", "title", "of", "a", "part", "in", "the", "summary" ]

[ "function", "preparePages", "(", "output", ")", "{", "var", "book", "=", "output", ".", "getBook", "(", ")", ";", "var", "logger", "=", "book", ".", "getLogger", "(", ")", ";", "if", "(", "book", ".", "isMultilingual", "(", ")", ")", "{", "return", "Promise", "(", "output", ")", ";", "}", "return", "Parse", ".", "parsePagesList", "(", "book", ")", ".", "then", "(", "function", "(", "pages", ")", "{", "logger", ".", "info", ".", "ln", "(", "'found'", ",", "pages", ".", "size", ",", "'pages'", ")", ";", "return", "output", ".", "set", "(", "'pages'", ",", "pages", ")", ";", "}", ")", ";", "}" ]

[ "List", "and", "prepare", "all", "pages" ]

[ "function", "svgToPng", "(", "rootFolder", ",", "currentFile", ",", "$", ")", "{", "var", "currentDirectory", "=", "path", ".", "dirname", "(", "currentFile", ")", ";", "return", "editHTMLElement", "(", "$", ",", "'img'", ",", "function", "(", "$img", ")", "{", "var", "src", "=", "$img", ".", "attr", "(", "'src'", ")", ";", "if", "(", "path", ".", "extname", "(", "src", ")", "!==", "'.svg'", ")", "{", "return", ";", "}", "// Calcul absolute path for this", "src", "=", "LocationUtils", ".", "toAbsolute", "(", "src", ",", "currentDirectory", ",", "'.'", ")", ";", "// We avoid generating twice the same PNG", "var", "hash", "=", "crc", ".", "crc32", "(", "src", ")", ".", "toString", "(", "16", ")", ";", "var", "fileName", "=", "hash", "+", "'.png'", ";", "// Input file path", "var", "inputPath", "=", "path", ".", "join", "(", "rootFolder", ",", "src", ")", ";", "// Result file path", "var", "filePath", "=", "path", ".", "join", "(", "rootFolder", ",", "fileName", ")", ";", "return", "fs", ".", "assertFile", "(", "filePath", ",", "function", "(", ")", "{", "return", "imagesUtil", ".", "convertSVGToPNG", "(", "inputPath", ",", "filePath", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "// Convert filename to a relative filename", "fileName", "=", "LocationUtils", ".", "relative", "(", "currentDirectory", ",", "fileName", ")", ";", "// Replace src", "$img", ".", "attr", "(", "'src'", ",", "fileName", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Convert", "all", "SVG", "images", "to", "PNG" ]

[ "function", "installPlugins", "(", "book", ")", "{", "var", "logger", "=", "book", ".", "getLogger", "(", ")", ";", "var", "config", "=", "book", ".", "getConfig", "(", ")", ";", "var", "plugins", "=", "config", ".", "getPluginDependencies", "(", ")", ";", "// Remove default plugins", "// (only if version is same as installed)", "plugins", "=", "plugins", ".", "filterNot", "(", "function", "(", "plugin", ")", "{", "var", "dependency", "=", "DEFAULT_PLUGINS", ".", "find", "(", "function", "(", "dep", ")", "{", "return", "dep", ".", "getName", "(", ")", "===", "plugin", ".", "getName", "(", ")", ";", "}", ")", ";", "return", "(", "// Disabled plugin", "!", "plugin", ".", "isEnabled", "(", ")", "||", "// Or default one installed in GitBook itself", "(", "dependency", "&&", "plugin", ".", "getVersion", "(", ")", "===", "dependency", ".", "getVersion", "(", ")", ")", ")", ";", "}", ")", ";", "if", "(", "plugins", ".", "size", "==", "0", ")", "{", "logger", ".", "info", ".", "ln", "(", "'nothing to install!'", ")", ";", "return", "Promise", "(", ")", ";", "}", "logger", ".", "info", ".", "ln", "(", "'installing'", ",", "plugins", ".", "size", ",", "'plugins using npm@'", "+", "npmi", ".", "NPM_VERSION", ")", ";", "return", "Promise", ".", "forEach", "(", "plugins", ",", "function", "(", "plugin", ")", "{", "return", "installPlugin", "(", "book", ",", "plugin", ")", ";", "}", ")", ".", "thenResolve", "(", "plugins", ".", "size", ")", ";", "}" ]

[ "Install", "plugin", "requirements", "for", "a", "book" ]

[ "function", "removePlugin", "(", "config", ",", "pluginName", ")", "{", "var", "deps", "=", "config", ".", "getPluginDependencies", "(", ")", ";", "// For default plugin, we have to disable it instead of removing from the list", "if", "(", "isDefaultPlugin", "(", "pluginName", ")", ")", "{", "return", "togglePlugin", "(", "config", ",", "pluginName", ",", "false", ")", ";", "}", "// Remove the dependency from the list", "deps", "=", "deps", ".", "filterNot", "(", "function", "(", "dep", ")", "{", "return", "dep", ".", "getName", "(", ")", "===", "pluginName", ";", "}", ")", ";", "return", "config", ".", "setPluginDependencies", "(", "deps", ")", ";", "}" ]

[ "Remove", "a", "plugin", "from", "a", "book", "s", "configuration" ]

[ "function", "decodePage", "(", "output", ",", "page", ",", "result", ")", "{", "var", "originalContent", "=", "page", ".", "getContent", "(", ")", ";", "// No returned value", "// Existing content will be used", "if", "(", "!", "result", ")", "{", "return", "page", ";", "}", "deprecate", ".", "disable", "(", "'page.sections'", ")", ";", "// GitBook 3", "// Use returned page.content if different from original content", "if", "(", "result", ".", "content", "!=", "originalContent", ")", "{", "page", "=", "page", ".", "set", "(", "'content'", ",", "result", ".", "content", ")", ";", "}", "// GitBook 2 compatibility", "// Finally, use page.sections", "else", "if", "(", "result", ".", "sections", ")", "{", "page", "=", "page", ".", "set", "(", "'content'", ",", "result", ".", "sections", ".", "map", "(", "function", "(", "section", ")", "{", "return", "section", ".", "content", ";", "}", ")", ".", "join", "(", "'\\n'", ")", ")", ";", "}", "deprecate", ".", "enable", "(", "'page.sections'", ")", ";", "return", "page", ";", "}" ]

[ "Decode", "changes", "from", "a", "JS", "API", "to", "a", "page", "object", ".", "Only", "the", "content", "can", "be", "edited", "by", "plugin", "s", "hooks", "." ]

[ "function", "spawnCmd", "(", "command", ",", "args", ",", "options", ")", "{", "var", "d", "=", "Promise", ".", "defer", "(", ")", ";", "var", "child", "=", "spawn", "(", "command", ",", "args", ",", "options", ")", ";", "child", ".", "on", "(", "'error'", ",", "function", "(", "error", ")", "{", "return", "d", ".", "reject", "(", "error", ")", ";", "}", ")", ";", "child", ".", "stdout", ".", "on", "(", "'data'", ",", "function", "(", "data", ")", "{", "d", ".", "notify", "(", "data", ")", ";", "}", ")", ";", "child", ".", "stderr", ".", "on", "(", "'data'", ",", "function", "(", "data", ")", "{", "d", ".", "notify", "(", "data", ")", ";", "}", ")", ";", "child", ".", "on", "(", "'close'", ",", "function", "(", "code", ")", "{", "if", "(", "code", "===", "0", ")", "{", "d", ".", "resolve", "(", ")", ";", "}", "else", "{", "d", ".", "reject", "(", "new", "Error", "(", "'Error with command \"'", "+", "command", "+", "'\"'", ")", ")", ";", "}", "}", ")", ";", "return", "d", ".", "promise", ";", "}" ]

[ "Spawn", "an", "executable" ]

[ "function", "escapeShellArg", "(", "value", ")", "{", "if", "(", "is", ".", "number", "(", "value", ")", ")", "{", "return", "value", ";", "}", "value", "=", "String", "(", "value", ")", ";", "value", "=", "value", ".", "replace", "(", "/", "\"", "/", "g", ",", "'\\\\\"'", ")", ";", "return", "'\"'", "+", "value", "+", "'\"'", ";", "}" ]

[ "Transform", "an", "option", "object", "to", "a", "command", "line", "string" ]

[ "function", "optionsToShellArgs", "(", "options", ")", "{", "var", "result", "=", "[", "]", ";", "for", "(", "var", "key", "in", "options", ")", "{", "var", "value", "=", "options", "[", "key", "]", ";", "if", "(", "value", "===", "null", "||", "value", "===", "undefined", "||", "value", "===", "false", ")", "{", "continue", ";", "}", "if", "(", "is", ".", "bool", "(", "value", ")", ")", "{", "result", ".", "push", "(", "key", ")", ";", "}", "else", "{", "result", ".", "push", "(", "key", "+", "'='", "+", "escapeShellArg", "(", "value", ")", ")", ";", "}", "}", "return", "result", ".", "join", "(", "' '", ")", ";", "}" ]

[ "Transform", "a", "map", "of", "options", "into", "a", "command", "line", "arguments", "string" ]

[ "function", "onInit", "(", "output", ")", "{", "return", "Promise", "(", "output", ")", ".", "then", "(", "prepareI18n", ")", ".", "then", "(", "prepareResources", ")", ".", "then", "(", "copyPluginAssets", ")", ";", "}" ]

[ "Initialize", "the", "generator" ]

[ "function", "callPageHook", "(", "name", ",", "output", ",", "page", ")", "{", "return", "callHook", "(", "name", ",", "function", "(", "out", ")", "{", "return", "Api", ".", "encodePage", "(", "out", ",", "page", ")", ";", "}", ",", "function", "(", "out", ",", "result", ")", "{", "return", "Api", ".", "decodePage", "(", "out", ",", "page", ",", "result", ")", ";", "}", ",", "output", ")", ";", "}" ]

[ "Call", "a", "hook", "for", "a", "specific", "page" ]

[ "function", "reducedObject", "(", "defaultVersion", ",", "currentVersion", ")", "{", "if", "(", "defaultVersion", "===", "undefined", ")", "{", "return", "currentVersion", ";", "}", "return", "currentVersion", ".", "reduce", "(", "function", "(", "result", ",", "value", ",", "key", ")", "{", "var", "defaultValue", "=", "defaultVersion", ".", "get", "(", "key", ")", ";", "if", "(", "Immutable", ".", "Map", ".", "isMap", "(", "value", ")", ")", "{", "var", "diffs", "=", "reducedObject", "(", "defaultValue", ",", "value", ")", ";", "if", "(", "diffs", ".", "size", ">", "0", ")", "{", "return", "result", ".", "set", "(", "key", ",", "diffs", ")", ";", "}", "}", "if", "(", "Immutable", ".", "is", "(", "defaultValue", ",", "value", ")", ")", "{", "return", "result", ";", "}", "return", "result", ".", "set", "(", "key", ",", "value", ")", ";", "}", ",", "Immutable", ".", "Map", "(", ")", ")", ";", "}" ]

[ "Reduce", "the", "difference", "between", "a", "map", "and", "its", "default", "version" ]

[ "function", "ensureRelative", "(", "outputDir", ",", "p", ")", "{", "if", "(", "path", ".", "isAbsolute", "(", "p", ")", ")", "{", "return", "path", ".", "relative", "(", "outputDir", ",", "p", ")", ";", "}", "else", "{", "return", "p", ";", "}", "}" ]

[ "ensure", "the", "filename", "passed", "to", "html", "-", "webpack", "-", "plugin", "is", "a", "relative", "path", "because", "it", "cannot", "correctly", "handle", "absolute", "paths" ]

[ "function", "get", "(", "arr", ",", "n", ")", "{", "return", "n", ">=", "0", "?", "arr", "[", "n", "]", ":", "arr", "[", "arr", ".", "length", "+", "n", "]", ";", "}" ]

[ "Get", "n", "item", "of", "array", ".", "Supports", "negative", "n", "where", "-", "1", "is", "last", "element", "in", "array", "." ]

[ "function", "selectLanguage", "(", "options", ",", "lang", ")", "{", "let", "langToUse", "=", "lang", ";", "if", "(", "langToUse", "===", "''", "&&", "options", ".", "defaultLanguageForUnspecified", "!==", "undefined", ")", "{", "langToUse", "=", "options", ".", "defaultLanguageForUnspecified", ";", "}", "let", "prismLang", "=", "loadPrismLang", "(", "langToUse", ")", ";", "if", "(", "prismLang", "===", "undefined", "&&", "options", ".", "defaultLanguageForUnknown", "!==", "undefined", ")", "{", "langToUse", "=", "options", ".", "defaultLanguageForUnknown", ";", "prismLang", "=", "loadPrismLang", "(", "langToUse", ")", ";", "}", "return", "[", "langToUse", ",", "prismLang", "]", ";", "}" ]

[ "Select", "the", "language", "to", "use", "for", "highlighting", "based", "on", "the", "provided", "options", "and", "the", "specified", "language", "." ]

[ "function", "checkLanguageOption", "(", "options", ",", "optionName", ")", "{", "const", "language", "=", "options", "[", "optionName", "]", ";", "if", "(", "language", "!==", "undefined", "&&", "loadPrismLang", "(", "language", ")", "===", "undefined", ")", "{", "throw", "new", "Error", "(", "`", "${", "optionName", "}", "${", "language", "}", "`", ")", ";", "}", "}" ]

[ "Checks", "whether", "an", "option", "represents", "a", "valid", "Prism", "language" ]

[ "function", "applyClass", "(", "token", ")", "{", "// init attributes", "token", ".", "attrs", "=", "token", ".", "attrs", "||", "[", "]", ";", "// get index of class attribute", "let", "keys", "=", "token", ".", "attrs", ".", "map", "(", "arr", "=>", "arr", "[", "0", "]", ")", ";", "let", "idx", "=", "keys", ".", "indexOf", "(", "'class'", ")", ";", "if", "(", "idx", "===", "-", "1", ")", "{", "// Add class attribute if not defined", "token", ".", "attrs", ".", "push", "(", "[", "'class'", ",", "className", "]", ")", ";", "}", "else", "{", "// Get the current class list to append.", "// Watch out for duplicates", "let", "classStr", "=", "token", ".", "attrs", "[", "idx", "]", "[", "1", "]", "||", "''", ";", "let", "classList", "=", "classStr", ".", "split", "(", "' '", ")", ";", "// Add the class if we don't already have it", "if", "(", "classList", ".", "indexOf", "(", "className", ")", "===", "-", "1", ")", "{", "token", ".", "attrs", "[", "idx", "]", "[", "1", "]", "=", "classStr", "+=", "' '", "+", "className", ";", "}", "}", "}" ]

[ "Adds", "class", "to", "token" ]

[ "function", "attachSearch", "(", "ref", ")", "{", "if", "(", "ref", "&&", "window", ")", "import", "(", "'docsearch.js'", ")", ".", "then", "(", "(", "{", "default", ":", "docsearch", "}", ")", "=>", "{", "docsearch", "(", "{", "apiKey", ":", "'00f98b765b687b91399288e7c4c68ce1'", ",", "indexName", ":", "'react_bootstrap_v4'", ",", "inputSelector", ":", "`", "${", "ref", ".", "id", "}", "`", ",", "debug", ":", "process", ".", "env", ".", "NODE_ENV", "!==", "'production'", ",", "// Set debug to true if you want to inspect the dropdown", "}", ")", ";", "}", ")", ";", "}" ]

[ "We", "need", "to", "configure", "this" ]

[ "function", "map", "(", "children", ",", "func", ")", "{", "let", "index", "=", "0", ";", "return", "React", ".", "Children", ".", "map", "(", "children", ",", "child", "=>", "React", ".", "isValidElement", "(", "child", ")", "?", "func", "(", "child", ",", "index", "++", ")", ":", "child", ",", ")", ";", "}" ]

[ "Iterates", "through", "children", "that", "are", "typically", "specified", "as", "props", ".", "children", "but", "only", "maps", "over", "children", "that", "are", "valid", "elements", "." ]

[ "function", "forEach", "(", "children", ",", "func", ")", "{", "let", "index", "=", "0", ";", "React", ".", "Children", ".", "forEach", "(", "children", ",", "child", "=>", "{", "if", "(", "React", ".", "isValidElement", "(", "child", ")", ")", "func", "(", "child", ",", "index", "++", ")", ";", "}", ")", ";", "}" ]

[ "Iterates", "through", "children", "that", "are", "valid", "elements", "." ]

[ "function", "convolve", "(", "context", ",", "kernel", ")", "{", "const", "canvas", "=", "context", ".", "canvas", ";", "const", "width", "=", "canvas", ".", "width", ";", "const", "height", "=", "canvas", ".", "height", ";", "const", "size", "=", "Math", ".", "sqrt", "(", "kernel", ".", "length", ")", ";", "const", "half", "=", "Math", ".", "floor", "(", "size", "/", "2", ")", ";", "const", "inputData", "=", "context", ".", "getImageData", "(", "0", ",", "0", ",", "width", ",", "height", ")", ".", "data", ";", "const", "output", "=", "context", ".", "createImageData", "(", "width", ",", "height", ")", ";", "const", "outputData", "=", "output", ".", "data", ";", "for", "(", "let", "pixelY", "=", "0", ";", "pixelY", "<", "height", ";", "++", "pixelY", ")", "{", "const", "pixelsAbove", "=", "pixelY", "*", "width", ";", "for", "(", "let", "pixelX", "=", "0", ";", "pixelX", "<", "width", ";", "++", "pixelX", ")", "{", "let", "r", "=", "0", ",", "g", "=", "0", ",", "b", "=", "0", ",", "a", "=", "0", ";", "for", "(", "let", "kernelY", "=", "0", ";", "kernelY", "<", "size", ";", "++", "kernelY", ")", "{", "for", "(", "let", "kernelX", "=", "0", ";", "kernelX", "<", "size", ";", "++", "kernelX", ")", "{", "const", "weight", "=", "kernel", "[", "kernelY", "*", "size", "+", "kernelX", "]", ";", "const", "neighborY", "=", "Math", ".", "min", "(", "height", "-", "1", ",", "Math", ".", "max", "(", "0", ",", "pixelY", "+", "kernelY", "-", "half", ")", ")", ";", "const", "neighborX", "=", "Math", ".", "min", "(", "width", "-", "1", ",", "Math", ".", "max", "(", "0", ",", "pixelX", "+", "kernelX", "-", "half", ")", ")", ";", "const", "inputIndex", "=", "(", "neighborY", "*", "width", "+", "neighborX", ")", "*", "4", ";", "r", "+=", "inputData", "[", "inputIndex", "]", "*", "weight", ";", "g", "+=", "inputData", "[", "inputIndex", "+", "1", "]", "*", "weight", ";", "b", "+=", "inputData", "[", "inputIndex", "+", "2", "]", "*", "weight", ";", "a", "+=", "inputData", "[", "inputIndex", "+", "3", "]", "*", "weight", ";", "}", "}", "const", "outputIndex", "=", "(", "pixelsAbove", "+", "pixelX", ")", "*", "4", ";", "outputData", "[", "outputIndex", "]", "=", "r", ";", "outputData", "[", "outputIndex", "+", "1", "]", "=", "g", ";", "outputData", "[", "outputIndex", "+", "2", "]", "=", "b", ";", "outputData", "[", "outputIndex", "+", "3", "]", "=", "kernel", ".", "normalized", "?", "a", ":", "255", ";", "}", "}", "context", ".", "putImageData", "(", "output", ",", "0", ",", "0", ")", ";", "}" ]

[ "Apply", "a", "convolution", "kernel", "to", "canvas", ".", "This", "works", "for", "any", "size", "kernel", "but", "performance", "starts", "degrading", "above", "3", "x", "3", "." ]

[ "function", "rgb2hcl", "(", "pixel", ")", "{", "const", "red", "=", "rgb2xyz", "(", "pixel", "[", "0", "]", ")", ";", "const", "green", "=", "rgb2xyz", "(", "pixel", "[", "1", "]", ")", ";", "const", "blue", "=", "rgb2xyz", "(", "pixel", "[", "2", "]", ")", ";", "const", "x", "=", "xyz2lab", "(", "(", "0.4124564", "*", "red", "+", "0.3575761", "*", "green", "+", "0.1804375", "*", "blue", ")", "/", "Xn", ")", ";", "const", "y", "=", "xyz2lab", "(", "(", "0.2126729", "*", "red", "+", "0.7151522", "*", "green", "+", "0.0721750", "*", "blue", ")", "/", "Yn", ")", ";", "const", "z", "=", "xyz2lab", "(", "(", "0.0193339", "*", "red", "+", "0.1191920", "*", "green", "+", "0.9503041", "*", "blue", ")", "/", "Zn", ")", ";", "const", "l", "=", "116", "*", "y", "-", "16", ";", "const", "a", "=", "500", "*", "(", "x", "-", "y", ")", ";", "const", "b", "=", "200", "*", "(", "y", "-", "z", ")", ";", "const", "c", "=", "Math", ".", "sqrt", "(", "a", "*", "a", "+", "b", "*", "b", ")", ";", "let", "h", "=", "Math", ".", "atan2", "(", "b", ",", "a", ")", ";", "if", "(", "h", "<", "0", ")", "{", "h", "+=", "twoPi", ";", "}", "pixel", "[", "0", "]", "=", "h", ";", "pixel", "[", "1", "]", "=", "c", ";", "pixel", "[", "2", "]", "=", "l", ";", "return", "pixel", ";", "}" ]

[ "Convert", "an", "RGB", "pixel", "into", "an", "HCL", "pixel", "." ]

[ "function", "hcl2rgb", "(", "pixel", ")", "{", "const", "h", "=", "pixel", "[", "0", "]", ";", "const", "c", "=", "pixel", "[", "1", "]", ";", "const", "l", "=", "pixel", "[", "2", "]", ";", "const", "a", "=", "Math", ".", "cos", "(", "h", ")", "*", "c", ";", "const", "b", "=", "Math", ".", "sin", "(", "h", ")", "*", "c", ";", "let", "y", "=", "(", "l", "+", "16", ")", "/", "116", ";", "let", "x", "=", "isNaN", "(", "a", ")", "?", "y", ":", "y", "+", "a", "/", "500", ";", "let", "z", "=", "isNaN", "(", "b", ")", "?", "y", ":", "y", "-", "b", "/", "200", ";", "y", "=", "Yn", "*", "lab2xyz", "(", "y", ")", ";", "x", "=", "Xn", "*", "lab2xyz", "(", "x", ")", ";", "z", "=", "Zn", "*", "lab2xyz", "(", "z", ")", ";", "pixel", "[", "0", "]", "=", "xyz2rgb", "(", "3.2404542", "*", "x", "-", "1.5371385", "*", "y", "-", "0.4985314", "*", "z", ")", ";", "pixel", "[", "1", "]", "=", "xyz2rgb", "(", "-", "0.9692660", "*", "x", "+", "1.8760108", "*", "y", "+", "0.0415560", "*", "z", ")", ";", "pixel", "[", "2", "]", "=", "xyz2rgb", "(", "0.0556434", "*", "x", "-", "0.2040259", "*", "y", "+", "1.0572252", "*", "z", ")", ";", "return", "pixel", ";", "}" ]

[ "Convert", "an", "HCL", "pixel", "into", "an", "RGB", "pixel", "." ]

[ "function", "createWordIndex", "(", "exampleData", ")", "{", "const", "index", "=", "{", "}", ";", "const", "keys", "=", "[", "'shortdesc'", ",", "'title'", ",", "'tags'", "]", ";", "exampleData", ".", "forEach", "(", "(", "data", ",", "i", ")", "=>", "{", "keys", ".", "forEach", "(", "key", "=>", "{", "let", "text", "=", "data", "[", "key", "]", ";", "if", "(", "Array", ".", "isArray", "(", "text", ")", ")", "{", "text", "=", "text", ".", "join", "(", "' '", ")", ";", "}", "const", "words", "=", "text", "?", "text", ".", "split", "(", "/", "\\W+", "/", ")", ":", "[", "]", ";", "words", ".", "forEach", "(", "word", "=>", "{", "if", "(", "word", ")", "{", "word", "=", "word", ".", "toLowerCase", "(", ")", ";", "let", "counts", "=", "index", "[", "word", "]", ";", "if", "(", "counts", ")", "{", "if", "(", "index", "in", "counts", ")", "{", "counts", "[", "i", "]", "+=", "1", ";", "}", "else", "{", "counts", "[", "i", "]", "=", "1", ";", "}", "}", "else", "{", "counts", "=", "{", "}", ";", "counts", "[", "i", "]", "=", "1", ";", "index", "[", "word", "]", "=", "counts", ";", "}", "}", "}", ")", ";", "}", ")", ";", "}", ")", ";", "return", "index", ";", "}" ]

[ "Create", "an", "inverted", "index", "of", "keywords", "from", "examples", ".", "Property", "names", "are", "lowercased", "words", ".", "Property", "values", "are", "objects", "mapping", "example", "index", "to", "word", "count", "." ]

[ "function", "getJsSource", "(", "chunk", ",", "jsName", ")", "{", "let", "jsSource", ";", "for", "(", "let", "i", "=", "0", ",", "ii", "=", "chunk", ".", "modules", ".", "length", ";", "i", "<", "ii", ";", "++", "i", ")", "{", "const", "module", "=", "chunk", ".", "modules", "[", "i", "]", ";", "if", "(", "module", ".", "modules", ")", "{", "jsSource", "=", "getJsSource", "(", "module", ",", "jsName", ")", ";", "if", "(", "jsSource", ")", "{", "return", "jsSource", ";", "}", "}", "if", "(", "module", ".", "identifier", ".", "endsWith", "(", "jsName", ")", "&&", "module", ".", "source", ")", "{", "return", "module", ".", "source", ";", "}", "}", "}" ]

[ "Gets", "the", "source", "for", "the", "chunk", "that", "matches", "the", "jsPath" ]

[ "function", "getDependencies", "(", "jsSource", ")", "{", "const", "lines", "=", "jsSource", ".", "split", "(", "'\\n'", ")", ";", "const", "dependencies", "=", "{", "ol", ":", "pkg", ".", "version", "}", ";", "for", "(", "let", "i", "=", "0", ",", "ii", "=", "lines", ".", "length", ";", "i", "<", "ii", ";", "++", "i", ")", "{", "const", "line", "=", "lines", "[", "i", "]", ";", "const", "importMatch", "=", "line", ".", "match", "(", "importRegEx", ")", ";", "if", "(", "importMatch", ")", "{", "const", "imp", "=", "importMatch", "[", "1", "]", ";", "if", "(", "!", "imp", ".", "startsWith", "(", "'ol/'", ")", "&&", "imp", "!=", "'ol'", ")", "{", "const", "parts", "=", "imp", ".", "split", "(", "'/'", ")", ";", "let", "dep", ";", "if", "(", "imp", ".", "startsWith", "(", "'@'", ")", ")", "{", "dep", "=", "parts", ".", "slice", "(", "0", ",", "2", ")", ".", "join", "(", "'/'", ")", ";", "}", "else", "{", "dep", "=", "parts", "[", "0", "]", ";", "}", "if", "(", "dep", "in", "pkg", ".", "devDependencies", ")", "{", "dependencies", "[", "dep", "]", "=", "pkg", ".", "devDependencies", "[", "dep", "]", ";", "}", "}", "}", "}", "return", "dependencies", ";", "}" ]

[ "Gets", "dependencies", "from", "the", "js", "source", "." ]

[ "function", "setCommonGeometryProperties", "(", "multiGeometry", ",", "geometries", ")", "{", "const", "ii", "=", "geometries", ".", "length", ";", "const", "extrudes", "=", "new", "Array", "(", "geometries", ".", "length", ")", ";", "const", "tessellates", "=", "new", "Array", "(", "geometries", ".", "length", ")", ";", "const", "altitudeModes", "=", "new", "Array", "(", "geometries", ".", "length", ")", ";", "let", "hasExtrude", ",", "hasTessellate", ",", "hasAltitudeMode", ";", "hasExtrude", "=", "hasTessellate", "=", "hasAltitudeMode", "=", "false", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "ii", ";", "++", "i", ")", "{", "const", "geometry", "=", "geometries", "[", "i", "]", ";", "extrudes", "[", "i", "]", "=", "geometry", ".", "get", "(", "'extrude'", ")", ";", "tessellates", "[", "i", "]", "=", "geometry", ".", "get", "(", "'tessellate'", ")", ";", "altitudeModes", "[", "i", "]", "=", "geometry", ".", "get", "(", "'altitudeMode'", ")", ";", "hasExtrude", "=", "hasExtrude", "||", "extrudes", "[", "i", "]", "!==", "undefined", ";", "hasTessellate", "=", "hasTessellate", "||", "tessellates", "[", "i", "]", "!==", "undefined", ";", "hasAltitudeMode", "=", "hasAltitudeMode", "||", "altitudeModes", "[", "i", "]", ";", "}", "if", "(", "hasExtrude", ")", "{", "multiGeometry", ".", "set", "(", "'extrude'", ",", "extrudes", ")", ";", "}", "if", "(", "hasTessellate", ")", "{", "multiGeometry", ".", "set", "(", "'tessellate'", ",", "tessellates", ")", ";", "}", "if", "(", "hasAltitudeMode", ")", "{", "multiGeometry", ".", "set", "(", "'altitudeMode'", ",", "altitudeModes", ")", ";", "}", "}" ]

[ "Reads", "an", "array", "of", "geometries", "and", "creates", "arrays", "for", "common", "geometry", "properties", ".", "Then", "sets", "them", "to", "the", "multi", "geometry", "." ]

[ "function", "msPointerDown", "(", "inEvent", ")", "{", "this", ".", "pointerMap", "[", "inEvent", ".", "pointerId", ".", "toString", "(", ")", "]", "=", "inEvent", ";", "const", "e", "=", "this", ".", "prepareEvent_", "(", "inEvent", ")", ";", "this", ".", "dispatcher", ".", "down", "(", "e", ",", "inEvent", ")", ";", "}" ]

[ "Handler", "for", "msPointerDown", "." ]

[ "function", "msPointerUp", "(", "inEvent", ")", "{", "const", "e", "=", "this", ".", "prepareEvent_", "(", "inEvent", ")", ";", "this", ".", "dispatcher", ".", "up", "(", "e", ",", "inEvent", ")", ";", "this", ".", "cleanup", "(", "inEvent", ".", "pointerId", ")", ";", "}" ]

[ "Handler", "for", "msPointerUp", "." ]

[ "function", "msPointerCancel", "(", "inEvent", ")", "{", "const", "e", "=", "this", ".", "prepareEvent_", "(", "inEvent", ")", ";", "this", ".", "dispatcher", ".", "cancel", "(", "e", ",", "inEvent", ")", ";", "this", ".", "cleanup", "(", "inEvent", ".", "pointerId", ")", ";", "}" ]

[ "Handler", "for", "msPointerCancel", "." ]

[ "function", "msLostPointerCapture", "(", "inEvent", ")", "{", "const", "e", "=", "this", ".", "dispatcher", ".", "makeEvent", "(", "'lostpointercapture'", ",", "inEvent", ",", "inEvent", ")", ";", "this", ".", "dispatcher", ".", "dispatchEvent", "(", "e", ")", ";", "}" ]

[ "Handler", "for", "msLostPointerCapture", "." ]

[ "function", "msGotPointerCapture", "(", "inEvent", ")", "{", "const", "e", "=", "this", ".", "dispatcher", ".", "makeEvent", "(", "'gotpointercapture'", ",", "inEvent", ",", "inEvent", ")", ";", "this", ".", "dispatcher", ".", "dispatchEvent", "(", "e", ")", ";", "}" ]

[ "Handler", "for", "msGotPointerCapture", "." ]

[ "function", "adaptAttributions", "(", "attributionLike", ")", "{", "if", "(", "!", "attributionLike", ")", "{", "return", "null", ";", "}", "if", "(", "Array", ".", "isArray", "(", "attributionLike", ")", ")", "{", "return", "function", "(", "frameState", ")", "{", "return", "attributionLike", ";", "}", ";", "}", "if", "(", "typeof", "attributionLike", "===", "'function'", ")", "{", "return", "attributionLike", ";", "}", "return", "function", "(", "frameState", ")", "{", "return", "[", "attributionLike", "]", ";", "}", ";", "}" ]

[ "Turns", "the", "attributions", "option", "into", "an", "attributions", "function", "." ]

[ "function", "(", "evt", ")", "{", "if", "(", "evt", ".", "dragging", ")", "{", "return", ";", "}", "/** @type {string} */", "let", "helpMsg", "=", "'Click to start drawing'", ";", "if", "(", "sketch", ")", "{", "const", "geom", "=", "sketch", ".", "getGeometry", "(", ")", ";", "if", "(", "geom", "instanceof", "Polygon", ")", "{", "helpMsg", "=", "continuePolygonMsg", ";", "}", "else", "if", "(", "geom", "instanceof", "LineString", ")", "{", "helpMsg", "=", "continueLineMsg", ";", "}", "}", "helpTooltipElement", ".", "innerHTML", "=", "helpMsg", ";", "helpTooltip", ".", "setPosition", "(", "evt", ".", "coordinate", ")", ";", "helpTooltipElement", ".", "classList", ".", "remove", "(", "'hidden'", ")", ";", "}" ]

[ "Handle", "pointer", "move", "." ]

[ "function", "(", "line", ")", "{", "const", "length", "=", "getLength", "(", "line", ")", ";", "let", "output", ";", "if", "(", "length", ">", "100", ")", "{", "output", "=", "(", "Math", ".", "round", "(", "length", "/", "1000", "*", "100", ")", "/", "100", ")", "+", "' '", "+", "'km'", ";", "}", "else", "{", "output", "=", "(", "Math", ".", "round", "(", "length", "*", "100", ")", "/", "100", ")", "+", "' '", "+", "'m'", ";", "}", "return", "output", ";", "}" ]

[ "global", "so", "we", "can", "remove", "it", "later", "Format", "length", "output", "." ]

[ "function", "(", "polygon", ")", "{", "const", "area", "=", "getArea", "(", "polygon", ")", ";", "let", "output", ";", "if", "(", "area", ">", "10000", ")", "{", "output", "=", "(", "Math", ".", "round", "(", "area", "/", "1000000", "*", "100", ")", "/", "100", ")", "+", "' '", "+", "'km²'", ";", "}", "else", "{", "output", "=", "(", "Math", ".", "round", "(", "area", "*", "100", ")", "/", "100", ")", "+", "' '", "+", "'m²'", ";", "}", "return", "output", ";", "}" ]

[ "Format", "area", "output", "." ]