Datasets:

---

Anonymous2023

/

dataset2js

like 0

[ "function", "inferSettings", "(", "graph", ")", "{", "var", "order", "=", "graph", ".", "order", ";", "return", "{", "barnesHutOptimize", ":", "order", ">", "2000", ",", "strongGravityMode", ":", "true", ",", "gravity", ":", "0.05", ",", "scalingRatio", ":", "10", ",", "slowDown", ":", "1", "+", "Math", ".", "log", "(", "order", ")", "}", ";", "}" ]

[ "Function", "returning", "sane", "layout", "settings", "for", "the", "given", "graph", "." ]

[ "function", "Page", "(", "path", ",", "ctx", ")", "{", "events", ".", "EventEmitter", ".", "call", "(", "this", ")", ";", "this", ".", "path", "=", "path", ";", "this", ".", "context", "=", "ctx", ";", "this", ".", "_isOpen", "=", "false", ";", "}" ]

[ "Initialize", "a", "new", "Page", "." ]

[ "function", "dispatch", "(", "req", ",", "done", ")", "{", "var", "site", "=", "req", ".", "site", ",", "path", "=", "upath", ".", "join", "(", "site", ".", "path", "||", "''", ",", "req", ".", "path", ")", ",", "parent", "=", "site", ".", "parent", ";", "while", "(", "parent", ")", "{", "path", "=", "upath", ".", "join", "(", "parent", ".", "path", "||", "''", ",", "path", ")", ";", "parent", "=", "parent", ".", "parent", ";", "}", "console", ".", "log", "(", "'# '", "+", "path", ")", ";", "var", "page", "=", "new", "Page", "(", "path", ",", "req", ".", "context", ")", ";", "pages", ".", "push", "(", "page", ")", ";", "page", ".", "once", "(", "'close'", ",", "done", ")", ";", "self", ".", "handle", "(", "page", ")", ";", "}" ]

[ "Binding", "is", "complete", "producing", "a", "complete", "list", "of", "all", "pages", "that", "need", "to", "be", "generated", ".", "Dispatch", "those", "pages", "into", "the", "application", "so", "that", "the", "content", "can", "be", "written", "to", "files", "which", "constitute", "the", "static", "site", "." ]

[ "function", "rewrite_code", "(", "code", ",", "node", ",", "replacement_string", ")", "{", "return", "code", ".", "substr", "(", "0", ",", "node", ".", "start", ".", "pos", ")", "+", "replacement_string", "+", "code", ".", "substr", "(", "node", ".", "end", ".", "endpos", ")", ";", "}" ]

[ "Modify", "code", "string", "with", "a", "new", "value", "based", "on", "start", "and", "end", "position", "of", "an", "UglifyJS", ".", "AST_Node" ]

[ "function", "generateData", "(", "filepath", ")", "{", "var", "dataObj", "=", "new", "datauri", "(", "filepath", ")", ";", "return", "{", "data", ":", "dataObj", ".", "content", ",", "path", ":", "filepath", "}", ";", "}" ]

[ "generates", "a", "datauri", "object", "from", "file", "~~~~~~~~~~~~~~~~~~~~~" ]

[ "function", "generateCss", "(", "filepath", ",", "data", ")", "{", "var", "filetype", "=", "filepath", ".", "split", "(", "'.'", ")", ".", "pop", "(", ")", ".", "toLowerCase", "(", ")", ";", "var", "className", ";", "var", "template", ";", "className", "=", "options", ".", "classPrefix", "+", "path", ".", "basename", "(", "data", ".", "path", ")", ".", "split", "(", "'.'", ")", "[", "0", "]", "+", "options", ".", "classSuffix", ";", "filetype", "=", "options", ".", "usePlaceholder", "?", "filetype", ":", "filetype", "+", "'_no'", ";", "if", "(", "options", ".", "variables", ")", "{", "template", "=", "cssTemplates", ".", "variables", ";", "}", "else", "{", "template", "=", "cssTemplates", "[", "filetype", "]", "||", "cssTemplates", ".", "default", ";", "}", "return", "template", ".", "replace", "(", "'{{class}}'", ",", "className", ")", ".", "replace", "(", "'{{data}}'", ",", "data", ".", "data", ")", ";", "}" ]

[ "wraps", "daturi", "in", "css", "class", "~~~~~~~~~~~~~~~~~~~~~" ]

[ "function", "getHistory", "(", "callback", ")", "{", "if", "(", "_", ".", "isUndefined", "(", "callback", ")", ")", "{", "}", "else", "{", "var", "u", "=", "config", ".", "baseUrl", "+", "(", "(", "api_version", "==", "\"v1\"", ")", "?", "\"v1.1\"", ":", "api_version", ")", "+", "\"/history\"", ",", "tokenData", "=", "this", ".", "getAuthToken", "(", ")", ";", "if", "(", "tokenData", ".", "type", "!=", "\"bearer\"", ")", "{", "throw", "new", "Error", "(", "\"Invalid token type. Must use a token of type bearer.\"", ")", ";", "}", "return", "helper", ".", "get", "(", "tokenData", ",", "u", ",", "callback", ")", ";", "}", "}" ]

[ "getHistory", "Get", "the", "currently", "logged", "in", "user", "history" ]

[ "function", "getUserProfile", "(", "callback", ")", "{", "if", "(", "_", ".", "isUndefined", "(", "callback", ")", ")", "{", "}", "else", "{", "var", "u", "=", "baseUrl", "+", "\"/me\"", ";", "var", "tokenData", "=", "this", ".", "getAuthToken", "(", ")", ";", "if", "(", "tokenData", ".", "type", "!=", "\"bearer\"", ")", "{", "throw", "new", "Error", "(", "\"Invalid token type. Must use a token of type bearer.\"", ")", ";", "}", "return", "helper", ".", "get", "(", "tokenData", ",", "u", ",", "callback", ")", ";", "}", "}" ]

[ "getMe", "Get", "the", "currently", "logged", "in", "user", "profile", "." ]

[ "function", "(", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "exec", "(", "\"find . ! -name '\"", "+", "__filename", ".", "split", "(", "'/'", ")", ".", "pop", "(", ")", "+", "\"' -iname '*\\.js' | xargs grep 'CRUD.Entity.call(this);' -isl\"", ",", "\\.", ",", "{", "timeout", ":", "3000", ",", "cwd", ":", "process", ".", "cwd", "(", ")", "}", ")", ";", "}", ")", ";", "}" ]

[ "Find", "and", "register", "all", "CRUD", "entities", "under", "the", "base", "dir", ".", "evaluates", "the", "files" ]

[ "function", "(", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "exec", "(", "\"find . ! -name '\"", "+", "__filename", ".", "split", "(", "'/'", ")", ".", "pop", "(", ")", "+", "\"' -iname '*\\.js' | xargs grep 'CRUD.Entity.call(this);' -isl\"", ",", "\\.", ",", "{", "timeout", ":", "3000", ",", "cwd", ":", "process", ".", "cwd", "(", ")", "}", ")", ";", "}", ")", ";", "}" ]

[ "Find", "the", "filenames", "for", "all", "CRUD", "entities", "under", "the", "base", "dir" ]

[ "function", "Group", "(", "props", ")", "{", "var", "children", "=", "React", ".", "Children", ".", "toArray", "(", "props", ".", "children", ")", ".", "filter", "(", "Boolean", ")", ";", "if", "(", "children", ".", "length", "===", "1", ")", "{", "return", "children", ";", "}", "var", "separator", "=", "props", ".", "separator", ";", "var", "separatorIsElement", "=", "React", ".", "isValidElement", "(", "separator", ")", ";", "var", "items", "=", "[", "children", ".", "shift", "(", ")", "]", ";", "children", ".", "forEach", "(", "function", "(", "item", ",", "index", ")", "{", "if", "(", "separatorIsElement", ")", "{", "var", "key", "=", "'separator-'", "+", "(", "item", ".", "key", "||", "index", ")", ";", "separator", "=", "React", ".", "cloneElement", "(", "separator", ",", "{", "key", ":", "key", "}", ")", ";", "}", "items", ".", "push", "(", "separator", ",", "item", ")", ";", "}", ")", ";", "return", "items", ";", "}" ]

[ "React", "component", "to", "render", "collection", "of", "items", "separated", "by", "space", "or", "other", "separator", "." ]

[ "function", "createSite", "(", ")", "{", "function", "app", "(", "page", ")", "{", "app", ".", "handle", "(", "page", ")", ";", "}", "mixin", "(", "app", ",", "EventEmitter", ".", "prototype", ",", "false", ")", ";", "mixin", "(", "app", ",", "proto", ",", "false", ")", ";", "app", ".", "init", "(", ")", ";", "return", "app", ";", "}" ]

[ "Create", "a", "Kerouac", "site", "." ]

[ "function", "invalidResponseError", "(", "result", ",", "host", ")", "{", "const", "message", "=", "!", "!", "result", "&&", "!", "!", "result", ".", "error", "&&", "!", "!", "result", ".", "error", ".", "message", "?", "`", "${", "result", ".", "error", ".", "message", "}", "`", ":", "`", "${", "host", "}", "${", "JSON", ".", "stringify", "(", "result", ",", "null", ",", "2", ")", "}", "`", ";", "return", "new", "Error", "(", "message", ")", ";", "}" ]

[ "InvalidResponseError", "helper", "for", "invalid", "errors", "." ]

[ "function", "HttpProvider", "(", "host", ",", "timeout", ")", "{", "if", "(", "!", "(", "this", "instanceof", "HttpProvider", ")", ")", "{", "throw", "new", "Error", "(", "'[ethjs-provider-http] the HttpProvider instance requires the \"new\" flag in order to function normally (e.g. `const eth = new Eth(new HttpProvider());`).'", ")", ";", "}", "if", "(", "typeof", "host", "!==", "'string'", ")", "{", "throw", "new", "Error", "(", "'[ethjs-provider-http] the HttpProvider instance requires that the host be specified (e.g. `new HttpProvider(\"http://localhost:8545\")` or via service like infura `new HttpProvider(\"http://ropsten.infura.io\")`)'", ")", ";", "}", "const", "self", "=", "this", ";", "self", ".", "host", "=", "host", ";", "self", ".", "timeout", "=", "timeout", "||", "0", ";", "}" ]

[ "HttpProvider", "should", "be", "used", "to", "send", "rpc", "calls", "over", "http" ]

[ "function", "(", "ip", ")", "{", "this", ".", "connectionparams", "=", "{", "host", ":", "ip", ",", "port", ":", "23", ",", "timeout", ":", "1000", ",", "sendTimeout", ":", "1200", ",", "negotiationMandatory", ":", "false", ",", "ors", ":", "'\\r'", ",", "\\r", "}", ";", "irs", ":", "'\\r'", "\\r", "}" ]

[ "Returns", "an", "instance", "of", "MarantzDenonTelnet", "that", "can", "handle", "telnet", "commands", "to", "the", "given", "IP", "." ]

[ "function", "sendKeys", "(", "element", ",", "str", ")", "{", "return", "str", ".", "split", "(", "''", ")", ".", "reduce", "(", "function", "(", "promise", ",", "char", ")", "{", "return", "promise", ".", "then", "(", "function", "(", ")", "{", "return", "element", ".", "sendKeys", "(", "char", ")", ";", "}", ")", ";", "}", ",", "element", ".", "getAttribute", "(", "'value'", ")", ")", ";", "}" ]

[ "Hack", "-", "because", "of", "bug", "with", "protractor", "send", "keys" ]

[ "function", "insertQuerySuccess", "(", "resultSet", ")", "{", "resultSet", ".", "Action", "=", "'inserted'", ";", "resultSet", ".", "ID", "=", "resultSet", ".", "rs", ".", "insertId", ";", "CRUD", ".", "stats", ".", "writesExecuted", "++", ";", "return", "resultSet", ";", "}" ]

[ "Generic", "insert", "query", "callback", "that", "logs", "writesExecuted", "and", "sets", "inserted", "action", "+", "id" ]

[ "function", "insertQueryError", "(", "err", ",", "tx", ")", "{", "CRUD", ".", "stats", ".", "writesExecuted", "++", ";", "console", ".", "error", "(", "\"Insert query error: \"", ",", "err", ")", ";", "return", "err", ";", "}" ]

[ "Generic", "insert", "query", "error", "callback", "that", "logs", "writesExecuted", "and", "the", "error", "." ]

[ "function", "parseSchemaInfo", "(", "resultset", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "resultset", ".", "rs", ".", "rows", ".", "length", ";", "i", "++", ")", "{", "var", "row", "=", "resultset", ".", "rs", ".", "rows", ".", "item", "(", "i", ")", ";", "if", "(", "row", ".", "name", ".", "indexOf", "(", "'sqlite_autoindex'", ")", ">", "-", "1", "||", "row", ".", "name", "==", "'__WebKitDatabaseInfoTable__'", ")", "continue", ";", "if", "(", "row", ".", "type", "==", "'table'", ")", "{", "tables", ".", "push", "(", "row", ".", "tbl_name", ")", ";", "}", "else", "if", "(", "row", ".", "type", "==", "'index'", ")", "{", "if", "(", "!", "(", "row", ".", "tbl_name", "in", "indexes", ")", ")", "{", "indexes", "[", "row", ".", "tbl_name", "]", "=", "[", "]", ";", "}", "indexes", "[", "row", ".", "tbl_name", "]", ".", "push", "(", "row", ".", "name", ")", ";", "}", "}", "return", ";", "}" ]

[ "Pre", "-", "Parse", "database", "schema", "info", "for", "further", "processing", ".", "Finds", "tables", "and", "indexes", "." ]

[ "function", "createTables", "(", ")", "{", "return", "Promise", ".", "all", "(", "Object", ".", "keys", "(", "CRUD", ".", "EntityManager", ".", "entities", ")", ".", "map", "(", "function", "(", "entityName", ")", "{", "var", "entity", "=", "CRUD", ".", "EntityManager", ".", "entities", "[", "entityName", "]", ";", "if", "(", "tables", ".", "indexOf", "(", "entity", ".", "table", ")", "==", "-", "1", ")", "{", "if", "(", "!", "entity", ".", "createStatement", ")", "{", "throw", "\"No create statement found for \"", "+", "entity", ".", "getType", "(", ")", "+", "\". Don't know how to create table.\"", ";", "}", "return", "db", ".", "execute", "(", "entity", ".", "createStatement", ")", ".", "then", "(", "function", "(", ")", "{", "tables", ".", "push", "(", "entity", ".", "table", ")", ";", "localStorage", ".", "setItem", "(", "'database.version.'", "+", "entity", ".", "table", ",", "(", "'migrations'", "in", "entity", ")", "?", "Math", ".", "max", ".", "apply", "(", "Math", ",", "Object", ".", "keys", "(", "entity", ".", "migrations", ")", ")", ":", "1", ")", ";", "CRUD", ".", "log", "(", "entity", ".", "table", "+", "\" table created.\"", ")", ";", "return", "entity", ";", "}", ",", "function", "(", "err", ")", "{", "CRUD", ".", "log", "(", "\"Error creating \"", "+", "entity", ".", "table", ",", "err", ",", "entity", ".", "createStatement", ")", ";", "throw", "\"Error creating table: \"", "+", "entity", ".", "table", ";", "}", ")", ".", "then", "(", "createFixtures", ")", ".", "then", "(", "function", "(", ")", "{", "CRUD", ".", "log", "(", "\"Table created and fixtures inserted for \"", ",", "entityName", ")", ";", "return", ";", "}", ")", ";", "}", "return", ";", "}", ")", ")", ";", "}" ]

[ "Iterate", "the", "list", "of", "registered", "entities", "and", "creates", "their", "tables", "if", "they", "don", "t", "exist", ".", "Run", "the", "migrations", "when", "needed", "if", "the", "table", "version", "is", "out", "of", "sync" ]

[ "function", "createIndexes", "(", ")", "{", "return", "Promise", ".", "all", "(", "Object", ".", "keys", "(", "CRUD", ".", "EntityManager", ".", "entities", ")", ".", "map", "(", "function", "(", "entityName", ")", "{", "var", "entity", "=", "CRUD", ".", "EntityManager", ".", "entities", "[", "entityName", "]", ";", "if", "(", "(", "'indexes'", "in", "entity", ")", ")", "{", "return", "Promise", ".", "all", "(", "entity", ".", "indexes", ".", "map", "(", "function", "(", "index", ")", "{", "var", "indexName", "=", "index", ".", "replace", "(", "/", "\\W", "/", "g", ",", "''", ")", "+", "'_idx'", ";", "if", "(", "!", "(", "entity", ".", "table", "in", "indexes", ")", "||", "indexes", "[", "entity", ".", "table", "]", ".", "indexOf", "(", "indexName", ")", "==", "-", "1", ")", "{", "return", "db", ".", "execute", "(", "\"create index if not exists \"", "+", "indexName", "+", "\" on \"", "+", "entity", ".", "table", "+", "\" (\"", "+", "index", "+", "\")\"", ")", ".", "then", "(", "function", "(", "result", ")", "{", "CRUD", ".", "log", "(", "\"index created: \"", ",", "entity", ".", "table", ",", "index", ",", "indexName", ")", ";", "if", "(", "!", "(", "entity", ".", "table", "in", "indexes", ")", ")", "{", "indexes", "[", "entity", ".", "table", "]", "=", "[", "]", ";", "}", "indexes", "[", "entity", ".", "table", "]", ".", "push", "(", "indexName", ")", ";", "return", ";", "}", ")", ";", "}", "return", ";", "}", ")", ")", ";", "}", "}", ")", ")", ";", "}" ]

[ "Iterate", "the", "list", "of", "existing", "and", "non", "-", "existing", "indexes", "for", "each", "entity", "and", "create", "the", "ones", "that", "don", "t", "exist", "." ]

[ "function", "createFixtures", "(", "entity", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "if", "(", "!", "entity", ".", "fixtures", ")", "return", "resolve", "(", ")", ";", "return", "Promise", ".", "all", "(", "entity", ".", "fixtures", ".", "map", "(", "function", "(", "fixture", ")", "{", "CRUD", ".", "fromCache", "(", "entity", ".", "getType", "(", ")", ",", "fixture", ")", ".", "Persist", "(", "true", ")", ";", "}", ")", ")", ".", "then", "(", "resolve", ",", "reject", ")", ";", "}", ")", ";", "}" ]

[ "Insert", "fixtures", "for", "an", "entity", "if", "they", "exist" ]

[ "function", "(", "field", ",", "def", ")", "{", "var", "ret", ";", "if", "(", "field", "in", "this", ".", "__dirtyValues__", ")", "{", "ret", "=", "this", ".", "__dirtyValues__", "[", "field", "]", ";", "}", "else", "if", "(", "field", "in", "this", ".", "__values__", ")", "{", "ret", "=", "this", ".", "__values__", "[", "field", "]", ";", "}", "else", "if", "(", "CRUD", ".", "EntityManager", ".", "entities", "[", "this", ".", "getType", "(", ")", "]", ".", "fields", ".", "indexOf", "(", "field", ")", ">", "-", "1", ")", "{", "ret", "=", "(", "field", "in", "CRUD", ".", "EntityManager", ".", "entities", "[", "this", ".", "getType", "(", ")", "]", ".", "defaultValues", ")", "?", "CRUD", ".", "EntityManager", ".", "entities", "[", "this", ".", "getType", "(", ")", "]", ".", "defaultValues", "[", "field", "]", ":", "null", ";", "}", "else", "{", "CRUD", ".", "log", "(", "'Could not find field \\''", "+", "\\'", "+", "field", "+", "'\\' in \\''", "+", "\\'", ")", ";", "}", "\\'", "}" ]

[ "Accessor", ".", "Gets", "one", "field", "optionally", "returns", "the", "default", "value", "." ]

[ "function", "Route", "(", "path", ",", "fns", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "this", ".", "path", "=", "path", ";", "this", ".", "fns", "=", "fns", ";", "this", ".", "regexp", "=", "pathRegexp", "(", "path", ",", "this", ".", "keys", "=", "[", "]", ",", "options", ")", ";", "}" ]

[ "Initialize", "a", "new", "Route", "with", "the", "given", "path", "an", "array", "of", "callback", "fns", "and", "options", "." ]

[ "function", "buildFile", "(", ")", "{", "var", "reader", "=", "readline", ".", "createInterface", "(", "{", "input", ":", "fs", ".", "createReadStream", "(", "path", ".", "resolve", "(", "\"./src/assets/template.html\"", ")", ")", "}", ")", ";", "var", "lines", "=", "[", "]", ";", "reader", ".", "on", "(", "\"line\"", ",", "line", "=>", "lines", ".", "push", "(", "line", ")", ")", ";", "return", "new", "Promise", "(", "resolve", "=>", "{", "reader", ".", "on", "(", "\"close\"", ",", "(", ")", "=>", "resolve", "(", "buildJsFileContents", "(", "lines", ")", ")", ")", ";", "}", ")", ";", "}" ]

[ "Build", "a", "promise", "which", "will", "generate", "css", "-", ">", "js", "file", "contents" ]

[ "function", "(", "moveBack", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "exec", "(", "resolve", ",", "reject", ",", "APP_PLUGIN_NAME", ",", "\"minimizeApp\"", ",", "[", "moveBack", "||", "false", "]", ")", ";", "}", ")", ";", "}" ]

[ "Go", "to", "home", "screen" ]

[ "function", "(", "packageName", ",", "componentName", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "exec", "(", "resolve", ",", "reject", ",", "APP_PLUGIN_NAME", ",", "\"startApp\"", ",", "[", "packageName", ",", "componentName", "]", ")", ";", "}", ")", ";", "}" ]

[ "Starts", "app", "intent" ]

[ "function", "promisePrompt", "(", "questions", ")", "{", "return", "new", "Promise", "(", "function", "(", "resolve", ",", "reject", ")", "{", "inquirer", ".", "prompt", "(", "questions", ",", "function", "(", "results", ")", "{", "resolve", "(", "results", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Convert", "inquirer", ".", "prompt", "to", "a", "promise", "." ]

[ "function", "buildJsFileContent", "(", "lines", ")", "{", "var", "ls", "=", "lines", ".", "map", "(", "l", "=>", "l", ".", "replace", "(", "/", "^\\s*", "/", "g", ",", "\"\"", ")", ".", "replace", "(", "/", "\\s*$", "/", "g", ",", "\"\"", ")", ".", "replace", "(", "/", "\\\\", "/", "g", ",", "\"\\\\\\\\\"", ")", ".", "\\\\", "\\\\", ".", "replace", "(", "/", "\"", "/", "g", ",", "\"\\\\\\\"\"", ")", ".", "\\\\", "\\\"", ")", ".", "replace", "(", "/", "\\s*\\{\\s*", "/", "g", ",", "\"{\"", ")", ".", "replace", "(", "/", "\\s*:\\s*", "/", "g", ",", "\":\"", ")", ";", "join", "}" ]

[ "Create", "the", "js", "content", "of", "the", "file", "to", "add", "css" ]

[ "function", "(", "done", ",", "promise", ",", "expectedState", ",", "expectedData", ",", "isNegative", ")", "{", "function", "verify", "(", "promiseState", ")", "{", "return", "function", "(", "data", ")", "{", "var", "test", "=", "verifyState", "(", "promiseState", ",", "expectedState", ")", ";", "if", "(", "test", ".", "pass", ")", "{", "test", "=", "verifyData", "(", "data", ",", "expectedData", ")", ";", "}", "if", "(", "!", "test", ".", "pass", "&&", "!", "isNegative", ")", "{", "done", ".", "fail", "(", "new", "Error", "(", "test", ".", "message", ")", ")", ";", "return", ";", "}", "done", "(", ")", ";", "}", "}", "promise", ".", "then", "(", "verify", "(", "PROMISE_STATE", ".", "RESOLVED", ")", ",", "verify", "(", "PROMISE_STATE", ".", "REJECTED", ")", ")", ";", "return", "{", "pass", ":", "true", "}", ";", "}" ]

[ "Helper", "method", "to", "verify", "expectations", "and", "return", "a", "Jasmine", "-", "friendly", "info", "-", "object" ]

[ "function", "(", "class_data", ",", "path", ")", "{", "var", "implements_source", "=", "this", ".", "_sources", "[", "path", "]", ",", "name", ",", "references_offset", ";", "if", "(", "Lava", ".", "schema", ".", "DEBUG", ")", "{", "if", "(", "!", "implements_source", ")", "Lava", ".", "t", "(", "'Implements: class not found - \"'", "+", "path", "+", "'\"'", ")", ";", "for", "(", "name", "in", "implements_source", ".", "shared", ")", "Lava", ".", "t", "(", "\"Implements: unable to use a class with Shared as mixin.\"", ")", ";", "if", "(", "class_data", ".", "implements", ".", "indexOf", "(", "path", ")", "!=", "-", "1", ")", "Lava", ".", "t", "(", "\"Implements: class \"", "+", "class_data", ".", "path", "+", "\" already implements \"", "+", "path", ")", ";", "}", "class_data", ".", "implements", ".", "push", "(", "path", ")", ";", "references_offset", "=", "class_data", ".", "references", ".", "length", ";", "class_data", ".", "references", "=", "class_data", ".", "references", ".", "concat", "(", "implements_source", ".", "references", ")", ";", "this", ".", "_extend", "(", "class_data", ",", "class_data", ".", "skeleton", ",", "implements_source", ",", "implements_source", ".", "skeleton", ",", "true", ",", "references_offset", ")", ";", "}" ]

[ "Implement", "members", "from", "another", "class", "into", "current", "class", "data" ]

[ "function", "(", "class_data", ",", "source_object", ",", "is_root", ")", "{", "var", "name", ",", "skeleton", "=", "{", "}", ",", "value", ",", "type", ",", "skeleton_value", ";", "for", "(", "name", "in", "source_object", ")", "{", "if", "(", "is_root", "&&", "(", "this", ".", "_reserved_members", ".", "indexOf", "(", "name", ")", "!=", "-", "1", "||", "(", "name", "in", "class_data", ".", "shared", ")", ")", ")", "{", "continue", ";", "}", "value", "=", "source_object", "[", "name", "]", ";", "type", "=", "Firestorm", ".", "getType", "(", "value", ")", ";", "switch", "(", "type", ")", "{", "case", "'null'", ":", "case", "'boolean'", ":", "case", "'number'", ":", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "PRIMITIVE", ",", "value", ":", "value", "}", ";", "break", ";", "case", "'string'", ":", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "STRING", ",", "value", ":", "value", "}", ";", "break", ";", "case", "'function'", ":", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "FUNCTION", ",", "index", ":", "class_data", ".", "references", ".", "length", "}", ";", "class_data", ".", "references", ".", "push", "(", "value", ")", ";", "break", ";", "case", "'regexp'", ":", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "REGEXP", ",", "index", ":", "class_data", ".", "references", ".", "length", "}", ";", "class_data", ".", "references", ".", "push", "(", "value", ")", ";", "break", ";", "case", "'object'", ":", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "OBJECT", ",", "skeleton", ":", "this", ".", "_disassemble", "(", "class_data", ",", "value", ",", "false", ")", "}", ";", "break", ";", "case", "'array'", ":", "if", "(", "value", ".", "length", "==", "0", ")", "{", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "EMPTY_ARRAY", "}", ";", "}", "else", "if", "(", "this", ".", "inline_simple_arrays", "&&", "this", ".", "isInlineArray", "(", "value", ")", ")", "{", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "INLINE_ARRAY", ",", "value", ":", "value", "}", ";", "}", "else", "{", "skeleton_value", "=", "{", "type", ":", "this", ".", "MEMBER_TYPES", ".", "SLICE_ARRAY", ",", "index", ":", "class_data", ".", "references", ".", "length", "}", ";", "class_data", ".", "references", ".", "push", "(", "value", ")", ";", "}", "break", ";", "case", "'undefined'", ":", "Lava", ".", "t", "(", "\"[ClassManager] Forced code style restriction: please, replace undefined member values with null. Member name: \"", "+", "name", ")", ";", "break", ";", "default", ":", "Lava", ".", "t", "(", "\"[ClassManager] Unsupported property type in source object: \"", "+", "type", ")", ";", "break", ";", "}", "skeleton", "[", "name", "]", "=", "skeleton_value", ";", "}", "return", "skeleton", ";", "}" ]

[ "Recursively", "create", "skeletons", "for", "all", "objects", "inside", "class", "body" ]

[ "function", "(", "skeleton", ",", "class_data", ",", "padding", ",", "serialized_properties", ")", "{", "var", "name", ",", "serialized_value", ",", "uses_references", "=", "false", ",", "object_properties", ";", "for", "(", "name", "in", "skeleton", ")", "{", "switch", "(", "skeleton", "[", "name", "]", ".", "type", ")", "{", "case", "this", ".", "MEMBER_TYPES", ".", "STRING", ":", "serialized_value", "=", "Firestorm", ".", "String", ".", "quote", "(", "skeleton", "[", "name", "]", ".", "value", ")", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "PRIMITIVE", ":", "serialized_value", "=", "skeleton", "[", "name", "]", ".", "value", "+", "''", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "REGEXP", ":", "case", "this", ".", "MEMBER_TYPES", ".", "FUNCTION", ":", "serialized_value", "=", "'r['", "+", "skeleton", "[", "name", "]", ".", "index", "+", "']'", ";", "uses_references", "=", "true", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "EMPTY_ARRAY", ":", "serialized_value", "=", "\"[]\"", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "INLINE_ARRAY", ":", "serialized_value", "=", "this", ".", "_serializeInlineArray", "(", "skeleton", "[", "name", "]", ".", "value", ")", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "SLICE_ARRAY", ":", "serialized_value", "=", "'r['", "+", "skeleton", "[", "name", "]", ".", "index", "+", "'].slice()'", ";", "uses_references", "=", "true", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "OBJECT", ":", "object_properties", "=", "[", "]", ";", "if", "(", "this", ".", "_serializeSkeleton", "(", "skeleton", "[", "name", "]", ".", "skeleton", ",", "class_data", ",", "padding", "+", "\"\\t\"", ",", "\\t", ")", ")", "object_properties", "{", "uses_references", "=", "true", ";", "}", "serialized_value", "=", "object_properties", ".", "length", "?", "\"{\\n\\t\"", "+", "\\n", "+", "\\t", "+", "padding", "+", "object_properties", ".", "join", "(", "\",\\n\\t\"", "+", "\\n", ")", "+", "\\t", ":", "padding", ";", "\"\\n\"", "}", "\\n", "}", "padding", "}" ]

[ "Perform", "special", "class", "serialization", "that", "takes", "functions", "and", "resources", "from", "class", "data", "and", "can", "be", "used", "in", "constructors" ]

[ "function", "(", "path_segments", ")", "{", "var", "namespace", ",", "segment_name", ",", "count", "=", "path_segments", ".", "length", ",", "i", "=", "1", ";", "if", "(", "!", "count", ")", "Lava", ".", "t", "(", "\"ClassManager: class names must include a namespace, even for global classes.\"", ")", ";", "if", "(", "!", "(", "path_segments", "[", "0", "]", "in", "this", ".", "_root", ")", ")", "Lava", ".", "t", "(", "\"[ClassManager] namespace is not registered: \"", "+", "path_segments", "[", "0", "]", ")", ";", "namespace", "=", "this", ".", "_root", "[", "path_segments", "[", "0", "]", "]", ";", "for", "(", ";", "i", "<", "count", ";", "i", "++", ")", "{", "segment_name", "=", "path_segments", "[", "i", "]", ";", "if", "(", "!", "(", "segment_name", "in", "namespace", ")", ")", "{", "namespace", "[", "segment_name", "]", "=", "{", "}", ";", "}", "namespace", "=", "namespace", "[", "segment_name", "]", ";", "}", "return", "namespace", ";", "}" ]

[ "Get", "namespace", "for", "a", "class", "constructor" ]

[ "function", "(", "class_path", ",", "default_namespace", ")", "{", "if", "(", "!", "(", "class_path", "in", "this", ".", "constructors", ")", "&&", "default_namespace", ")", "{", "class_path", "=", "default_namespace", "+", "'.'", "+", "class_path", ";", "}", "return", "this", ".", "constructors", "[", "class_path", "]", ";", "}" ]

[ "Get", "class", "constructor" ]

[ "function", "(", "data", ")", "{", "var", "tempResult", "=", "[", "]", ",", "i", "=", "0", ",", "count", "=", "data", ".", "length", ",", "type", ",", "value", ";", "for", "(", ";", "i", "<", "count", ";", "i", "++", ")", "{", "type", "=", "Firestorm", ".", "getType", "(", "data", "[", "i", "]", ")", ";", "switch", "(", "type", ")", "{", "case", "'string'", ":", "value", "=", "Firestorm", ".", "String", ".", "quote", "(", "data", "[", "i", "]", ")", ";", "break", ";", "case", "'null'", ":", "case", "'undefined'", ":", "case", "'boolean'", ":", "case", "'number'", ":", "value", "=", "data", "[", "i", "]", "+", "''", ";", "break", ";", "default", ":", "Lava", ".", "t", "(", ")", ";", "}", "tempResult", ".", "push", "(", "value", ")", ";", "}", "return", "'['", "+", "tempResult", ".", "join", "(", "\", \"", ")", "+", "']'", ";", "}" ]

[ "Serialize", "an", "array", "which", "contains", "only", "certain", "primitive", "types", "from", "SIMPLE_TYPES", "property" ]

[ "function", "(", "class_data", ")", "{", "var", "skeleton", "=", "class_data", ".", "skeleton", ",", "name", ",", "serialized_value", ",", "serialized_actions", "=", "[", "]", ",", "is_polymorphic", "=", "!", "class_data", ".", "is_monomorphic", ";", "for", "(", "name", "in", "skeleton", ")", "{", "switch", "(", "skeleton", "[", "name", "]", ".", "type", ")", "{", "case", "this", ".", "MEMBER_TYPES", ".", "REGEXP", ":", "case", "this", ".", "MEMBER_TYPES", ".", "FUNCTION", ":", "serialized_value", "=", "'r['", "+", "skeleton", "[", "name", "]", ".", "index", "+", "']'", ";", "break", ";", "case", "this", ".", "MEMBER_TYPES", ".", "STRING", ":", "if", "(", "is_polymorphic", ")", "{", "serialized_value", "=", "'\"'", "+", "skeleton", "[", "name", "]", ".", "value", ".", "replace", "(", "/", "\\\"", "/", "g", ",", "\"\\\\\\\"\"", ")", "+", "\\\\", ";", "}", "\\\"", "'\"'", "}", "break", ";", "}", "case", "this", ".", "MEMBER_TYPES", ".", "PRIMITIVE", ":", "if", "(", "is_polymorphic", ")", "{", "serialized_value", "=", "skeleton", "[", "name", "]", ".", "value", "+", "''", ";", "}", "break", ";", "if", "(", "serialized_value", ")", "{", "if", "(", "Lava", ".", "VALID_PROPERTY_NAME_REGEX", ".", "test", "(", "name", ")", ")", "{", "serialized_actions", ".", "push", "(", "'p.'", "+", "name", "+", "' = '", "+", "serialized_value", "+", "';'", ")", ";", "}", "else", "{", "serialized_actions", ".", "push", "(", "'p['", "+", "Firestorm", ".", "String", ".", "quote", "(", "name", ")", "+", "'] = '", "+", "serialized_value", "+", "';'", ")", ";", "}", "serialized_value", "=", "null", ";", "}", "}" ]

[ "Build", "a", "function", "that", "creates", "class", "constructor", "s", "prototype", ".", "Used", "in", "export" ]

[ "function", "(", "class_datas", ")", "{", "for", "(", "var", "i", "=", "0", ",", "count", "=", "class_datas", ".", "length", ";", "i", "<", "count", ";", "i", "++", ")", "{", "this", ".", "loadClass", "(", "class_datas", "[", "i", "]", ")", ";", "}", "}" ]

[ "Batch", "load", "exported", "classes", ".", "Constructors", "references", "and", "skeletons", "can", "be", "provided", "as", "separate", "arrays" ]

[ "function", "(", "class_data", ")", "{", "var", "class_path", "=", "class_data", ".", "path", ",", "namespace_path", ",", "class_name", ",", "namespace", ";", "if", "(", "(", "class_path", "in", "this", ".", "_sources", ")", "||", "(", "class_path", "in", "this", ".", "constructors", ")", ")", "Lava", ".", "t", "(", "\"Class is already defined: \"", "+", "class_path", ")", ";", "this", ".", "_sources", "[", "class_path", "]", "=", "class_data", ";", "if", "(", "class_data", ".", "constructor", ")", "{", "namespace_path", "=", "class_path", ".", "split", "(", "'.'", ")", ";", "class_name", "=", "namespace_path", ".", "pop", "(", ")", ";", "namespace", "=", "this", ".", "_getNamespace", "(", "namespace_path", ")", ";", "if", "(", "(", "class_name", "in", "namespace", ")", "&&", "namespace", "[", "class_name", "]", "!=", "null", ")", "Lava", ".", "t", "(", "\"Class name conflict: '\"", "+", "class_path", "+", "\"' property is already defined in namespace path\"", ")", ";", "this", ".", "constructors", "[", "class_path", "]", "=", "class_data", ".", "constructor", ";", "namespace", "[", "class_name", "]", "=", "class_data", ".", "constructor", ";", "}", "}" ]

[ "Put", "a", "newly", "built", "class", "constructor", "into", "it", "s", "namespace" ]

[ "function", "(", "base_path", ",", "suffix", ")", "{", "if", "(", "Lava", ".", "schema", ".", "DEBUG", "&&", "!", "(", "base_path", "in", "this", ".", "_sources", ")", ")", "Lava", ".", "t", "(", "\"[getPackageConstructor] Class not found: \"", "+", "base_path", ")", ";", "var", "path", ",", "current_class", "=", "this", ".", "_sources", "[", "base_path", "]", ",", "result", "=", "null", ";", "do", "{", "path", "=", "current_class", ".", "path", "+", "suffix", ";", "if", "(", "path", "in", "this", ".", "constructors", ")", "{", "result", "=", "this", ".", "constructors", "[", "path", "]", ";", "break", ";", "}", "current_class", "=", "current_class", ".", "parent_class_data", ";", "}", "while", "(", "current_class", ")", ";", "return", "result", ";", "}" ]

[ "Find", "a", "class", "that", "begins", "with", "base_path", "or", "names", "of", "it", "s", "parents", "and", "ends", "with", "suffix" ]

[ "function", "$$core$$ResolveLocale", "(", "availableLocales", ",", "requestedLocales", ",", "options", ",", "relevantExtensionKeys", ",", "localeData", ")", "{", "if", "(", "availableLocales", ".", "length", "===", "0", ")", "{", "throw", "new", "ReferenceError", "(", "'No locale data has been provided for this object yet.'", ")", ";", "}", "var", "matcher", "=", "options", "[", "'[[localeMatcher]]'", "]", ";", "if", "(", "matcher", "===", "'lookup'", ")", "var", "r", "=", "$$core$$LookupMatcher", "(", "availableLocales", ",", "requestedLocales", ")", ";", "else", "var", "r", "=", "$$core$$BestFitMatcher", "(", "availableLocales", ",", "requestedLocales", ")", ";", "var", "foundLocale", "=", "r", "[", "'[[locale]]'", "]", ";", "if", "(", "$$core$$hop", ".", "call", "(", "r", ",", "'[[extension]]'", ")", ")", "var", "extension", "=", "r", "[", "'[[extension]]'", "]", ",", "extensionIndex", "=", "r", "[", "'[[extensionIndex]]'", "]", ",", "split", "=", "String", ".", "prototype", ".", "split", ",", "extensionSubtags", "=", "split", ".", "call", "(", "extension", ",", "'-'", ")", ",", "extensionSubtagsLength", "=", "extensionSubtags", ".", "length", ";", "var", "result", "=", "new", "$$core$$Record", "(", ")", ";", "result", "[", "'[[dataLocale]]'", "]", "=", "foundLocale", ";", "var", "supportedExtension", "=", "'-u'", ",", "i", "=", "0", ",", "len", "=", "relevantExtensionKeys", ".", "length", ";", "while", "(", "i", "<", "len", ")", "{", "var", "key", "=", "relevantExtensionKeys", "[", "i", "]", ",", "foundLocaleData", "=", "localeData", "[", "foundLocale", "]", ",", "keyLocaleData", "=", "foundLocaleData", "[", "key", "]", ",", "value", "=", "keyLocaleData", "[", "'0'", "]", ",", "supportedExtensionAddition", "=", "''", ",", "indexOf", "=", "$$core$$arrIndexOf", ";", "if", "(", "extensionSubtags", "!==", "undefined", ")", "{", "var", "keyPos", "=", "indexOf", ".", "call", "(", "extensionSubtags", ",", "key", ")", ";", "if", "(", "keyPos", "!==", "-", "1", ")", "{", "if", "(", "keyPos", "+", "1", "<", "extensionSubtagsLength", "&&", "extensionSubtags", "[", "keyPos", "+", "1", "]", ".", "length", ">", "2", ")", "{", "var", "requestedValue", "=", "extensionSubtags", "[", "keyPos", "+", "1", "]", ",", "valuePos", "=", "indexOf", ".", "call", "(", "keyLocaleData", ",", "requestedValue", ")", ";", "if", "(", "valuePos", "!==", "-", "1", ")", "var", "value", "=", "requestedValue", ",", "supportedExtensionAddition", "=", "'-'", "+", "key", "+", "'-'", "+", "value", ";", "}", "else", "{", "var", "valuePos", "=", "indexOf", "(", "keyLocaleData", ",", "'true'", ")", ";", "if", "(", "valuePos", "!==", "-", "1", ")", "var", "value", "=", "'true'", ";", "}", "}", "}", "if", "(", "$$core$$hop", ".", "call", "(", "options", ",", "'[['", "+", "key", "+", "']]'", ")", ")", "{", "var", "optionsValue", "=", "options", "[", "'[['", "+", "key", "+", "']]'", "]", ";", "if", "(", "indexOf", ".", "call", "(", "keyLocaleData", ",", "optionsValue", ")", "!==", "-", "1", ")", "{", "if", "(", "optionsValue", "!==", "value", ")", "{", "value", "=", "optionsValue", ";", "supportedExtensionAddition", "=", "''", ";", "}", "}", "}", "result", "[", "'[['", "+", "key", "+", "']]'", "]", "=", "value", ";", "supportedExtension", "+=", "supportedExtensionAddition", ";", "i", "++", ";", "}", "if", "(", "supportedExtension", ".", "length", ">", "2", ")", "{", "var", "preExtension", "=", "foundLocale", ".", "substring", "(", "0", ",", "extensionIndex", ")", ",", "postExtension", "=", "foundLocale", ".", "substring", "(", "extensionIndex", ")", ",", "foundLocale", "=", "preExtension", "+", "supportedExtension", "+", "postExtension", ";", "}", "result", "[", "'[[locale]]'", "]", "=", "foundLocale", ";", "return", "result", ";", "}" ]

[ "The", "ResolveLocale", "abstract", "operation", "compares", "a", "BCP", "47", "language", "priority", "list", "requestedLocales", "against", "the", "locales", "in", "availableLocales", "and", "determines", "the", "best", "available", "language", "to", "meet", "the", "request", ".", "availableLocales", "and", "requestedLocales", "must", "be", "provided", "as", "List", "values", "options", "as", "a", "Record", "." ]

[ "function", "$$core$$GetOption", "(", "options", ",", "property", ",", "type", ",", "values", ",", "fallback", ")", "{", "var", "value", "=", "options", "[", "property", "]", ";", "if", "(", "value", "!==", "undefined", ")", "{", "value", "=", "type", "===", "'boolean'", "?", "Boolean", "(", "value", ")", ":", "(", "type", "===", "'string'", "?", "String", "(", "value", ")", ":", "value", ")", ";", "if", "(", "values", "!==", "undefined", ")", "{", "if", "(", "$$core$$arrIndexOf", ".", "call", "(", "values", ",", "value", ")", "===", "-", "1", ")", "throw", "new", "RangeError", "(", "\"'\"", "+", "value", "+", "\"' is not an allowed value for `\"", "+", "property", "+", "'`'", ")", ";", "}", "return", "value", ";", "}", "return", "fallback", ";", "}" ]

[ "The", "GetOption", "abstract", "operation", "extracts", "the", "value", "of", "the", "property", "named", "property", "from", "the", "provided", "options", "object", "converts", "it", "to", "the", "required", "type", "checks", "whether", "it", "is", "one", "of", "a", "List", "of", "allowed", "values", "and", "fills", "in", "a", "fallback", "value", "if", "necessary", "." ]

[ "function", "$$core$$GetNumberOption", "(", "options", ",", "property", ",", "minimum", ",", "maximum", ",", "fallback", ")", "{", "var", "value", "=", "options", "[", "property", "]", ";", "if", "(", "value", "!==", "undefined", ")", "{", "value", "=", "Number", "(", "value", ")", ";", "if", "(", "isNaN", "(", "value", ")", "||", "value", "<", "minimum", "||", "value", ">", "maximum", ")", "throw", "new", "RangeError", "(", "'Value is not a number or outside accepted range'", ")", ";", "return", "Math", ".", "floor", "(", "value", ")", ";", "}", "return", "fallback", ";", "}" ]

[ "The", "GetNumberOption", "abstract", "operation", "extracts", "a", "property", "value", "from", "the", "provided", "options", "object", "converts", "it", "to", "a", "Number", "value", "checks", "whether", "it", "is", "in", "the", "allowed", "range", "and", "fills", "in", "a", "fallback", "value", "if", "necessary", "." ]

[ "function", "$$core$$calculateScore", "(", "options", ",", "formats", ",", "bestFit", ")", "{", "var", "diffDataTypePenalty", "=", "8", ",", "removalPenalty", "=", "120", ",", "additionPenalty", "=", "20", ",", "longLessPenalty", "=", "8", ",", "longMorePenalty", "=", "6", ",", "shortLessPenalty", "=", "6", ",", "shortMorePenalty", "=", "3", ",", "bestScore", "=", "-", "Infinity", ",", "bestFormat", ",", "i", "=", "0", ",", "len", "=", "formats", ".", "length", ";", "while", "(", "i", "<", "len", ")", "{", "var", "format", "=", "formats", "[", "i", "]", ",", "score", "=", "0", ";", "for", "(", "var", "property", "in", "$$core$$dateTimeComponents", ")", "{", "if", "(", "!", "$$core$$hop", ".", "call", "(", "$$core$$dateTimeComponents", ",", "property", ")", ")", "continue", ";", "var", "optionsProp", "=", "options", "[", "'[['", "+", "property", "+", "']]'", "]", ",", "formatProp", "=", "$$core$$hop", ".", "call", "(", "format", ",", "property", ")", "?", "format", "[", "property", "]", ":", "undefined", ";", "if", "(", "optionsProp", "===", "undefined", "&&", "formatProp", "!==", "undefined", ")", "score", "-=", "additionPenalty", ";", "else", "if", "(", "optionsProp", "!==", "undefined", "&&", "formatProp", "===", "undefined", ")", "score", "-=", "removalPenalty", ";", "else", "{", "var", "values", "=", "[", "'2-digit'", ",", "'numeric'", ",", "'narrow'", ",", "'short'", ",", "'long'", "]", ",", "optionsPropIndex", "=", "$$core$$arrIndexOf", ".", "call", "(", "values", ",", "optionsProp", ")", ",", "formatPropIndex", "=", "$$core$$arrIndexOf", ".", "call", "(", "values", ",", "formatProp", ")", ",", "delta", "=", "Math", ".", "max", "(", "Math", ".", "min", "(", "formatPropIndex", "-", "optionsPropIndex", ",", "2", ")", ",", "-", "2", ")", ";", "if", "(", "bestFit", "&&", "(", "(", "(", "optionsProp", "===", "'numeric'", "||", "optionsProp", "===", "'2-digit'", ")", "&&", "(", "formatProp", "!==", "'numeric'", "&&", "formatProp", "!==", "'2-digit'", ")", "||", "(", "optionsProp", "!==", "'numeric'", "&&", "optionsProp", "!==", "'2-digit'", ")", "&&", "(", "formatProp", "===", "'2-digit'", "||", "formatProp", "===", "'numeric'", ")", ")", ")", ")", "score", "-=", "diffDataTypePenalty", ";", "if", "(", "delta", "===", "2", ")", "score", "-=", "longMorePenalty", ";", "else", "if", "(", "delta", "===", "1", ")", "score", "-=", "shortMorePenalty", ";", "else", "if", "(", "delta", "===", "-", "1", ")", "score", "-=", "shortLessPenalty", ";", "else", "if", "(", "delta", "===", "-", "2", ")", "score", "-=", "longLessPenalty", ";", "}", "}", "if", "(", "score", ">", "bestScore", ")", "{", "bestScore", "=", "score", ";", "bestFormat", "=", "format", ";", "}", "i", "++", ";", "}", "return", "bestFormat", ";", "}" ]

[ "Calculates", "score", "for", "BestFitFormatMatcher", "and", "BasicFormatMatcher", ".", "Abstracted", "from", "BasicFormatMatcher", "section", "." ]

[ "function", "$$core$$resolveDateString", "(", "data", ",", "ca", ",", "component", ",", "width", ",", "key", ")", "{", "var", "obj", "=", "data", "[", "ca", "]", "&&", "data", "[", "ca", "]", "[", "component", "]", "?", "data", "[", "ca", "]", "[", "component", "]", ":", "data", ".", "gregory", "[", "component", "]", ",", "alts", "=", "{", "narrow", ":", "[", "'short'", ",", "'long'", "]", ",", "short", ":", "[", "'long'", ",", "'narrow'", "]", ",", "long", ":", "[", "'short'", ",", "'narrow'", "]", "}", ",", "resolved", "=", "$$core$$hop", ".", "call", "(", "obj", ",", "width", ")", "?", "obj", "[", "width", "]", ":", "$$core$$hop", ".", "call", "(", "obj", ",", "alts", "[", "width", "]", "[", "0", "]", ")", "?", "obj", "[", "alts", "[", "width", "]", "[", "0", "]", "]", ":", "obj", "[", "alts", "[", "width", "]", "[", "1", "]", "]", ";", "return", "key", "!=", "null", "?", "resolved", "[", "key", "]", ":", "resolved", ";", "}" ]

[ "Returns", "a", "string", "for", "a", "date", "component", "resolved", "using", "multiple", "inheritance", "as", "specified", "as", "specified", "in", "the", "Unicode", "Technical", "Standard", "35", "." ]

[ "function", "$$core$$createRegExpRestore", "(", ")", "{", "var", "esc", "=", "/", "[.?*+^$[\\]\\\\(){}|-]", "/", "g", ",", "lm", "=", "RegExp", ".", "lastMatch", "||", "''", ",", "ml", "=", "RegExp", ".", "multiline", "?", "'m'", ":", "''", ",", "ret", "=", "{", "input", ":", "RegExp", ".", "input", "}", ",", "reg", "=", "new", "$$core$$List", "(", ")", ",", "has", "=", "false", ",", "cap", "=", "{", "}", ";", "for", "(", "var", "i", "=", "1", ";", "i", "<=", "9", ";", "i", "++", ")", "has", "=", "(", "cap", "[", "'$'", "+", "i", "]", "=", "RegExp", "[", "'$'", "+", "i", "]", ")", "||", "has", ";", "lm", "=", "lm", ".", "replace", "(", "esc", ",", "'\\\\$&'", ")", ";", "\\\\", "if", "(", "has", ")", "{", "for", "(", "var", "i", "=", "1", ";", "i", "<=", "9", ";", "i", "++", ")", "{", "var", "m", "=", "cap", "[", "'$'", "+", "i", "]", ";", "if", "(", "!", "m", ")", "lm", "=", "'()'", "+", "lm", ";", "else", "{", "m", "=", "m", ".", "replace", "(", "esc", ",", "'\\\\$&'", ")", ";", "\\\\", "}", "lm", "=", "lm", ".", "replace", "(", "m", ",", "'('", "+", "m", "+", "')'", ")", ";", "$$core$$arrPush", ".", "call", "(", "reg", ",", "lm", ".", "slice", "(", "0", ",", "lm", ".", "indexOf", "(", "'('", ")", "+", "1", ")", ")", ";", "}", "}", "lm", "=", "lm", ".", "slice", "(", "lm", ".", "indexOf", "(", "'('", ")", "+", "1", ")", ";", "}" ]

[ "Constructs", "a", "regular", "expression", "to", "restore", "tainted", "RegExp", "properties" ]

[ "function", "$$core$$toLatinUpperCase", "(", "str", ")", "{", "var", "i", "=", "str", ".", "length", ";", "while", "(", "i", "--", ")", "{", "var", "ch", "=", "str", ".", "charAt", "(", "i", ")", ";", "if", "(", "ch", ">=", "\"a\"", "&&", "ch", "<=", "\"z\"", ")", "str", "=", "str", ".", "slice", "(", "0", ",", "i", ")", "+", "ch", ".", "toUpperCase", "(", ")", "+", "str", ".", "slice", "(", "i", "+", "1", ")", ";", "}", "return", "str", ";", "}" ]

[ "Convert", "only", "a", "-", "z", "to", "uppercase", "as", "per", "section", "6", ".", "1", "of", "the", "spec" ]

[ "function", "PersistInNode", "(", "n", ")", "{", "RED", ".", "nodes", ".", "createNode", "(", "this", ",", "n", ")", ";", "var", "node", "=", "this", ";", "node", ".", "name", "=", "n", ".", "name", ";", "node", ".", "storageNode", "=", "RED", ".", "nodes", ".", "getNode", "(", "n", ".", "storageNode", ")", ";", "node", ".", "on", "(", "\"input\"", ",", "function", "(", "msg", ")", "{", "node", ".", "storageNode", ".", "store", "(", "node", ".", "name", ",", "msg", ")", ";", "}", ")", ";", "}" ]

[ "Record", "data", "to", "persist" ]

[ "function", "PersistOutNode", "(", "n", ")", "{", "RED", ".", "nodes", ".", "createNode", "(", "this", ",", "n", ")", ";", "var", "node", "=", "this", ";", "node", ".", "name", "=", "n", ".", "name", ";", "node", ".", "storageNode", "=", "RED", ".", "nodes", ".", "getNode", "(", "n", ".", "storageNode", ")", ";", "node", ".", "restore", "=", "function", "(", ")", "{", "var", "msg", "=", "node", ".", "storageNode", ".", "getMessage", "(", "node", ".", "name", ")", ";", "node", ".", "send", "(", "msg", ")", ";", "}", ";", "RED", ".", "events", ".", "on", "(", "\"nodes-started\"", ",", "node", ".", "restore", ")", ";", "node", ".", "on", "(", "\"input\"", ",", "function", "(", "msg", ")", "{", "node", ".", "restore", "(", ")", ";", "}", ")", ";", "node", ".", "on", "(", "'close'", ",", "function", "(", "removed", ",", "done", ")", "{", "RED", ".", "events", ".", "removeListener", "(", "\"nodes-started\"", ",", "node", ".", "restore", ")", ";", "done", "(", ")", ";", "}", ")", ";", "}" ]

[ "Replay", "persisted", "data" ]

[ "function", "isMethodCall", "(", "node", ")", "{", "var", "nodeParentType", "=", "node", ".", "parent", ".", "type", ",", "nodeParentParentParentType", "=", "node", ".", "parent", ".", "parent", ".", "parent", ".", "type", ";", "if", "(", "nodeParentType", "===", "\"CallExpression\"", "&&", "nodeParentParentParentType", "===", "\"BlockStatement\"", "&&", "!", "variable", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Checks", "for", "object", "literal", "method" ]

[ "function", "broadcast", "(", "subscriptions", ",", "type", ")", "{", "return", "value", "=>", "{", "subscriptions", ".", "forEach", "(", "s", "=>", "{", "if", "(", "typeof", "s", ".", "emit", "[", "type", "]", "===", "'function'", ")", "{", "s", ".", "emit", "[", "type", "]", "(", "value", ")", "}", "}", ")", "}", "}" ]

[ "Creates", "a", "callback", "function", "that", "emits", "values", "to", "a", "list", "of", "subscribers", "." ]

[ "function", "(", ")", "{", "var", "outputPropertyName", ",", "callback", ",", "inputPropertyNames", ",", "inputs", ",", "output", ";", "if", "(", "arguments", ".", "length", "===", "0", ")", "{", "return", "configurationProperty", "(", ")", ";", "}", "else", "if", "(", "arguments", ".", "length", "===", "1", ")", "{", "if", "(", "typeof", "arguments", "[", "0", "]", "===", "\"object\"", ")", "{", "return", "setConfiguration", "(", "arguments", "[", "0", "]", ")", ";", "}", "else", "{", "return", "addProperty", "(", "arguments", "[", "0", "]", ")", ";", "}", "}", "else", "if", "(", "arguments", ".", "length", "===", "2", ")", "{", "if", "(", "typeof", "arguments", "[", "0", "]", "===", "\"function\"", ")", "{", "inputPropertyNames", "=", "arguments", "[", "1", "]", ";", "callback", "=", "arguments", "[", "0", "]", ";", "outputPropertyName", "=", "undefined", ";", "}", "else", "{", "return", "addProperty", "(", "arguments", "[", "0", "]", ",", "arguments", "[", "1", "]", ")", ";", "}", "}", "else", "if", "(", "arguments", ".", "length", "===", "3", ")", "{", "outputPropertyName", "=", "arguments", "[", "0", "]", ";", "callback", "=", "arguments", "[", "1", "]", ";", "inputPropertyNames", "=", "arguments", "[", "2", "]", ";", "}", "if", "(", "typeof", "inputPropertyNames", "===", "\"string\"", ")", "{", "inputPropertyNames", "=", "inputPropertyNames", ".", "split", "(", "\",\"", ")", ".", "map", "(", "invoke", "(", "\"trim\"", ")", ")", ";", "}", "inputs", "=", "inputPropertyNames", ".", "map", "(", "function", "(", "propertyName", ")", "{", "var", "property", "=", "getProperty", "(", "propertyName", ")", ";", "if", "(", "typeof", "property", "===", "\"undefined\"", ")", "{", "throw", "new", "Error", "(", "[", "\"The property \\\"\"", ",", "\\\"", ",", "propertyName", ",", "\"\\\" was referenced as a dependency for a reactive function before it was defined. \"", "]", ".", "\\\"", "\"Please define each property first before referencing them in reactive functions.\"", ")", ";", "}", "join", "}", ")", ";", "(", "\"\"", ")", "return", "property", ";", "if", "(", "outputPropertyName", ")", "{", "addProperty", "(", "outputPropertyName", ")", ";", "output", "=", "model", "[", "outputPropertyName", "]", ";", "}", "var", "isAsynchronous", "=", "(", "callback", ".", "length", "===", "inputs", ".", "length", "+", "1", ")", ";", "}" ]

[ "The", "model", "instance", "object", ".", "This", "is", "the", "value", "returned", "from", "the", "constructor", "." ]

[ "function", "addProperty", "(", "propertyName", ",", "defaultValue", ")", "{", "if", "(", "model", "[", "propertyName", "]", ")", "{", "throw", "new", "Error", "(", "\"The property \\\"\"", "+", "\\\"", "+", "propertyName", ")", ";", "}", "\"\\\" is already defined.\"", "\\\"", "var", "property", "=", "ReactiveProperty", "(", "defaultValue", ")", ";", "property", ".", "propertyName", "=", "propertyName", ";", "model", "[", "propertyName", "]", "=", "property", ";", "}" ]

[ "Adds", "a", "property", "to", "the", "model", "that", "is", "not", "exposed", "meaning", "that", "it", "is", "not", "included", "in", "the", "configuration", "object", "." ]

[ "function", "expose", "(", ")", "{", "if", "(", "!", "lastPropertyAdded", ")", "{", "throw", "Error", "(", "\"Expose() was called without first adding a property.\"", ")", ";", "}", "var", "propertyName", "=", "lastPropertyAdded", ";", "if", "(", "!", "exposedProperties", ")", "{", "exposedProperties", "=", "[", "]", ";", "}", "exposedProperties", ".", "push", "(", "propertyName", ")", ";", "if", "(", "configurationReactiveFunction", ")", "{", "configurationReactiveFunction", ".", "destroy", "(", ")", ";", "}", "var", "inputPropertyNames", "=", "exposedProperties", ";", "configurationReactiveFunction", "=", "ReactiveFunction", "(", "{", "inputs", ":", "inputPropertyNames", ".", "map", "(", "getProperty", ")", ",", "output", ":", "configurationProperty", ",", "callback", ":", "function", "(", ")", "{", "var", "configuration", "=", "{", "}", ";", "inputPropertyNames", ".", "forEach", "(", "function", "(", "propertyName", ")", "{", "var", "property", "=", "getProperty", "(", "propertyName", ")", ";", "if", "(", "property", "(", ")", "!==", "property", ".", "default", "(", ")", ")", "{", "configuration", "[", "propertyName", "]", "=", "property", "(", ")", ";", "}", "}", ")", ";", "return", "configuration", ";", "}", "}", ")", ";", "return", "model", ";", "}" ]

[ "Exposes", "the", "last", "added", "property", "to", "the", "configuration", "." ]

[ "function", "destroy", "(", ")", "{", "reactiveFunctions", ".", "forEach", "(", "invoke", "(", "\"destroy\"", ")", ")", ";", "if", "(", "configurationReactiveFunction", ")", "{", "configurationReactiveFunction", ".", "destroy", "(", ")", ";", "}", "Object", ".", "keys", "(", "model", ")", ".", "forEach", "(", "function", "(", "propertyName", ")", "{", "var", "property", "=", "model", "[", "propertyName", "]", ";", "if", "(", "property", ".", "destroy", ")", "{", "property", ".", "destroy", "(", ")", ";", "}", "}", ")", ";", "reactiveFunctions", "=", "undefined", ";", "configurationReactiveFunction", "=", "undefined", ";", "}" ]

[ "Destroys", "all", "reactive", "functions", "and", "properties", "that", "have", "been", "added", "to", "the", "model", "." ]

[ "function", "tiler", "(", "root", ",", "options", ")", "{", "this", ".", "root", "=", "root", ";", "options", "=", "options", "||", "{", "}", ";", "options", ".", "packSize", "=", "options", ".", "packSize", "||", "128", ";", "if", "(", "!", "options", ".", "storageFormat", ")", "{", "options", ".", "storageFormat", "=", "guessStorageFormat", "(", "root", ")", ";", "}", "this", ".", "options", "=", "options", ";", "}" ]

[ "Constructor", "for", "the", "tiler", "-", "arcgis", "-", "bundle" ]

[ "function", "(", "id", ",", "type", ")", "{", "if", "(", "this", ".", "state", ".", "sourcePageID", "!==", "id", ")", "{", "var", "selectedPage", ";", "this", ".", "state", ".", "pages", ".", "forEach", "(", "function", "(", "page", ")", "{", "if", "(", "parseInt", "(", "page", ".", "id", ",", "10", ")", "===", "parseInt", "(", "id", ",", "10", ")", ")", "{", "selectedPage", "=", "page", ";", "}", "}", ")", ";", "if", "(", "!", "selectedPage", ")", "{", "console", ".", "warn", "(", "'Page not found.'", ")", ";", "return", ";", "}", "var", "currentZoom", "=", "this", ".", "state", ".", "matrix", "[", "0", "]", ";", "var", "{", "x", ",", "y", "}", "=", "this", ".", "cartesian", ".", "getFocusTransform", "(", "selectedPage", ".", "coords", ",", "this", ".", "state", ".", "matrix", "[", "0", "]", ")", ";", "var", "newState", "=", "{", "matrix", ":", "[", "currentZoom", ",", "0", ",", "0", ",", "currentZoom", ",", "x", ",", "y", "]", "}", ";", "if", "(", "type", "===", "'selected'", ")", "{", "newState", ".", "selectedEl", "=", "id", ";", "}", "else", "if", "(", "type", "===", "'source'", ")", "{", "newState", ".", "sourcePageID", "=", "id", ";", "}", "this", ".", "setState", "(", "newState", ")", ";", "}", "}" ]

[ "Highlight", "a", "page", "in", "the", "UI", "and", "move", "camera", "to", "center", "it" ]

[ "function", "appendDirEnd", "(", "str", ",", "struct", ")", "{", "if", "(", "!", "struct", ".", "block", ")", "{", "return", "str", ";", "}", "const", "[", "rightSpace", "]", "=", "rightWSRgxp", ".", "exec", "(", "str", ")", ";", "str", "=", "str", ".", "replace", "(", "rightPartRgxp", ",", "''", ")", ";", "const", "s", "=", "alb", "+", "lb", ",", "e", "=", "rb", ";", "let", "tmp", ";", "if", "(", "needSpace", ")", "{", "tmp", "=", "`", "${", "struct", ".", "trim", ".", "right", "?", "''", ":", "eol", "}", "${", "endDirInit", "?", "''", ":", "`", "${", "s", "}", "${", "e", "}", "`", "}", "${", "struct", ".", "trim", ".", "right", "?", "eol", ":", "''", "}", "`", ";", "}", "else", "{", "tmp", "=", "eol", "+", "struct", ".", "space", ".", "slice", "(", "1", ")", ";", "}", "endDirInit", "=", "true", ";", "str", "+=", "`", "${", "tmp", "}", "${", "struct", ".", "adv", "+", "lb", "}", "${", "e", "}", "${", "s", "}", "${", "e", "}", "`", ";", "if", "(", "rightSpace", "&&", "needSpace", ")", "{", "str", "+=", "`", "${", "s", "}", "${", "rb", "}", "`", ";", "}", "return", "str", "+", "rightSpace", ";", "}" ]

[ "Appends", "the", "directive", "end", "for", "a", "resulting", "string", "and", "returns", "a", "new", "string" ]

[ "function", "(", ")", "{", "var", "fonts", "=", "[", "\"Roboto\"", ",", "\"Bitter\"", ",", "\"Pacifico\"", "]", ";", "var", "options", "=", "fonts", ".", "map", "(", "name", "=>", "{", "return", "<", "option", "key", "=", "{", "name", "}", "value", "=", "{", "name", "}", ">", "{", "name", "}", "<", "/", "option", ">", ";", "}", ")", ";", "return", "<", "select", "className", "=", "\"select\"", "valueLink", "=", "{", "this", ".", "linkState", "(", "'fontFamily'", ")", "}", ">", "{", "options", "}", "<", "/", "select", ">", ";", "}" ]

[ "Generate", "the", "dropdown", "selector", "for", "fonts", "with", "each", "font", "option", "styled", "in", "the", "appropriate", "font", "." ]

[ "function", "callback", "(", "fn", ",", "context", ",", "event", ")", "{", "event", ".", "target", "=", "context", ";", "(", "typeof", "context", "[", "fn", "]", "===", "\"function\"", ")", "&&", "context", "[", "fn", "]", ".", "apply", "(", "context", ",", "[", "event", "]", ")", ";", "}" ]

[ "A", "utility", "method", "to", "callback", "onsuccess", "onerror", "etc", "as", "soon", "as", "the", "calling", "function", "s", "context", "is", "over" ]

[ "function", "polyfill", "(", ")", "{", "if", "(", "navigator", ".", "userAgent", ".", "match", "(", "/", "MSIE", "/", ")", "||", "navigator", ".", "userAgent", ".", "match", "(", "/", "Trident", "/", ")", "||", "navigator", ".", "userAgent", ".", "match", "(", "/", "Edge", "/", ")", ")", "{", "compoundKeyPolyfill", "(", ")", ";", "}", "}" ]

[ "Polyfills", "missing", "features", "in", "the", "browser", "s", "native", "IndexedDB", "implementation", ".", "This", "is", "used", "for", "browsers", "that", "DON", "T", "support", "WebSQL", "but", "DO", "support", "IndexedDB" ]

[ "function", "readBlobAsDataURL", "(", "blob", ",", "path", ")", "{", "var", "reader", "=", "new", "FileReader", "(", ")", ";", "reader", ".", "onloadend", "=", "function", "(", "loadedEvent", ")", "{", "var", "dataURL", "=", "loadedEvent", ".", "target", ".", "result", ";", "var", "blobtype", "=", "'Blob'", ";", "if", "(", "blob", "instanceof", "File", ")", "{", "}", "updateEncodedBlob", "(", "dataURL", ",", "path", ",", "blobtype", ")", ";", "}", ";", "reader", ".", "readAsDataURL", "(", "blob", ")", ";", "}" ]

[ "Convert", "a", "blob", "to", "a", "data", "URL", "." ]

[ "function", "updateEncodedBlob", "(", "dataURL", ",", "path", ",", "blobtype", ")", "{", "var", "encoded", "=", "queuedObjects", ".", "indexOf", "(", "path", ")", ";", "path", "=", "path", ".", "replace", "(", "'$'", ",", "'derezObj'", ")", ";", "eval", "(", "path", "+", "'.$enc=\"'", "+", "dataURL", "+", "'\"'", ")", ";", "eval", "(", "path", "+", "'.$type=\"'", "+", "blobtype", "+", "'\"'", ")", ";", "queuedObjects", ".", "splice", "(", "encoded", ",", "1", ")", ";", "checkForCompletion", "(", ")", ";", "}" ]

[ "Async", "handler", "to", "update", "a", "blob", "object", "to", "a", "data", "URL", "for", "encoding", "." ]

[ "function", "dataURLToBlob", "(", "dataURL", ")", "{", "var", "BASE64_MARKER", "=", "';base64,'", ",", "contentType", ",", "parts", ",", "raw", ";", "if", "(", "dataURL", ".", "indexOf", "(", "BASE64_MARKER", ")", "===", "-", "1", ")", "{", "parts", "=", "dataURL", ".", "split", "(", "','", ")", ";", "contentType", "=", "parts", "[", "0", "]", ".", "split", "(", "':'", ")", "[", "1", "]", ";", "raw", "=", "parts", "[", "1", "]", ";", "return", "new", "Blob", "(", "[", "raw", "]", ",", "{", "type", ":", "contentType", "}", ")", ";", "}", "parts", "=", "dataURL", ".", "split", "(", "BASE64_MARKER", ")", ";", "contentType", "=", "parts", "[", "0", "]", ".", "split", "(", "':'", ")", "[", "1", "]", ";", "raw", "=", "window", ".", "atob", "(", "parts", "[", "1", "]", ")", ";", "var", "rawLength", "=", "raw", ".", "length", ";", "var", "uInt8Array", "=", "new", "Uint8Array", "(", "rawLength", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "rawLength", ";", "++", "i", ")", "{", "uInt8Array", "[", "i", "]", "=", "raw", ".", "charCodeAt", "(", "i", ")", ";", "}", "return", "new", "Blob", "(", "[", "uInt8Array", ".", "buffer", "]", ",", "{", "type", ":", "contentType", "}", ")", ";", "}" ]

[ "Converts", "the", "specified", "data", "URL", "to", "a", "Blob", "object" ]

[ "function", "(", "key", ")", "{", "var", "key32", "=", "Math", ".", "abs", "(", "key", ")", ".", "toString", "(", "32", ")", ";", "var", "decimalIndex", "=", "key32", ".", "indexOf", "(", "\".\"", ")", ";", "key32", "=", "(", "decimalIndex", "!==", "-", "1", ")", "?", "key32", ".", "replace", "(", "\".\"", ",", "\"\"", ")", ":", "key32", ";", "var", "significantDigitIndex", "=", "key32", ".", "search", "(", "/", "[^0]", "/", ")", ";", "key32", "=", "key32", ".", "slice", "(", "significantDigitIndex", ")", ";", "var", "sign", ",", "exponent", "=", "zeros", "(", "2", ")", ",", "mantissa", "=", "zeros", "(", "11", ")", ";", "if", "(", "isFinite", "(", "key", ")", ")", "{", "if", "(", "key", "<", "0", ")", "{", "if", "(", "key", ">", "-", "1", ")", "{", "sign", "=", "signValues", ".", "indexOf", "(", "\"smallNegative\"", ")", ";", "exponent", "=", "padBase32Exponent", "(", "significantDigitIndex", ")", ";", "mantissa", "=", "flipBase32", "(", "padBase32Mantissa", "(", "key32", ")", ")", ";", "}", "else", "{", "sign", "=", "signValues", ".", "indexOf", "(", "\"bigNegative\"", ")", ";", "exponent", "=", "flipBase32", "(", "padBase32Exponent", "(", "(", "decimalIndex", "!==", "-", "1", ")", "?", "decimalIndex", ":", "key32", ".", "length", ")", ")", ";", "mantissa", "=", "flipBase32", "(", "padBase32Mantissa", "(", "key32", ")", ")", ";", "}", "}", "else", "{", "if", "(", "key", "<", "1", ")", "{", "sign", "=", "signValues", ".", "indexOf", "(", "\"smallPositive\"", ")", ";", "exponent", "=", "flipBase32", "(", "padBase32Exponent", "(", "significantDigitIndex", ")", ")", ";", "mantissa", "=", "padBase32Mantissa", "(", "key32", ")", ";", "}", "else", "{", "sign", "=", "signValues", ".", "indexOf", "(", "\"bigPositive\"", ")", ";", "exponent", "=", "padBase32Exponent", "(", "(", "decimalIndex", "!==", "-", "1", ")", "?", "decimalIndex", ":", "key32", ".", "length", ")", ";", "mantissa", "=", "padBase32Mantissa", "(", "key32", ")", ";", "}", "}", "}", "else", "{", "sign", "=", "signValues", ".", "indexOf", "(", "key", ">", "0", "?", "\"positiveInfinity\"", ":", "\"negativeInfinity\"", ")", ";", "}", "return", "collations", ".", "indexOf", "(", "\"number\"", ")", "+", "\"-\"", "+", "sign", "+", "exponent", "+", "mantissa", ";", "}" ]

[ "The", "encode", "step", "checks", "for", "six", "numeric", "cases", "and", "generates", "14", "-", "digit", "encoded", "sign", "-", "exponent", "-", "mantissa", "strings", "." ]

[ "function", "(", "key", ")", "{", "var", "sign", "=", "+", "key", ".", "substr", "(", "2", ",", "1", ")", ";", "var", "exponent", "=", "key", ".", "substr", "(", "3", ",", "2", ")", ";", "var", "mantissa", "=", "key", ".", "substr", "(", "5", ",", "11", ")", ";", "switch", "(", "signValues", "[", "sign", "]", ")", "{", "case", "\"negativeInfinity\"", ":", "return", "-", "Infinity", ";", "case", "\"positiveInfinity\"", ":", "return", "Infinity", ";", "case", "\"bigPositive\"", ":", "return", "pow32", "(", "mantissa", ",", "exponent", ")", ";", "case", "\"smallPositive\"", ":", "exponent", "=", "negate", "(", "flipBase32", "(", "exponent", ")", ")", ";", "return", "pow32", "(", "mantissa", ",", "exponent", ")", ";", "case", "\"smallNegative\"", ":", "exponent", "=", "negate", "(", "exponent", ")", ";", "mantissa", "=", "flipBase32", "(", "mantissa", ")", ";", "return", "-", "pow32", "(", "mantissa", ",", "exponent", ")", ";", "case", "\"bigNegative\"", ":", "exponent", "=", "flipBase32", "(", "exponent", ")", ";", "mantissa", "=", "flipBase32", "(", "mantissa", ")", ";", "return", "-", "pow32", "(", "mantissa", ",", "exponent", ")", ";", "default", ":", "throw", "new", "Error", "(", "\"Invalid number.\"", ")", ";", "}", "}" ]

[ "The", "decode", "step", "must", "interpret", "the", "sign", "reflip", "values", "encoded", "as", "the", "32", "s", "complements", "apply", "signs", "to", "the", "exponent", "and", "mantissa", "do", "the", "base", "-", "32", "power", "operation", "and", "return", "the", "original", "JavaScript", "number", "values", "." ]

[ "function", "flipBase32", "(", "encoded", ")", "{", "var", "flipped", "=", "\"\"", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "encoded", ".", "length", ";", "i", "++", ")", "{", "flipped", "+=", "(", "31", "-", "parseInt", "(", "encoded", "[", "i", "]", ",", "32", ")", ")", ".", "toString", "(", "32", ")", ";", "}", "return", "flipped", ";", "}" ]

[ "Flips", "each", "digit", "of", "a", "base", "-", "32", "encoded", "string", "." ]

[ "function", "validate", "(", "key", ")", "{", "var", "type", "=", "getType", "(", "key", ")", ";", "if", "(", "type", "===", "\"array\"", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "key", ".", "length", ";", "i", "++", ")", "{", "validate", "(", "key", "[", "i", "]", ")", ";", "}", "}", "else", "if", "(", "!", "types", "[", "type", "]", "||", "(", "type", "!==", "\"string\"", "&&", "isNaN", "(", "key", ")", ")", ")", "{", "throw", "idbModules", ".", "util", ".", "createDOMException", "(", "\"DataError\"", ",", "\"Not a valid key\"", ")", ";", "}", "}" ]

[ "Keys", "must", "be", "strings", "numbers", "Dates", "or", "Arrays" ]

[ "function", "getValue", "(", "source", ",", "keyPath", ")", "{", "try", "{", "if", "(", "keyPath", "instanceof", "Array", ")", "{", "var", "arrayValue", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "keyPath", ".", "length", ";", "i", "++", ")", "{", "arrayValue", ".", "push", "(", "eval", "(", "\"source.\"", "+", "keyPath", "[", "i", "]", ")", ")", ";", "}", "return", "arrayValue", ";", "}", "else", "{", "return", "eval", "(", "\"source.\"", "+", "keyPath", ")", ";", "}", "}", "catch", "(", "e", ")", "{", "return", "undefined", ";", "}", "}" ]

[ "Returns", "the", "value", "of", "an", "inline", "key" ]

[ "function", "setValue", "(", "source", ",", "keyPath", ",", "value", ")", "{", "var", "props", "=", "keyPath", ".", "split", "(", "'.'", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "props", ".", "length", "-", "1", ";", "i", "++", ")", "{", "var", "prop", "=", "props", "[", "i", "]", ";", "source", "=", "source", "[", "prop", "]", "=", "source", "[", "prop", "]", "||", "{", "}", ";", "}", "source", "[", "props", "[", "props", ".", "length", "-", "1", "]", "]", "=", "value", ";", "}" ]

[ "Sets", "the", "inline", "key", "value" ]

[ "function", "isMultiEntryMatch", "(", "encodedEntry", ",", "encodedKey", ")", "{", "var", "keyType", "=", "collations", "[", "encodedKey", ".", "substring", "(", "0", ",", "1", ")", "]", ";", "if", "(", "keyType", "===", "\"array\"", ")", "{", "return", "encodedKey", ".", "indexOf", "(", "encodedEntry", ")", ">", "1", ";", "}", "else", "{", "return", "encodedKey", "===", "encodedEntry", ";", "}", "}" ]

[ "Determines", "whether", "an", "index", "entry", "matches", "a", "multi", "-", "entry", "key", "value", "." ]

[ "function", "createNativeEvent", "(", "type", ",", "debug", ")", "{", "var", "event", "=", "new", "Event", "(", "type", ")", ";", "event", ".", "debug", "=", "debug", ";", "Object", ".", "defineProperty", "(", "event", ",", "'target'", ",", "{", "writable", ":", "true", "}", ")", ";", "return", "event", ";", "}" ]

[ "Creates", "a", "native", "Event", "object", "for", "browsers", "that", "support", "it" ]

[ "function", "ShimEvent", "(", "type", ",", "debug", ")", "{", "this", ".", "type", "=", "type", ";", "this", ".", "debug", "=", "debug", ";", "this", ".", "bubbles", "=", "false", ";", "this", ".", "cancelable", "=", "false", ";", "this", ".", "eventPhase", "=", "0", ";", "this", ".", "timeStamp", "=", "new", "Date", "(", ")", ".", "valueOf", "(", ")", ";", "}" ]

[ "A", "shim", "Event", "class", "for", "browsers", "that", "don", "t", "allow", "us", "to", "create", "native", "Event", "objects", "." ]

[ "function", "createNativeDOMException", "(", "name", ",", "message", ")", "{", "var", "e", "=", "new", "DOMException", ".", "prototype", ".", "constructor", "(", "0", ",", "message", ")", ";", "e", ".", "name", "=", "name", "||", "'DOMException'", ";", "e", ".", "message", "=", "message", ";", "return", "e", ";", "}" ]

[ "Creates", "a", "native", "DOMException", "for", "browsers", "that", "support", "it" ]

[ "function", "createNativeDOMError", "(", "name", ",", "message", ")", "{", "name", "=", "name", "||", "'DOMError'", ";", "var", "e", "=", "new", "DOMError", "(", "name", ",", "message", ")", ";", "e", ".", "name", "===", "name", "||", "(", "e", ".", "name", "=", "name", ")", ";", "e", ".", "message", "===", "message", "||", "(", "e", ".", "message", "=", "message", ")", ";", "return", "e", ";", "}" ]

[ "Creates", "a", "native", "DOMError", "for", "browsers", "that", "support", "it" ]

[ "function", "createError", "(", "name", ",", "message", ")", "{", "var", "e", "=", "new", "Error", "(", "message", ")", ";", "e", ".", "name", "=", "name", "||", "'DOMException'", ";", "e", ".", "message", "=", "message", ";", "return", "e", ";", "}" ]

[ "Creates", "a", "generic", "Error", "object" ]

[ "function", "createSysDB", "(", "success", ",", "failure", ")", "{", "function", "sysDbCreateError", "(", "tx", ",", "err", ")", "{", "err", "=", "idbModules", ".", "util", ".", "findError", "(", "arguments", ")", ";", "idbModules", ".", "DEBUG", "&&", "console", ".", "log", "(", "\"Error in sysdb transaction - when creating dbVersions\"", ",", "err", ")", ";", "failure", "(", "err", ")", ";", "}", "if", "(", "sysdb", ")", "{", "success", "(", ")", ";", "}", "else", "{", "sysdb", "=", "window", ".", "openDatabase", "(", "\"__sysdb__\"", ",", "1", ",", "\"System Database\"", ",", "DEFAULT_DB_SIZE", ")", ";", "sysdb", ".", "transaction", "(", "function", "(", "tx", ")", "{", "tx", ".", "executeSql", "(", "\"CREATE TABLE IF NOT EXISTS dbVersions (name VARCHAR(255), version INT);\"", ",", "[", "]", ",", "success", ",", "sysDbCreateError", ")", ";", "}", ",", "sysDbCreateError", ")", ";", "}", "}" ]

[ "Craetes", "the", "sysDB", "to", "keep", "track", "of", "version", "numbers", "for", "databases" ]

[ "function", "(", "args", ")", "{", "if", "(", "!", "args", ".", "src", ")", "{", "ret", "=", "new", "Error", "(", "'metalsmith-convert: \"src\" arg is required'", ")", ";", "return", ";", "}", "if", "(", "!", "args", ".", "target", ")", "{", "args", ".", "target", "=", "'__source__'", ";", "}", "var", "ext", "=", "args", ".", "extension", "||", "'.'", "+", "args", ".", "target", ";", "if", "(", "!", "args", ".", "nameFormat", ")", "{", "if", "(", "args", ".", "resize", ")", "{", "args", ".", "nameFormat", "=", "'%b_%x_%y%e'", ";", "}", "else", "{", "args", ".", "nameFormat", "=", "'%b%e'", ";", "}", "}", "if", "(", "!", "!", "args", ".", "remove", "&&", "args", ".", "nameFormat", "===", "'%b%e'", "&&", "args", ".", "target", "===", "'__source__'", ")", "{", "args", ".", "remove", "=", "false", ";", "}", "Object", ".", "keys", "(", "files", ")", ".", "forEach", "(", "function", "(", "file", ")", "{", "convertFile", "(", "file", ",", "ext", ",", "args", ",", "files", ",", "results", ")", ";", "}", ")", ";", "}" ]

[ "what", "to", "return", ";" ]

[ "function", "timedLog", "(", "msg", ")", "{", "console", ".", "log", "(", "Date", ".", "now", "(", ")", "+", "\":\"", "+", "window", ".", "performance", ".", "now", "(", ")", "+", "\": \"", "+", "msg", ")", ";", "}" ]

[ "A", "timed", "logging", "function", "for", "tracing", "touch", "calls", "during", "debug" ]

[ "function", "(", "evt", ")", "{", "evt", ".", "preventDefault", "(", ")", ";", "evt", ".", "stopPropagation", "(", ")", ";", "positionable", ".", "rect", "=", "positionable", ".", "refs", ".", "styleWrapper", ".", "getBoundingClientRect", "(", ")", ";", "if", "(", "debug", ")", "{", "timedLog", "(", "\"startmark\"", ")", ";", "}", "if", "(", "!", "evt", ".", "touches", "||", "evt", ".", "touches", ".", "length", "===", "1", ")", "{", "if", "(", "debug", ")", "{", "timedLog", "(", "\"startmark - continued\"", ")", ";", "}", "mark", "=", "copy", "(", "positionable", ".", "state", ")", ";", "transform", ".", "x1", "=", "evt", ".", "clientX", "||", "evt", ".", "touches", "[", "0", "]", ".", "pageX", ";", "transform", ".", "y1", "=", "evt", ".", "clientY", "||", "evt", ".", "touches", "[", "0", "]", ".", "pageY", ";", "positionable", ".", "setState", "(", "{", "touchactive", ":", "true", "}", ")", ";", "}", "else", "{", "handlers", ".", "secondFinger", "(", "evt", ")", ";", "}", "var", "timeStart", "=", "new", "Date", "(", ")", ";", "tapStart", "=", "{", "x1", ":", "evt", ".", "touches", "[", "0", "]", ".", "pageX", ",", "y1", ":", "evt", ".", "touches", "[", "0", "]", ".", "pageY", ",", "timeStart", ":", "timeStart", "}", ";", "}" ]

[ "mark", "the", "first", "touch", "event", "so", "we", "can", "perform", "computation", "relative", "to", "that", "coordinate", "." ]

[ "function", "(", "evt", ")", "{", "if", "(", "debug", ")", "{", "timedLog", "(", "\"endmark\"", ")", ";", "}", "if", "(", "evt", ".", "touches", "&&", "evt", ".", "touches", ".", "length", ">", "0", ")", "{", "if", "(", "handlers", ".", "endSecondFinger", "(", "evt", ")", ")", "{", "return", ";", "}", "}", "if", "(", "debug", ")", "{", "timedLog", "(", "\"endmark - continued\"", ")", ";", "}", "mark", "=", "copy", "(", "positionable", ".", "state", ")", ";", "var", "modified", "=", "transform", ".", "modified", ";", "transform", "=", "resetTransform", "(", ")", ";", "if", "(", "tapDiff", "<", "MAX_TAP_THRESHOLD", "&&", "(", "new", "Date", "(", ")", "-", "tapStart", ".", "timeStart", "<=", "tapDuration", ")", "&&", "positionable", ".", "onTap", ")", "{", "positionable", ".", "setState", "(", "{", "touchactive", ":", "false", "}", ",", "function", "(", ")", "{", "if", "(", "positionable", ".", "onTap", ")", "{", "positionable", ".", "onTap", "(", ")", ";", "}", "}", ")", ";", "return", ";", "}", "tapDiff", "=", "0", ";", "positionable", ".", "setState", "(", "{", "touchactive", ":", "false", "}", ",", "function", "(", ")", "{", "if", "(", "positionable", ".", "onTouchEnd", ")", "{", "positionable", ".", "onTouchEnd", "(", "modified", ")", ";", "}", "}", ")", ";", "}" ]

[ "When", "all", "fingers", "are", "off", "the", "device", "stop", "being", "in", "touch", "mode" ]

[ "function", "(", "evt", ")", "{", "evt", ".", "preventDefault", "(", ")", ";", "evt", ".", "stopPropagation", "(", ")", ";", "if", "(", "debug", ")", "{", "timedLog", "(", "\"secondFinger\"", ")", ";", "}", "if", "(", "evt", ".", "touches", ".", "length", "<", "2", ")", "{", "return", ";", "}", "transform", ".", "x1", "=", "evt", ".", "touches", "[", "0", "]", ".", "pageX", ";", "transform", ".", "y1", "=", "evt", ".", "touches", "[", "0", "]", ".", "pageY", ";", "transform", ".", "x2", "=", "evt", ".", "touches", "[", "1", "]", ".", "pageX", ";", "transform", ".", "y2", "=", "evt", ".", "touches", "[", "1", "]", ".", "pageY", ";", "var", "x1", "=", "transform", ".", "x1", ",", "y1", "=", "transform", ".", "y1", ",", "x2", "=", "transform", ".", "x2", ",", "y2", "=", "transform", ".", "y2", ",", "dx", "=", "x2", "-", "x1", ",", "dy", "=", "y2", "-", "y1", ",", "d", "=", "Math", ".", "sqrt", "(", "dx", "*", "dx", "+", "dy", "*", "dy", ")", ",", "a", "=", "Math", ".", "atan2", "(", "dy", ",", "dx", ")", ";", "transform", ".", "distance", "=", "d", ";", "transform", ".", "angle", "=", "a", ";", "}" ]

[ "A", "second", "finger", "means", "we", "need", "to", "start", "tracking", "another", "event", "coordinate", "which", "may", "lead", "to", "rotation", "and", "scaling", "updates", "for", "the", "element", "we", "re", "working", "for", "." ]

[ "function", "(", "evt", ")", "{", "evt", ".", "preventDefault", "(", ")", ";", "evt", ".", "stopPropagation", "(", ")", ";", "if", "(", "debug", ")", "{", "timedLog", "(", "\"endSecondFinger\"", ")", ";", "}", "if", "(", "evt", ".", "touches", ".", "length", ">", "1", ")", "{", "if", "(", "debug", ")", "{", "timedLog", "(", "\"endSecondFinger - capped\"", ")", ";", "}", "return", "true", ";", "}", "if", "(", "debug", ")", "{", "timedLog", "(", "\"endSecondFinger - continued\"", ")", ";", "}", "handlers", ".", "startmark", "(", "evt", ")", ";", "return", "evt", ".", "touches", ".", "length", "!==", "0", ";", "}" ]

[ "When", "the", "second", "touch", "event", "ends", "we", "might", "still", "need", "to", "keep", "processing", "plain", "single", "touch", "updates", "." ]

[ "function", "tryFormat", "(", "body", ")", "{", "try", "{", "const", "parsed", "=", "typeof", "body", "===", "'string'", "?", "JSON", ".", "parse", "(", "body", ")", ":", "body", "return", "JSON", ".", "stringify", "(", "parsed", ",", "null", ",", "2", ")", "}", "catch", "(", "err", ")", "{", "return", "body", "}", "}" ]

[ "Attempt", "pretty", "-", "formatting", "JSON" ]

[ "function", "formatReport", "(", ")", "{", "const", "lineCoverage", "=", "new", "LineCoverage", "(", "2", ",", "2", ",", "[", "new", "LineData", "(", "6", ",", "2", ",", "'PF4Rz2r7RTliO9u6bZ7h6g'", ")", ",", "new", "LineData", "(", "7", ",", "2", ",", "'yGMB6FhEEAd8OyASe3Ni1w'", ")", "]", ")", ";", "const", "record", "=", "new", "Record", "(", "'/home/cedx/lcov.js/fixture.js'", ",", "{", "functions", ":", "new", "FunctionCoverage", "(", "1", ",", "1", ")", ",", "lines", ":", "lineCoverage", "}", ")", ";", "const", "report", "=", "new", "Report", "(", "'Example'", ",", "[", "record", "]", ")", ";", "console", ".", "log", "(", "report", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Formats", "coverage", "data", "as", "LCOV", "report", "." ]

[ "async", "function", "parseReport", "(", ")", "{", "try", "{", "const", "coverage", "=", "await", "promises", ".", "readFile", "(", "'lcov.info'", ",", "'utf8'", ")", ";", "const", "report", "=", "Report", ".", "fromCoverage", "(", "coverage", ")", ";", "console", ".", "log", "(", "`", "${", "report", ".", "records", ".", "length", "}", "`", ")", ";", "console", ".", "log", "(", "report", ".", "toJSON", "(", ")", ")", ";", "}", "catch", "(", "error", ")", "{", "console", ".", "log", "(", "`", "${", "error", ".", "message", "}", "`", ")", ";", "}", "}" ]

[ "Parses", "a", "LCOV", "report", "to", "coverage", "data", "." ]

[ "function", "range", "(", "from", ",", "to", ")", "{", "const", "list", "=", "new", "Array", "(", "to", "-", "from", "+", "1", ")", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "list", ".", "length", ";", "i", "+=", "1", ")", "{", "list", "[", "i", "]", "=", "from", "+", "i", ";", "}", "return", "list", ";", "}" ]

[ "Create", "an", "array", "of", "numbers", "." ]

[ "function", "setupBrowserStorage", "(", ")", "{", "if", "(", "browser", "||", "storageMock", ")", "{", "if", "(", "storageMock", ")", "{", "store", "=", "storageMock", ";", "storageKey", "=", "'cache-module-storage-mock'", ";", "}", "else", "{", "var", "storageType", "=", "(", "config", ".", "storage", "===", "'local'", "||", "config", ".", "storage", "===", "'session'", ")", "?", "config", ".", "storage", ":", "null", ";", "store", "=", "(", "storageType", "&&", "typeof", "Storage", "!==", "void", "(", "0", ")", ")", "?", "window", "[", "storageType", "+", "'Storage'", "]", ":", "false", ";", "storageKey", "=", "(", "storageType", ")", "?", "self", ".", "type", "+", "'-'", "+", "storageType", "+", "'-storage'", ":", "null", ";", "}", "if", "(", "store", ")", "{", "var", "db", "=", "store", ".", "getItem", "(", "storageKey", ")", ";", "try", "{", "cache", "=", "JSON", ".", "parse", "(", "db", ")", "||", "cache", ";", "}", "catch", "(", "err", ")", "{", "}", "}", "else", "if", "(", "storageType", ")", "{", "log", "(", "true", ",", "'Browser storage is not supported by this browser. Defaulting to an in-memory cache.'", ")", ";", "}", "}", "}" ]

[ "Enable", "browser", "storage", "if", "desired", "and", "available" ]

[ "function", "overwriteBrowserStorage", "(", ")", "{", "if", "(", "(", "browser", "&&", "store", ")", "||", "storageMock", ")", "{", "var", "db", "=", "cache", ";", "try", "{", "db", "=", "JSON", ".", "stringify", "(", "db", ")", ";", "store", ".", "setItem", "(", "storageKey", ",", "db", ")", ";", "}", "catch", "(", "err", ")", "{", "}", "}", "}" ]

[ "Overwrite", "namespaced", "browser", "storage", "with", "current", "cache" ]

[ "function", "handleRefreshResponse", "(", "key", ",", "data", ",", "err", ",", "response", ")", "{", "if", "(", "!", "err", ")", "{", "this", ".", "set", "(", "key", ",", "response", ",", "(", "data", ".", "lifeSpan", "/", "1000", ")", ",", "data", ".", "refresh", ",", "function", "(", ")", "{", "}", ")", ";", "}", "}" ]

[ "Handle", "the", "refresh", "callback", "from", "the", "consumer", "save", "the", "data", "to", "redis", "." ]

[ "function", "log", "(", "isError", ",", "message", ",", "data", ")", "{", "if", "(", "self", ".", "verbose", "||", "isError", ")", "{", "if", "(", "data", ")", "console", ".", "log", "(", "self", ".", "type", "+", "': '", "+", "message", ",", "data", ")", ";", "else", "console", ".", "log", "(", "self", ".", "type", "+", "message", ")", ";", "}", "}" ]

[ "Error", "logging", "logic" ]

[ "function", "WebRequest", "(", "options", ",", "callback", ")", "{", "request", "(", "options", ",", "function", "(", "err", ",", "response", ",", "body", ")", "{", "if", "(", "err", ")", "{", "return", "callback", "(", "err", ")", ";", "}", "callback", "(", "null", ",", "body", ")", ";", "}", ")", ";", "}" ]

[ "Sends", "a", "request", "to", "the", "Steam", "api" ]

[ "function", "(", "options", ")", "{", "var", "out", "=", "this", ".", "formatEmpty", "(", ")", ",", "data", "=", "[", "]", ",", "rels", ";", "this", ".", "init", "(", ")", ";", "options", "=", "(", "options", ")", "?", "options", ":", "{", "}", ";", "this", ".", "mergeOptions", "(", "options", ")", ";", "this", ".", "getDOMContext", "(", "options", ")", ";", "if", "(", "!", "this", ".", "rootNode", "||", "!", "this", ".", "document", ")", "{", "this", ".", "errors", ".", "push", "(", "this", ".", "noContentErr", ")", ";", "}", "else", "{", "if", "(", "this", ".", "hasMicroformats", "(", "this", ".", "rootNode", ",", "options", ")", ")", "{", "this", ".", "prepareDOM", "(", "options", ")", ";", "if", "(", "this", ".", "options", ".", "filters", ".", "length", ">", "0", ")", "{", "var", "newRootNode", "=", "this", ".", "findFilterNodes", "(", "this", ".", "rootNode", ",", "this", ".", "options", ".", "filters", ")", ";", "data", "=", "this", ".", "walkRoot", "(", "newRootNode", ")", ";", "}", "else", "{", "data", "=", "this", ".", "walkRoot", "(", "this", ".", "rootNode", ")", ";", "}", "out", ".", "items", "=", "data", ";", "if", "(", "modules", ".", "domUtils", ".", "canCloneDocument", "(", "this", ".", "document", ")", "===", "false", ")", "{", "this", ".", "clearUpDom", "(", "this", ".", "rootNode", ")", ";", "}", "}", "if", "(", "this", ".", "findRels", ")", "{", "rels", "=", "this", ".", "findRels", "(", "this", ".", "rootNode", ")", ";", "out", ".", "rels", "=", "rels", ".", "rels", ";", "out", "[", "'rel-urls'", "]", "=", "rels", "[", "'rel-urls'", "]", ";", "}", "}", "if", "(", "this", ".", "errors", ".", "length", ">", "0", ")", "{", "return", "this", ".", "formatError", "(", ")", ";", "}", "return", "out", ";", "}" ]

[ "internal", "parse", "function" ]

[ "function", "(", "node", ",", "options", ")", "{", "this", ".", "init", "(", ")", ";", "options", "=", "(", "options", ")", "?", "options", ":", "{", "}", ";", "if", "(", "node", ")", "{", "return", "this", ".", "getParentTreeWalk", "(", "node", ",", "options", ")", ";", "}", "else", "{", "this", ".", "errors", ".", "push", "(", "this", ".", "noContentErr", ")", ";", "return", "this", ".", "formatError", "(", ")", ";", "}", "}" ]

[ "parse", "to", "get", "parent", "microformat", "of", "passed", "node" ]

[ "function", "(", "options", ")", "{", "var", "out", "=", "{", "}", ",", "items", ",", "classItems", ",", "x", ",", "i", ";", "this", ".", "init", "(", ")", ";", "options", "=", "(", "options", ")", "?", "options", ":", "{", "}", ";", "this", ".", "getDOMContext", "(", "options", ")", ";", "if", "(", "!", "this", ".", "rootNode", "||", "!", "this", ".", "document", ")", "{", "return", "{", "'errors'", ":", "[", "this", ".", "noContentErr", "]", "}", ";", "}", "else", "{", "items", "=", "this", ".", "findRootNodes", "(", "this", ".", "rootNode", ",", "true", ")", ";", "i", "=", "items", ".", "length", ";", "while", "(", "i", "--", ")", "{", "classItems", "=", "modules", ".", "domUtils", ".", "getAttributeList", "(", "items", "[", "i", "]", ",", "'class'", ")", ";", "x", "=", "classItems", ".", "length", ";", "while", "(", "x", "--", ")", "{", "if", "(", "modules", ".", "utils", ".", "startWith", "(", "classItems", "[", "x", "]", ",", "'h-'", ")", ")", "{", "this", ".", "appendCount", "(", "classItems", "[", "x", "]", ",", "1", ",", "out", ")", ";", "}", "for", "(", "var", "key", "in", "modules", ".", "maps", ")", "{", "if", "(", "modules", ".", "maps", "[", "key", "]", ".", "root", "===", "classItems", "[", "x", "]", "&&", "classItems", ".", "indexOf", "(", "key", ")", "===", "-", "1", ")", "{", "this", ".", "appendCount", "(", "key", ",", "1", ",", "out", ")", ";", "}", "}", "}", "}", "var", "relCount", "=", "this", ".", "countRels", "(", "this", ".", "rootNode", ")", ";", "if", "(", "relCount", ">", "0", ")", "{", "out", ".", "rels", "=", "relCount", ";", "}", "return", "out", ";", "}", "}" ]

[ "get", "the", "count", "of", "microformats" ]

[ "function", "(", "node", ",", "options", ")", "{", "var", "classes", ",", "i", ";", "if", "(", "!", "node", ")", "{", "return", "false", ";", "}", "node", "=", "modules", ".", "domUtils", ".", "getTopMostNode", "(", "node", ")", ";", "classes", "=", "this", ".", "getUfClassNames", "(", "node", ")", ";", "if", "(", "options", "&&", "options", ".", "filters", "&&", "modules", ".", "utils", ".", "isArray", "(", "options", ".", "filters", ")", ")", "{", "i", "=", "options", ".", "filters", ".", "length", ";", "while", "(", "i", "--", ")", "{", "if", "(", "classes", ".", "root", ".", "indexOf", "(", "options", ".", "filters", "[", "i", "]", ")", ">", "-", "1", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "else", "{", "return", "(", "classes", ".", "root", ".", "length", ">", "0", ")", ";", "}", "}" ]

[ "does", "a", "node", "have", "a", "class", "that", "marks", "it", "as", "a", "microformats", "root" ]

[ "function", "(", "node", ",", "options", ")", "{", "var", "items", ",", "i", ";", "if", "(", "!", "node", ")", "{", "return", "false", ";", "}", "node", "=", "modules", ".", "domUtils", ".", "getTopMostNode", "(", "node", ")", ";", "items", "=", "this", ".", "findRootNodes", "(", "node", ",", "true", ")", ";", "if", "(", "options", "&&", "options", ".", "filters", "&&", "modules", ".", "utils", ".", "isArray", "(", "options", ".", "filters", ")", ")", "{", "i", "=", "items", ".", "length", ";", "while", "(", "i", "--", ")", "{", "if", "(", "this", ".", "isMicroformat", "(", "items", "[", "i", "]", ",", "options", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "else", "{", "return", "(", "items", ".", "length", ">", "0", ")", ";", "}", "}" ]

[ "does", "a", "node", "or", "its", "children", "have", "microformats" ]

[ "function", "(", "maps", ")", "{", "maps", ".", "forEach", "(", "function", "(", "map", ")", "{", "if", "(", "map", "&&", "map", ".", "root", "&&", "map", ".", "name", "&&", "map", ".", "properties", ")", "{", "modules", ".", "maps", "[", "map", ".", "name", "]", "=", "JSON", ".", "parse", "(", "JSON", ".", "stringify", "(", "map", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "add", "a", "new", "v1", "mapping", "object", "to", "parser" ]

[ "function", "(", "node", ",", "options", ",", "recursive", ")", "{", "options", "=", "(", "options", ")", "?", "options", ":", "{", "}", ";", "if", "(", "recursive", "===", "undefined", ")", "{", "if", "(", "node", ".", "parentNode", "&&", "node", ".", "nodeName", "!==", "'HTML'", ")", "{", "return", "this", ".", "getParentTreeWalk", "(", "node", ".", "parentNode", ",", "options", ",", "true", ")", ";", "}", "else", "{", "return", "this", ".", "formatEmpty", "(", ")", ";", "}", "}", "if", "(", "node", "!==", "null", "&&", "node", "!==", "undefined", "&&", "node", ".", "parentNode", ")", "{", "if", "(", "this", ".", "isMicroformat", "(", "node", ",", "options", ")", ")", "{", "options", ".", "node", "=", "node", ";", "return", "this", ".", "get", "(", "options", ")", ";", "}", "else", "{", "return", "this", ".", "getParentTreeWalk", "(", "node", ".", "parentNode", ",", "options", ",", "true", ")", ";", "}", "}", "else", "{", "return", "this", ".", "formatEmpty", "(", ")", ";", "}", "}" ]

[ "internal", "parse", "to", "get", "parent", "microformats", "by", "walking", "up", "the", "tree" ]

[ "function", "(", "options", ")", "{", "var", "baseTag", ",", "href", ";", "try", "{", "if", "(", "!", "options", ".", "baseUrl", "&&", "this", ".", "document", "&&", "this", ".", "document", ".", "location", ")", "{", "this", ".", "options", ".", "baseUrl", "=", "this", ".", "document", ".", "location", ".", "href", ";", "}", "}", "catch", "(", "e", ")", "{", "}", "baseTag", "=", "modules", ".", "domUtils", ".", "querySelector", "(", "this", ".", "document", ",", "'base'", ")", ";", "if", "(", "baseTag", ")", "{", "href", "=", "modules", ".", "domUtils", ".", "getAttribute", "(", "baseTag", ",", "'href'", ")", ";", "if", "(", "href", ")", "{", "this", ".", "options", ".", "baseUrl", "=", "href", ";", "}", "}", "var", "path", ",", "newDocument", ",", "newRootNode", ";", "path", "=", "modules", ".", "domUtils", ".", "getNodePath", "(", "this", ".", "rootNode", ")", ";", "newDocument", "=", "modules", ".", "domUtils", ".", "cloneDocument", "(", "this", ".", "document", ")", ";", "newRootNode", "=", "modules", ".", "domUtils", ".", "getNodeByPath", "(", "newDocument", ",", "path", ")", ";", "if", "(", "newDocument", "&&", "newRootNode", ")", "{", "this", ".", "document", "=", "newDocument", ";", "this", ".", "rootNode", "=", "newRootNode", ";", "}", "if", "(", "this", ".", "addIncludes", ")", "{", "this", ".", "addIncludes", "(", "this", ".", "document", ")", ";", "}", "return", "(", "this", ".", "rootNode", "&&", "this", ".", "document", ")", ";", "}" ]

[ "prepares", "DOM", "before", "the", "parse", "begins" ]