Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", "node", ",", "args", ")", "{", "var", "self", "=", "this", ",", "impl", ",", "doc", ",", "oldDoc", ",", "htmlSerializer", ",", "content", ",", "rootNode", ";", "// Explorer won't clone contents of script and style and the", "// selected index of select elements are cleared on a clone operation.", "if", "(", "Env", ".", "ie", "&&", "dom", ".", "select", "(", "'script,style,select,map'", ")", ".", "length", ">", "0", ")", "{", "content", "=", "node", ".", "innerHTML", ";", "node", "=", "node", ".", "cloneNode", "(", "false", ")", ";", "dom", ".", "setHTML", "(", "node", ",", "content", ")", ";", "}", "else", "{", "node", "=", "node", ".", "cloneNode", "(", "true", ")", ";", "}", "// Nodes needs to be attached to something in WebKit/Opera", "// This fix will make DOM ranges and make Sizzle happy!", "impl", "=", "document", ".", "implementation", ";", "if", "(", "impl", ".", "createHTMLDocument", ")", "{", "// Create an empty HTML document", "doc", "=", "impl", ".", "createHTMLDocument", "(", "\"\"", ")", ";", "// Add the element or it's children if it's a body element to the new document", "each", "(", "node", ".", "nodeName", "==", "'BODY'", "?", "node", ".", "childNodes", ":", "[", "node", "]", ",", "function", "(", "node", ")", "{", "doc", ".", "body", ".", "appendChild", "(", "doc", ".", "importNode", "(", "node", ",", "true", ")", ")", ";", "}", ")", ";", "// Grab first child or body element for serialization", "if", "(", "node", ".", "nodeName", "!=", "'BODY'", ")", "{", "node", "=", "doc", ".", "body", ".", "firstChild", ";", "}", "else", "{", "node", "=", "doc", ".", "body", ";", "}", "// set the new document in DOMUtils so createElement etc works", "oldDoc", "=", "dom", ".", "doc", ";", "dom", ".", "doc", "=", "doc", ";", "}", "args", "=", "args", "||", "{", "}", ";", "args", ".", "format", "=", "args", ".", "format", "||", "'html'", ";", "// Don't wrap content if we want selected html", "if", "(", "args", ".", "selection", ")", "{", "args", ".", "forced_root_block", "=", "''", ";", "}", "// Pre process", "if", "(", "!", "args", ".", "no_events", ")", "{", "args", ".", "node", "=", "node", ";", "self", ".", "onPreProcess", "(", "args", ")", ";", "}", "// Parse HTML", "content", "=", "Zwsp", ".", "trim", "(", "trim", "(", "args", ".", "getInner", "?", "node", ".", "innerHTML", ":", "dom", ".", "getOuterHTML", "(", "node", ")", ")", ")", ";", "rootNode", "=", "htmlParser", ".", "parse", "(", "content", ",", "args", ")", ";", "trimTrailingBr", "(", "rootNode", ")", ";", "// Serialize HTML", "htmlSerializer", "=", "new", "Serializer", "(", "settings", ",", "schema", ")", ";", "args", ".", "content", "=", "htmlSerializer", ".", "serialize", "(", "rootNode", ")", ";", "// Post process", "if", "(", "!", "args", ".", "no_events", ")", "{", "self", ".", "onPostProcess", "(", "args", ")", ";", "}", "// Restore the old document if it was changed", "if", "(", "oldDoc", ")", "{", "dom", ".", "doc", "=", "oldDoc", ";", "}", "args", ".", "node", "=", "null", ";", "return", "args", ".", "content", ";", "}" ]

[ "Serializes", "the", "specified", "browser", "DOM", "node", "into", "a", "HTML", "string", "." ]

[ "function", "(", "original", ",", "tag", ")", "{", "var", "nu", "=", "Element", ".", "fromTag", "(", "tag", ")", ";", "var", "attributes", "=", "Attr", ".", "clone", "(", "original", ")", ";", "Attr", ".", "setAll", "(", "nu", ",", "attributes", ")", ";", "return", "nu", ";", "}" ]

[ "Shallow", "clone", "with", "a", "new", "tag" ]

[ "function", "(", "original", ",", "tag", ")", "{", "var", "nu", "=", "shallowAs", "(", "original", ",", "tag", ")", ";", "// NOTE", "// previously this used serialisation:", "// nu.dom().innerHTML = original.dom().innerHTML;", "//", "// Clone should be equivalent (and faster), but if TD <-> TH toggle breaks, put it back.", "var", "cloneChildren", "=", "Traverse", ".", "children", "(", "deep", "(", "original", ")", ")", ";", "InsertAll", ".", "append", "(", "nu", ",", "cloneChildren", ")", ";", "return", "nu", ";", "}" ]

[ "Deep", "clone", "with", "a", "new", "tag" ]

[ "function", "(", "original", ",", "tag", ")", "{", "var", "nu", "=", "shallowAs", "(", "original", ",", "tag", ")", ";", "Insert", ".", "before", "(", "original", ",", "nu", ")", ";", "var", "children", "=", "Traverse", ".", "children", "(", "original", ")", ";", "InsertAll", ".", "append", "(", "nu", ",", "children", ")", ";", "Remove", ".", "remove", "(", "original", ")", ";", "return", "nu", ";", "}" ]

[ "Change", "the", "tag", "name", "but", "keep", "all", "children" ]

[ "function", "(", "arr", ",", "f", ")", "{", "var", "r", "=", "[", "]", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "arr", ".", "length", ";", "i", "++", ")", "{", "var", "x", "=", "arr", "[", "i", "]", ";", "if", "(", "x", ".", "isSome", "(", ")", ")", "{", "r", ".", "push", "(", "x", ".", "getOrDie", "(", ")", ")", ";", "}", "else", "{", "return", "Option", ".", "none", "(", ")", ";", "}", "}", "return", "Option", ".", "some", "(", "f", ".", "apply", "(", "null", ",", "r", ")", ")", ";", "}" ]

[ "if", "all", "elements", "in", "arr", "are", "some", "their", "inner", "values", "are", "passed", "as", "arguments", "to", "f", "f", "must", "have", "arity", "arr", ".", "length" ]

[ "function", "(", "args", ")", "{", "var", "self", "=", "this", ",", "rng", "=", "self", ".", "getRng", "(", ")", ",", "tmpElm", "=", "self", ".", "dom", ".", "create", "(", "\"body\"", ")", ";", "var", "se", "=", "self", ".", "getSel", "(", ")", ",", "whiteSpaceBefore", ",", "whiteSpaceAfter", ",", "fragment", ";", "args", "=", "args", "||", "{", "}", ";", "whiteSpaceBefore", "=", "whiteSpaceAfter", "=", "''", ";", "args", ".", "get", "=", "true", ";", "args", ".", "format", "=", "args", ".", "format", "||", "'html'", ";", "args", ".", "selection", "=", "true", ";", "self", ".", "editor", ".", "fire", "(", "'BeforeGetContent'", ",", "args", ")", ";", "if", "(", "args", ".", "format", "===", "'text'", ")", "{", "return", "self", ".", "isCollapsed", "(", ")", "?", "''", ":", "Zwsp", ".", "trim", "(", "rng", ".", "text", "||", "(", "se", ".", "toString", "?", "se", ".", "toString", "(", ")", ":", "''", ")", ")", ";", "}", "if", "(", "rng", ".", "cloneContents", ")", "{", "fragment", "=", "args", ".", "contextual", "?", "FragmentReader", ".", "read", "(", "self", ".", "editor", ".", "getBody", "(", ")", ",", "rng", ")", ".", "dom", "(", ")", ":", "rng", ".", "cloneContents", "(", ")", ";", "if", "(", "fragment", ")", "{", "tmpElm", ".", "appendChild", "(", "fragment", ")", ";", "}", "}", "else", "if", "(", "rng", ".", "item", "!==", "undefined", "||", "rng", ".", "htmlText", "!==", "undefined", ")", "{", "// IE will produce invalid markup if elements are present that", "// it doesn't understand like custom elements or HTML5 elements.", "// Adding a BR in front of the contents and then remoiving it seems to fix it though.", "tmpElm", ".", "innerHTML", "=", "'<br>'", "+", "(", "rng", ".", "item", "?", "rng", ".", "item", "(", "0", ")", ".", "outerHTML", ":", "rng", ".", "htmlText", ")", ";", "tmpElm", ".", "removeChild", "(", "tmpElm", ".", "firstChild", ")", ";", "}", "else", "{", "tmpElm", ".", "innerHTML", "=", "rng", ".", "toString", "(", ")", ";", "}", "// Keep whitespace before and after", "if", "(", "/", "^\\s", "/", ".", "test", "(", "tmpElm", ".", "innerHTML", ")", ")", "{", "whiteSpaceBefore", "=", "' '", ";", "}", "if", "(", "/", "\\s+$", "/", ".", "test", "(", "tmpElm", ".", "innerHTML", ")", ")", "{", "whiteSpaceAfter", "=", "' '", ";", "}", "args", ".", "getInner", "=", "true", ";", "args", ".", "content", "=", "self", ".", "isCollapsed", "(", ")", "?", "''", ":", "whiteSpaceBefore", "+", "self", ".", "serializer", ".", "serialize", "(", "tmpElm", ",", "args", ")", "+", "whiteSpaceAfter", ";", "self", ".", "editor", ".", "fire", "(", "'GetContent'", ",", "args", ")", ";", "return", "args", ".", "content", ";", "}" ]

[ "Returns", "the", "selected", "contents", "using", "the", "DOM", "serializer", "passed", "in", "to", "this", "class", "." ]

[ "function", "(", "rng", ",", "forward", ")", "{", "var", "self", "=", "this", ",", "sel", ",", "node", ",", "evt", ";", "if", "(", "!", "isValidRange", "(", "rng", ")", ")", "{", "return", ";", "}", "// Is IE specific range", "if", "(", "rng", ".", "select", ")", "{", "self", ".", "explicitRange", "=", "null", ";", "try", "{", "rng", ".", "select", "(", ")", ";", "}", "catch", "(", "ex", ")", "{", "// Needed for some odd IE bug #1843306", "}", "return", ";", "}", "if", "(", "!", "self", ".", "tridentSel", ")", "{", "sel", "=", "self", ".", "getSel", "(", ")", ";", "evt", "=", "self", ".", "editor", ".", "fire", "(", "'SetSelectionRange'", ",", "{", "range", ":", "rng", ",", "forward", ":", "forward", "}", ")", ";", "rng", "=", "evt", ".", "range", ";", "if", "(", "sel", ")", "{", "self", ".", "explicitRange", "=", "rng", ";", "try", "{", "sel", ".", "removeAllRanges", "(", ")", ";", "sel", ".", "addRange", "(", "rng", ")", ";", "}", "catch", "(", "ex", ")", "{", "// IE might throw errors here if the editor is within a hidden container and selection is changed", "}", "// Forward is set to false and we have an extend function", "if", "(", "forward", "===", "false", "&&", "sel", ".", "extend", ")", "{", "sel", ".", "collapse", "(", "rng", ".", "endContainer", ",", "rng", ".", "endOffset", ")", ";", "sel", ".", "extend", "(", "rng", ".", "startContainer", ",", "rng", ".", "startOffset", ")", ";", "}", "// adding range isn't always successful so we need to check range count otherwise an exception can occur", "self", ".", "selectedRange", "=", "sel", ".", "rangeCount", ">", "0", "?", "sel", ".", "getRangeAt", "(", "0", ")", ":", "null", ";", "}", "// WebKit egde case selecting images works better using setBaseAndExtent when the image is floated", "if", "(", "!", "rng", ".", "collapsed", "&&", "rng", ".", "startContainer", "===", "rng", ".", "endContainer", "&&", "sel", ".", "setBaseAndExtent", "&&", "!", "Env", ".", "ie", ")", "{", "if", "(", "rng", ".", "endOffset", "-", "rng", ".", "startOffset", "<", "2", ")", "{", "if", "(", "rng", ".", "startContainer", ".", "hasChildNodes", "(", ")", ")", "{", "node", "=", "rng", ".", "startContainer", ".", "childNodes", "[", "rng", ".", "startOffset", "]", ";", "if", "(", "node", "&&", "node", ".", "tagName", "===", "'IMG'", ")", "{", "sel", ".", "setBaseAndExtent", "(", "rng", ".", "startContainer", ",", "rng", ".", "startOffset", ",", "rng", ".", "endContainer", ",", "rng", ".", "endOffset", ")", ";", "// Since the setBaseAndExtent is fixed in more recent Blink versions we", "// need to detect if it's doing the wrong thing and falling back to the", "// crazy incorrect behavior api call since that seems to be the only way", "// to get it to work on Safari WebKit as of 2017-02-23", "if", "(", "sel", ".", "anchorNode", "!==", "rng", ".", "startContainer", "||", "sel", ".", "focusNode", "!==", "rng", ".", "endContainer", ")", "{", "sel", ".", "setBaseAndExtent", "(", "node", ",", "0", ",", "node", ",", "1", ")", ";", "}", "}", "}", "}", "}", "self", ".", "editor", ".", "fire", "(", "'AfterSetSelectionRange'", ",", "{", "range", ":", "rng", ",", "forward", ":", "forward", "}", ")", ";", "}", "else", "{", "// Is W3C Range fake range on IE", "if", "(", "rng", ".", "cloneRange", ")", "{", "try", "{", "self", ".", "tridentSel", ".", "addRange", "(", "rng", ")", ";", "}", "catch", "(", "ex", ")", "{", "//IE9 throws an error here if called before selection is placed in the editor", "}", "}", "}", "}" ]

[ "Changes", "the", "selection", "to", "the", "specified", "DOM", "range", "." ]

[ "function", "(", ")", "{", "var", "level", ";", "if", "(", "self", ".", "typing", ")", "{", "self", ".", "add", "(", ")", ";", "self", ".", "typing", "=", "false", ";", "setTyping", "(", "false", ")", ";", "}", "if", "(", "index", ">", "0", ")", "{", "level", "=", "data", "[", "--", "index", "]", ";", "Levels", ".", "applyToEditor", "(", "editor", ",", "level", ",", "true", ")", ";", "setDirty", "(", "true", ")", ";", "editor", ".", "fire", "(", "'undo'", ",", "{", "level", ":", "level", "}", ")", ";", "}", "return", "level", ";", "}" ]

[ "Undoes", "the", "last", "action", "." ]

[ "function", "(", "elm", ",", "afterDeletePosOpt", ")", "{", "return", "Options", ".", "liftN", "(", "[", "Traverse", ".", "prevSibling", "(", "elm", ")", ",", "Traverse", ".", "nextSibling", "(", "elm", ")", ",", "afterDeletePosOpt", "]", ",", "function", "(", "prev", ",", "next", ",", "afterDeletePos", ")", "{", "var", "offset", ",", "prevNode", "=", "prev", ".", "dom", "(", ")", ",", "nextNode", "=", "next", ".", "dom", "(", ")", ";", "if", "(", "NodeType", ".", "isText", "(", "prevNode", ")", "&&", "NodeType", ".", "isText", "(", "nextNode", ")", ")", "{", "offset", "=", "prevNode", ".", "data", ".", "length", ";", "prevNode", ".", "appendData", "(", "nextNode", ".", "data", ")", ";", "Remove", ".", "remove", "(", "next", ")", ";", "Remove", ".", "remove", "(", "elm", ")", ";", "if", "(", "afterDeletePos", ".", "container", "(", ")", "===", "nextNode", ")", "{", "return", "new", "CaretPosition", "(", "prevNode", ",", "offset", ")", ";", "}", "else", "{", "return", "afterDeletePos", ";", "}", "}", "else", "{", "Remove", ".", "remove", "(", "elm", ")", ";", "return", "afterDeletePos", ";", "}", "}", ")", ".", "orThunk", "(", "function", "(", ")", "{", "Remove", ".", "remove", "(", "elm", ")", ";", "return", "afterDeletePosOpt", ";", "}", ")", ";", "}" ]

[ "When", "deleting", "an", "element", "between", "two", "text", "nodes", "IE", "11", "doesn", "t", "automatically", "merge", "the", "adjacent", "text", "nodes" ]

[ "function", "queryCommandValue", "(", "command", ")", "{", "var", "func", ";", "if", "(", "editor", ".", "quirks", ".", "isHidden", "(", ")", "||", "editor", ".", "removed", ")", "{", "return", ";", "}", "command", "=", "command", ".", "toLowerCase", "(", ")", ";", "if", "(", "(", "func", "=", "commands", ".", "value", "[", "command", "]", ")", ")", "{", "return", "func", "(", "command", ")", ";", "}", "// Browser commands", "try", "{", "return", "editor", ".", "getDoc", "(", ")", ".", "queryCommandValue", "(", "command", ")", ";", "}", "catch", "(", "ex", ")", "{", "// Fails sometimes see bug: 1896577", "}", "}" ]

[ "Queries", "the", "command", "value", "for", "example", "the", "current", "fontsize", "." ]

[ "function", "(", "dom", ",", "node", ")", "{", "return", "node", "&&", "dom", ".", "isBlock", "(", "node", ")", "&&", "!", "/", "^(TD|TH|CAPTION|FORM)$", "/", ".", "test", "(", "node", ".", "nodeName", ")", "&&", "!", "/", "^(fixed|absolute)", "/", "i", ".", "test", "(", "node", ".", "style", ".", "position", ")", "&&", "dom", ".", "getContentEditable", "(", "node", ")", "!==", "\"true\"", ";", "}" ]

[ "Returns", "true", "if", "the", "block", "can", "be", "split", "into", "two", "blocks", "or", "not" ]

[ "function", "moveToCaretPosition", "(", "root", ")", "{", "var", "walker", ",", "node", ",", "rng", ",", "lastNode", "=", "root", ",", "tempElm", ";", "if", "(", "!", "root", ")", "{", "return", ";", "}", "// Old IE versions doesn't properly render blocks with br elements in them", "// For example <p><br></p> wont be rendered correctly in a contentEditable area", "// until you remove the br producing <p></p>", "if", "(", "Env", ".", "ie", "&&", "Env", ".", "ie", "<", "9", "&&", "parentBlock", "&&", "parentBlock", ".", "firstChild", ")", "{", "if", "(", "parentBlock", ".", "firstChild", "==", "parentBlock", ".", "lastChild", "&&", "parentBlock", ".", "firstChild", ".", "tagName", "==", "'BR'", ")", "{", "dom", ".", "remove", "(", "parentBlock", ".", "firstChild", ")", ";", "}", "}", "if", "(", "/", "^(LI|DT|DD)$", "/", ".", "test", "(", "root", ".", "nodeName", ")", ")", "{", "var", "firstChild", "=", "firstNonWhiteSpaceNodeSibling", "(", "root", ".", "firstChild", ")", ";", "if", "(", "firstChild", "&&", "/", "^(UL|OL|DL)$", "/", ".", "test", "(", "firstChild", ".", "nodeName", ")", ")", "{", "root", ".", "insertBefore", "(", "dom", ".", "doc", ".", "createTextNode", "(", "'\\u00a0'", ")", ",", "root", ".", "firstChild", ")", ";", "}", "}", "rng", "=", "dom", ".", "createRng", "(", ")", ";", "// Normalize whitespace to remove empty text nodes. Fix for: #6904", "// Gecko will be able to place the caret in empty text nodes but it won't render propery", "// Older IE versions will sometimes crash so for now ignore all IE versions", "if", "(", "!", "Env", ".", "ie", ")", "{", "root", ".", "normalize", "(", ")", ";", "}", "if", "(", "root", ".", "hasChildNodes", "(", ")", ")", "{", "walker", "=", "new", "TreeWalker", "(", "root", ",", "root", ")", ";", "while", "(", "(", "node", "=", "walker", ".", "current", "(", ")", ")", ")", "{", "if", "(", "node", ".", "nodeType", "==", "3", ")", "{", "rng", ".", "setStart", "(", "node", ",", "0", ")", ";", "rng", ".", "setEnd", "(", "node", ",", "0", ")", ";", "break", ";", "}", "if", "(", "moveCaretBeforeOnEnterElementsMap", "[", "node", ".", "nodeName", ".", "toLowerCase", "(", ")", "]", ")", "{", "rng", ".", "setStartBefore", "(", "node", ")", ";", "rng", ".", "setEndBefore", "(", "node", ")", ";", "break", ";", "}", "lastNode", "=", "node", ";", "node", "=", "walker", ".", "next", "(", ")", ";", "}", "if", "(", "!", "node", ")", "{", "rng", ".", "setStart", "(", "lastNode", ",", "0", ")", ";", "rng", ".", "setEnd", "(", "lastNode", ",", "0", ")", ";", "}", "}", "else", "{", "if", "(", "root", ".", "nodeName", "==", "'BR'", ")", "{", "if", "(", "root", ".", "nextSibling", "&&", "dom", ".", "isBlock", "(", "root", ".", "nextSibling", ")", ")", "{", "// Trick on older IE versions to render the caret before the BR between two lists", "if", "(", "!", "documentMode", "||", "documentMode", "<", "9", ")", "{", "tempElm", "=", "dom", ".", "create", "(", "'br'", ")", ";", "root", ".", "parentNode", ".", "insertBefore", "(", "tempElm", ",", "root", ")", ";", "}", "rng", ".", "setStartBefore", "(", "root", ")", ";", "rng", ".", "setEndBefore", "(", "root", ")", ";", "}", "else", "{", "rng", ".", "setStartAfter", "(", "root", ")", ";", "rng", ".", "setEndAfter", "(", "root", ")", ";", "}", "}", "else", "{", "rng", ".", "setStart", "(", "root", ",", "0", ")", ";", "rng", ".", "setEnd", "(", "root", ",", "0", ")", ";", "}", "}", "selection", ".", "setRng", "(", "rng", ")", ";", "// Remove tempElm created for old IE:s", "dom", ".", "remove", "(", "tempElm", ")", ";", "selection", ".", "scrollIntoView", "(", "root", ")", ";", "}" ]

[ "Moves", "the", "caret", "to", "a", "suitable", "position", "within", "the", "root", "for", "example", "in", "the", "first", "non", "pure", "whitespace", "text", "node", "or", "before", "an", "image" ]

[ "function", "(", "editor", ",", "clientX", ",", "clientY", ")", "{", "var", "bodyElm", "=", "Element", ".", "fromDom", "(", "editor", ".", "getBody", "(", ")", ")", ";", "var", "targetElm", "=", "editor", ".", "inline", "?", "bodyElm", ":", "Traverse", ".", "documentElement", "(", "bodyElm", ")", ";", "var", "transposedPoint", "=", "transpose", "(", "editor", ".", "inline", ",", "targetElm", ",", "clientX", ",", "clientY", ")", ";", "return", "isInsideElementContentArea", "(", "targetElm", ",", "transposedPoint", ".", "x", ",", "transposedPoint", ".", "y", ")", ";", "}" ]

[ "Checks", "if", "the", "specified", "coordinate", "is", "within", "the", "visual", "content", "area", "excluding", "the", "scrollbars" ]

[ "function", "Editor", "(", "id", ",", "settings", ",", "editorManager", ")", "{", "var", "self", "=", "this", ",", "documentBaseUrl", ",", "baseUri", ";", "documentBaseUrl", "=", "self", ".", "documentBaseUrl", "=", "editorManager", ".", "documentBaseURL", ";", "baseUri", "=", "editorManager", ".", "baseURI", ";", "/**\n * Name/value collection with editor settings.\n *\n * @property settings\n * @type Object\n * @example\n * // Get the value of the theme setting\n * tinymce.activeEditor.windowManager.alert(\"You are using the \" + tinymce.activeEditor.settings.theme + \" theme\");\n */", "settings", "=", "EditorSettings", ".", "getEditorSettings", "(", "self", ",", "id", ",", "documentBaseUrl", ",", "editorManager", ".", "defaultSettings", ",", "settings", ")", ";", "self", ".", "settings", "=", "settings", ";", "AddOnManager", ".", "language", "=", "settings", ".", "language", "||", "'en'", ";", "AddOnManager", ".", "languageLoad", "=", "settings", ".", "language_load", ";", "AddOnManager", ".", "baseURL", "=", "editorManager", ".", "baseURL", ";", "/**\n * Editor instance id, normally the same as the div/textarea that was replaced.\n *\n * @property id\n * @type String\n */", "self", ".", "id", "=", "id", ";", "/**\n * State to force the editor to return false on a isDirty call.\n *\n * @property isNotDirty\n * @type Boolean\n * @deprecated Use editor.setDirty instead.\n */", "self", ".", "setDirty", "(", "false", ")", ";", "/**\n * Name/Value object containing plugin instances.\n *\n * @property plugins\n * @type Object\n * @example\n * // Execute a method inside a plugin directly\n * tinymce.activeEditor.plugins.someplugin.someMethod();\n */", "self", ".", "plugins", "=", "{", "}", ";", "/**\n * URI object to document configured for the TinyMCE instance.\n *\n * @property documentBaseURI\n * @type tinymce.util.URI\n * @example\n * // Get relative URL from the location of document_base_url\n * tinymce.activeEditor.documentBaseURI.toRelative('/somedir/somefile.htm');\n *\n * // Get absolute URL from the location of document_base_url\n * tinymce.activeEditor.documentBaseURI.toAbsolute('somefile.htm');\n */", "self", ".", "documentBaseURI", "=", "new", "URI", "(", "settings", ".", "document_base_url", ",", "{", "base_uri", ":", "baseUri", "}", ")", ";", "/**\n * URI object to current document that holds the TinyMCE editor instance.\n *\n * @property baseURI\n * @type tinymce.util.URI\n * @example\n * // Get relative URL from the location of the API\n * tinymce.activeEditor.baseURI.toRelative('/somedir/somefile.htm');\n *\n * // Get absolute URL from the location of the API\n * tinymce.activeEditor.baseURI.toAbsolute('somefile.htm');\n */", "self", ".", "baseURI", "=", "baseUri", ";", "/**\n * Array with CSS files to load into the iframe.\n *\n * @property contentCSS\n * @type Array\n */", "self", ".", "contentCSS", "=", "[", "]", ";", "/**\n * Array of CSS styles to add to head of document when the editor loads.\n *\n * @property contentStyles\n * @type Array\n */", "self", ".", "contentStyles", "=", "[", "]", ";", "// Creates all events like onClick, onSetContent etc see Editor.Events.js for the actual logic", "self", ".", "shortcuts", "=", "new", "Shortcuts", "(", "self", ")", ";", "self", ".", "loadedCSS", "=", "{", "}", ";", "self", ".", "editorCommands", "=", "new", "EditorCommands", "(", "self", ")", ";", "self", ".", "suffix", "=", "editorManager", ".", "suffix", ";", "self", ".", "editorManager", "=", "editorManager", ";", "self", ".", "inline", "=", "settings", ".", "inline", ";", "if", "(", "settings", ".", "cache_suffix", ")", "{", "Env", ".", "cacheSuffix", "=", "settings", ".", "cache_suffix", ".", "replace", "(", "/", "^[\\?\\&]+", "/", ",", "''", ")", ";", "}", "if", "(", "settings", ".", "override_viewport", "===", "false", ")", "{", "Env", ".", "overrideViewPort", "=", "false", ";", "}", "// Call setup", "editorManager", ".", "fire", "(", "'SetupEditor'", ",", "self", ")", ";", "self", ".", "execCallback", "(", "'setup'", ",", "self", ")", ";", "/**\n * Dom query instance with default scope to the editor document and default element is the body of the editor.\n *\n * @property $\n * @type tinymce.dom.DomQuery\n * @example\n * tinymce.activeEditor.$('p').css('color', 'red');\n * tinymce.activeEditor.$().append('<p>new</p>');\n */", "self", ".", "$", "=", "DomQuery", ".", "overrideDefaults", "(", "function", "(", ")", "{", "return", "{", "context", ":", "self", ".", "inline", "?", "self", ".", "getBody", "(", ")", ":", "self", ".", "getDoc", "(", ")", ",", "element", ":", "self", ".", "getBody", "(", ")", "}", ";", "}", ")", ";", "}" ]

[ "Include", "Editor", "API", "docs", "." ]

[ "function", "(", "text", ")", "{", "if", "(", "text", "&&", "Tools", ".", "is", "(", "text", ",", "'string'", ")", ")", "{", "var", "lang", "=", "this", ".", "settings", ".", "language", "||", "'en'", ",", "i18n", "=", "this", ".", "editorManager", ".", "i18n", ";", "text", "=", "i18n", ".", "data", "[", "lang", "+", "'.'", "+", "text", "]", "||", "text", ".", "replace", "(", "/", "\\{\\#([^\\}]+)\\}", "/", "g", ",", "function", "(", "a", ",", "b", ")", "{", "return", "i18n", ".", "data", "[", "lang", "+", "'.'", "+", "b", "]", "||", "'{#'", "+", "b", "+", "'}'", ";", "}", ")", ";", "}", "return", "this", ".", "editorManager", ".", "translate", "(", "text", ")", ";", "}" ]

[ "Translates", "the", "specified", "string", "by", "replacing", "variables", "with", "language", "pack", "items", "it", "will", "also", "check", "if", "there", "is", "a", "key", "matching", "the", "input", "." ]

[ "function", "(", "args", ")", "{", "var", "self", "=", "this", ",", "content", ",", "body", "=", "self", ".", "getBody", "(", ")", ";", "if", "(", "self", ".", "removed", ")", "{", "return", "''", ";", "}", "// Setup args object", "args", "=", "args", "||", "{", "}", ";", "args", ".", "format", "=", "args", ".", "format", "||", "'html'", ";", "args", ".", "get", "=", "true", ";", "args", ".", "getInner", "=", "true", ";", "// Do preprocessing", "if", "(", "!", "args", ".", "no_events", ")", "{", "self", ".", "fire", "(", "'BeforeGetContent'", ",", "args", ")", ";", "}", "// Get raw contents or by default the cleaned contents", "if", "(", "args", ".", "format", "==", "'raw'", ")", "{", "content", "=", "Tools", ".", "trim", "(", "self", ".", "serializer", ".", "getTrimmedContent", "(", ")", ")", ";", "}", "else", "if", "(", "args", ".", "format", "==", "'text'", ")", "{", "content", "=", "body", ".", "innerText", "||", "body", ".", "textContent", ";", "}", "else", "{", "content", "=", "self", ".", "serializer", ".", "serialize", "(", "body", ",", "args", ")", ";", "}", "// Trim whitespace in beginning/end of HTML", "if", "(", "args", ".", "format", "!=", "'text'", ")", "{", "args", ".", "content", "=", "trim", "(", "content", ")", ";", "}", "else", "{", "args", ".", "content", "=", "content", ";", "}", "// Do post processing", "if", "(", "!", "args", ".", "no_events", ")", "{", "self", ".", "fire", "(", "'GetContent'", ",", "args", ")", ";", "}", "return", "args", ".", "content", ";", "}" ]

[ "Gets", "the", "content", "from", "the", "editor", "instance", "this", "will", "cleanup", "the", "content", "before", "it", "gets", "returned", "using", "the", "different", "cleanup", "rules", "options", "." ]

[ "function", "(", ")", "{", "// Call the base contructor.\r", "this", ".", "base", "(", ")", ";", "/**\r\n\t\t * The characters to be used for each indentation step.\r\n\t\t *\r\n\t\t *\t\t// Use tab for indentation.\r\n\t\t *\t\teditorInstance.dataProcessor.writer.indentationChars = '\\t';\r\n\t\t */", "this", ".", "indentationChars", "=", "'\\t'", ";", "/**\r\n\t\t * The characters to be used to close \"self-closing\" elements, like `<br>` or `<img>`.\r\n\t\t *\r\n\t\t *\t\t// Use HTML4 notation for self-closing elements.\r\n\t\t *\t\teditorInstance.dataProcessor.writer.selfClosingEnd = '>';\r\n\t\t */", "this", ".", "selfClosingEnd", "=", "' />'", ";", "/**\r\n\t\t * The characters to be used for line breaks.\r\n\t\t *\r\n\t\t *\t\t// Use CRLF for line breaks.\r\n\t\t *\t\teditorInstance.dataProcessor.writer.lineBreakChars = '\\r\\n';\r\n\t\t */", "this", ".", "lineBreakChars", "=", "'\\n'", ";", "this", ".", "sortAttributes", "=", "1", ";", "this", ".", "_", ".", "indent", "=", "0", ";", "this", ".", "_", ".", "indentation", "=", "''", ";", "// Indicate preformatted block context status. (#5789)\r", "this", ".", "_", ".", "inPre", "=", "0", ";", "this", ".", "_", ".", "rules", "=", "{", "}", ";", "var", "dtd", "=", "CKEDITOR", ".", "dtd", ";", "for", "(", "var", "e", "in", "CKEDITOR", ".", "tools", ".", "extend", "(", "{", "}", ",", "dtd", ".", "$nonBodyContent", ",", "dtd", ".", "$block", ",", "dtd", ".", "$listItem", ",", "dtd", ".", "$tableContent", ")", ")", "{", "this", ".", "setRules", "(", "e", ",", "{", "indent", ":", "!", "dtd", "[", "e", "]", "[", "'#'", "]", ",", "breakBeforeOpen", ":", "1", ",", "breakBeforeClose", ":", "!", "dtd", "[", "e", "]", "[", "'#'", "]", ",", "breakAfterClose", ":", "1", ",", "needsSpace", ":", "(", "e", "in", "dtd", ".", "$block", ")", "&&", "!", "(", "e", "in", "{", "li", ":", "1", ",", "dt", ":", "1", ",", "dd", ":", "1", "}", ")", "}", ")", ";", "}", "this", ".", "setRules", "(", "'br'", ",", "{", "breakAfterOpen", ":", "1", "}", ")", ";", "this", ".", "setRules", "(", "'title'", ",", "{", "indent", ":", "0", ",", "breakAfterOpen", ":", "0", "}", ")", ";", "this", ".", "setRules", "(", "'style'", ",", "{", "indent", ":", "0", ",", "breakBeforeClose", ":", "1", "}", ")", ";", "this", ".", "setRules", "(", "'pre'", ",", "{", "breakAfterOpen", ":", "1", ",", "// Keep line break after the opening tag\r", "indent", ":", "0", "// Disable indentation on <pre>.\r", "}", ")", ";", "}" ]

[ "Creates", "an", "htmlWriter", "class", "instance", "." ]

[ "function", "(", "tagName", ",", "attributes", ")", "{", "var", "rules", "=", "this", ".", "_", ".", "rules", "[", "tagName", "]", ";", "if", "(", "this", ".", "_", ".", "afterCloser", "&&", "rules", "&&", "rules", ".", "needsSpace", "&&", "this", ".", "_", ".", "needsSpace", ")", "this", ".", "_", ".", "output", ".", "push", "(", "'\\n'", ")", ";", "if", "(", "this", ".", "_", ".", "indent", ")", "this", ".", "indentation", "(", ")", ";", "// Do not break if indenting.\r", "else", "if", "(", "rules", "&&", "rules", ".", "breakBeforeOpen", ")", "{", "this", ".", "lineBreak", "(", ")", ";", "this", ".", "indentation", "(", ")", ";", "}", "this", ".", "_", ".", "output", ".", "push", "(", "'<'", ",", "tagName", ")", ";", "this", ".", "_", ".", "afterCloser", "=", "0", ";", "}" ]

[ "Writes", "the", "tag", "opening", "part", "for", "an", "opener", "tag", "." ]

[ "function", "(", "tagName", ",", "isSelfClose", ")", "{", "var", "rules", "=", "this", ".", "_", ".", "rules", "[", "tagName", "]", ";", "if", "(", "isSelfClose", ")", "{", "this", ".", "_", ".", "output", ".", "push", "(", "this", ".", "selfClosingEnd", ")", ";", "if", "(", "rules", "&&", "rules", ".", "breakAfterClose", ")", "this", ".", "_", ".", "needsSpace", "=", "rules", ".", "needsSpace", ";", "}", "else", "{", "this", ".", "_", ".", "output", ".", "push", "(", "'>'", ")", ";", "if", "(", "rules", "&&", "rules", ".", "indent", ")", "this", ".", "_", ".", "indentation", "+=", "this", ".", "indentationChars", ";", "}", "if", "(", "rules", "&&", "rules", ".", "breakAfterOpen", ")", "this", ".", "lineBreak", "(", ")", ";", "tagName", "==", "'pre'", "&&", "(", "this", ".", "_", ".", "inPre", "=", "1", ")", ";", "}" ]

[ "Writes", "the", "tag", "closing", "part", "for", "an", "opener", "tag", "." ]

[ "function", "(", "tagName", ")", "{", "var", "rules", "=", "this", ".", "_", ".", "rules", "[", "tagName", "]", ";", "if", "(", "rules", "&&", "rules", ".", "indent", ")", "this", ".", "_", ".", "indentation", "=", "this", ".", "_", ".", "indentation", ".", "substr", "(", "this", ".", "indentationChars", ".", "length", ")", ";", "if", "(", "this", ".", "_", ".", "indent", ")", "this", ".", "indentation", "(", ")", ";", "// Do not break if indenting.\r", "else", "if", "(", "rules", "&&", "rules", ".", "breakBeforeClose", ")", "{", "this", ".", "lineBreak", "(", ")", ";", "this", ".", "indentation", "(", ")", ";", "}", "this", ".", "_", ".", "output", ".", "push", "(", "'</'", ",", "tagName", ",", "'>'", ")", ";", "tagName", "==", "'pre'", "&&", "(", "this", ".", "_", ".", "inPre", "=", "0", ")", ";", "if", "(", "rules", "&&", "rules", ".", "breakAfterClose", ")", "{", "this", ".", "lineBreak", "(", ")", ";", "this", ".", "_", ".", "needsSpace", "=", "rules", ".", "needsSpace", ";", "}", "this", ".", "_", ".", "afterCloser", "=", "1", ";", "}" ]

[ "Writes", "a", "closer", "tag", "." ]

[ "function", "(", "text", ")", "{", "if", "(", "this", ".", "_", ".", "indent", ")", "{", "this", ".", "indentation", "(", ")", ";", "!", "this", ".", "_", ".", "inPre", "&&", "(", "text", "=", "CKEDITOR", ".", "tools", ".", "ltrim", "(", "text", ")", ")", ";", "}", "this", ".", "_", ".", "output", ".", "push", "(", "text", ")", ";", "}" ]

[ "Writes", "text", "." ]

[ "function", "(", ")", "{", "this", ".", "_", ".", "output", "=", "[", "]", ";", "this", ".", "_", ".", "indent", "=", "0", ";", "this", ".", "_", ".", "indentation", "=", "''", ";", "this", ".", "_", ".", "afterCloser", "=", "0", ";", "this", ".", "_", ".", "inPre", "=", "0", ";", "}" ]

[ "Empties", "the", "current", "output", "buffer", ".", "It", "also", "brings", "back", "the", "default", "values", "of", "the", "writer", "flags", "." ]

[ "function", "normalizeToBase", "(", "text", ")", "{", "var", "rExps", "=", "[", "{", "re", ":", "/", "[\\xC0-\\xC6]", "/", "g", ",", "ch", ":", "\"A\"", "}", ",", "{", "re", ":", "/", "[\\xE0-\\xE6]", "/", "g", ",", "ch", ":", "\"a\"", "}", ",", "{", "re", ":", "/", "[\\xC8-\\xCB]", "/", "g", ",", "ch", ":", "\"E\"", "}", ",", "{", "re", ":", "/", "[\\xE8-\\xEB]", "/", "g", ",", "ch", ":", "\"e\"", "}", ",", "{", "re", ":", "/", "[\\xCC-\\xCF]", "/", "g", ",", "ch", ":", "\"I\"", "}", ",", "{", "re", ":", "/", "[\\xEC-\\xEF]", "/", "g", ",", "ch", ":", "\"i\"", "}", ",", "{", "re", ":", "/", "[\\xD2-\\xD6]", "/", "g", ",", "ch", ":", "\"O\"", "}", ",", "{", "re", ":", "/", "[\\xF2-\\xF6]", "/", "g", ",", "ch", ":", "\"o\"", "}", ",", "{", "re", ":", "/", "[\\xD9-\\xDC]", "/", "g", ",", "ch", ":", "\"U\"", "}", ",", "{", "re", ":", "/", "[\\xF9-\\xFC]", "/", "g", ",", "ch", ":", "\"u\"", "}", ",", "{", "re", ":", "/", "[\\xC7-\\xE7]", "/", "g", ",", "ch", ":", "\"c\"", "}", ",", "{", "re", ":", "/", "[\\xD1]", "/", "g", ",", "ch", ":", "\"N\"", "}", ",", "{", "re", ":", "/", "[\\xF1]", "/", "g", ",", "ch", ":", "\"n\"", "}", "]", ";", "$", ".", "each", "(", "rExps", ",", "function", "(", ")", "{", "text", "=", "text", ".", "replace", "(", "this", ".", "re", ",", "this", ".", "ch", ")", ";", "}", ")", ";", "return", "text", ";", "}" ]

[ "Remove", "all", "diatrics", "from", "the", "given", "text", "." ]

[ "function", "UsbHid", "(", ")", "{", "var", "vendorId", "=", "0x0fc5", ";", "// always 0x0FC5 for Delcom products", "var", "productId", "=", "0xb080", ";", "// always 0xB080 for Delcom HID device", "this", ".", "device", "=", "this", ".", "_find", "(", "vendorId", ",", "productId", ")", ";", "this", ".", "dataMap", "=", "{", "off", ":", "'\\x00'", ",", "green", ":", "'\\x01'", ",", "red", ":", "'\\x02'", ",", "blue", ":", "'\\x04'", ",", "yellow", ":", "'\\x04'", "}", ";", "}" ]

[ "class", "UsbHid", "UsbHid", "driver", "works", "by", "writing", "a", "colour", "data", "or", "off", "data", "to", "the", "device", "." ]

[ "function", "ToJSFilter", "(", "inputTree", ",", "options", ")", "{", "if", "(", "!", "(", "this", "instanceof", "ToJSFilter", ")", ")", "{", "return", "new", "ToJSFilter", "(", "inputTree", ",", "options", ")", ";", "}", "options", "=", "options", "||", "{", "}", ";", "options", ".", "extensions", "=", "options", ".", "extensions", "||", "[", "'txt'", "]", ";", "options", ".", "targetExtension", "=", "'js'", ";", "Filter", ".", "call", "(", "this", ",", "inputTree", ",", "options", ")", ";", "this", ".", "trimFiles", "=", "options", ".", "trimFiles", "||", "false", ";", "}" ]

[ "Take", "an", "input", "tree", "with", "text", "files", "in", "it", "and", "return", "them", "embedded", "into", "new", "JS", "module", "files" ]

[ "function", "define", "(", "scope", ",", "Type", ",", "name", ")", "{", "var", "propName", "=", "name", "||", "'super'", ",", "propInernalName", "=", "'_'", "+", "propName", ";", "Object", ".", "defineProperty", "(", "scope", ",", "propName", ",", "{", "writeable", ":", "false", ",", "get", ":", "function", "(", ")", "{", "if", "(", "!", "this", "[", "propInernalName", "]", ")", "{", "this", "[", "propInernalName", "]", "=", "create", "(", "this", ",", "Type", ")", ";", "}", "return", "this", "[", "propInernalName", "]", ";", "}", "}", ")", ";", "}" ]

[ "Attaches", "a", "super", "property", "to", "an", "object", "that", "contains", "the", "methods", "on", "the", "supplied", "Type", "bound", "to", "the", "current", "instance", "." ]

[ "function", "create", "(", "scope", ",", "Type", ")", "{", "// make result the constructor", "var", "result", "=", "function", "(", ")", "{", "Type", ".", "apply", "(", "scope", ",", "arguments", ")", ";", "}", ";", "// attach methods to result", "for", "(", "var", "key", "in", "Type", ".", "prototype", ")", "{", "if", "(", "typeof", "Type", ".", "prototype", "[", "key", "]", "===", "'function'", ")", "{", "result", "[", "key", "]", "=", "Type", ".", "prototype", "[", "key", "]", ".", "bind", "(", "scope", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Creates", "an", "object", "containing", "methods", "of", "the", "specificed", "proptotype", "that", "will", "be", "bound", "to", "the", "supplied", "scope", ".", "This", "function", "also", "creates", "a", "constructor", "property", "that", "is", "a", "function", "call", "for", "the", "supplied", "prototype" ]

[ "function", "(", "name", ")", "{", "return", "new", "DatabaseAPI", "(", "hoodie", ",", "{", "name", ":", "name", ",", "editable_permissions", ":", "true", ",", "_id", ":", "exports", ".", "convertID", ",", "prepare", ":", "exports", ".", "prepareDoc", ",", "parse", ":", "exports", ".", "parseDoc", "}", ")", "}" ]

[ "Calling", "this", "API", "with", "a", "db", "name", "returns", "a", "new", "DatabaseAPI", "object" ]

[ "function", "all", "(", "values", ",", "keyName", ")", "{", "if", "(", "values", "instanceof", "Array", ")", "{", "var", "results", "=", "{", "}", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "values", ".", "length", ";", "i", "++", ")", "{", "var", "obj2", "=", "values", "[", "i", "]", ";", "var", "res", "=", "get", "(", "obj2", ",", "keyName", ")", ";", "if", "(", "res", "!=", "undefined", ")", "{", "results", "[", "res", "]", "=", "0", ";", "}", "}", "var", "results2", "=", "[", "]", ";", "for", "(", "var", "result", "in", "results", ")", "{", "results2", ".", "push", "(", "result", ")", ";", "}", "return", "results2", ";", "}", "}" ]

[ "Get", "all", "values", "from", "an", "array", "if", "they", "are", "an", "object", "with", "a", "keyName", "attribute", "." ]

[ "function", "getTasksFromYakefile", "(", "cwd", ",", "fileOption", ")", "{", "// find the yakefile and load (actually a dynamic 'require') tasks", "// first create an empty collection - dont need to use the global collection", "const", "tc1", "=", "TC", ".", "TaskCollection", "(", ")", ";", "//preload ", "const", "tc2", "=", "TASKS", ".", "loadPreloadedTasks", "(", "tc1", ")", ";", "const", "yakefileCandidates", "=", "Yakefile", ".", "defaultFilenames", "(", ")", ";", "if", "(", "fileOption", "!==", "undefined", ")", "yakefileCandidates", "=", "[", "fileOption", "]", ";", "const", "yakeFilePath", "=", "Yakefile", ".", "recursiveFindFile", "(", "cwd", ",", "yakefileCandidates", ")", ";", "if", "(", "yakeFilePath", "===", "undefined", ")", "{", "const", "msg", "=", "yakefileCandidates", ".", "join", "(", ")", ";", "// console.log(util.inspect(yakefileCandidates));", "ERROR", ".", "raiseError", "(", "`", "${", "msg", "}", "`", ")", ";", "}", "const", "collection", "=", "TASKS", ".", "requireTasks", "(", "yakeFilePath", ",", "tc2", ")", ";", "return", "collection", ";", "}" ]

[ "Collects", "tasks", "from", "the", "appropriate", "yakefile", "." ]

[ "function", "getTasksFromTaskfile", "(", ")", "{", "// tasks will already be loaded and are in the global collection so get it", "const", "tc", "=", "TASKS", ".", "globals", ".", "globalTaskCollection", ";", "//this time the preloads come after the custom tasks - no choice", "const", "collection", "=", "TASKS", ".", "loadPreloadedTasks", "(", "tc", ")", ";", "return", "collection", ";", "}" ]

[ "In", "taskfile", "mode", "the", "tasks", "are", "defined", "before", "the", "mainline", "gets", "called", "through", "the", "use", "of", "the", "YAKE", ".", "task", "function", ".", "Hence", "by", "the", "time", "this", "function", "gets", "called", "those", "tasks", "are", "already", "in", "a", "global", "collection", ".", "So", "retreived", "them", "add", "default", "tasks", "return", "the", "collection" ]

[ "function", "getTasksFromArray", "(", "cfgArray", ")", "{", "const", "tc", "=", "TC", ".", "TaskCollection", "(", ")", ";", "// tasks are defined in a datascripture - load it", "const", "tc2", "=", "TASKS", ".", "loadTasksFromArray", "(", "cfgArray", ",", "tc", ")", ";", "//this time the preloads come after the custom tasks - could have done it the other way round", "const", "collection", "=", "TASKS", ".", "loadPreloadedTasks", "(", "tc2", ")", ";", "return", "collection", ";", "}" ]

[ "IN", "cfg", "array", "use", "a", "data", "structure", "will", "have", "the", "task", "definitions", ".", "This", "will", "be", "passed", "to", "this", "function" ]

[ "function", "tryShowTasks", "(", "options", ",", "collection", ")", "{", "if", "(", "options", ".", "getValueFor", "(", "'showTasks'", ")", "!==", "undefined", ")", "{", "REPORTS", ".", "printTaskList", "(", "collection", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Tests", "command", "line", "options", "for", "showTasks", "value", ".", "If", "true", "reports", "all", "tasks", "and", "descriptions", "and", "returns", "true", "to", "indicate", "it", "did", "something" ]

[ "function", "tryRunTask", "(", "args", ",", "collection", ")", "{", "let", "nameOfTaskToRun", "=", "'default'", ";", "const", "a", "=", "args", ".", "getArgs", "(", ")", ";", "if", "(", "a", ".", "length", ">", "0", ")", "{", "nameOfTaskToRun", "=", "a", "[", "0", "]", ";", "}", "const", "firstTask", "=", "collection", ".", "getByName", "(", "nameOfTaskToRun", ")", ";", "if", "(", "firstTask", "===", "undefined", ")", "{", "// console.log('ERROR');", "ERROR", ".", "raiseError", "(", "`", "${", "nameOfTaskToRun", "}", "`", ")", ";", "}", "TASKS", ".", "invokeTask", "(", "collection", ",", "firstTask", ")", ";", "// console.log(chalk.white.bold(`${firstTask.name()} - completed `) + chalk.green.bold('OK'));", "}" ]

[ "Looks", "in", "the", "CliArguments", "parameter", "and", "if", "any", "strings", "are", "found", "tries", "to", "execute", "those", "as", "task", "names", "and", "of", "course", "the", "prerequisites" ]

[ "function", "taskFileMain", "(", "argv", ")", "{", "if", "(", "argv", "===", "undefined", ")", "argv", "=", "process", ".", "argv", "const", "[", "options", ",", "args", ",", "helpText", "]", "=", "CLI", ".", "taskFileParse", "(", "argv", ")", ";", "const", "collection", "=", "getTasksFromTaskfile", "(", ")", ";", "const", "p", "=", "loadPackageJson", "(", ")", ";", "if", "(", "tryShowVersion", "(", "options", ",", "p", ".", "version", ")", ")", "return", ";", "if", "(", "tryShowTasks", "(", "options", ",", "collection", ")", ")", "return", ";", "if", "(", "tryShowHelp", "(", "options", ",", "helpText", ")", ")", "return", ";", "tryRunTask", "(", "args", ",", "collection", ")", ";", "}" ]

[ "The", "mainline", "of", "a", "taskfile", ".", "Only", "depends", "on", "the", "options", "and", "arguments", "on", "the", "command", "line" ]

[ "function", "yakeFileMain", "(", "argv", ",", "cwd", ")", "{", "if", "(", "cwd", "===", "undefined", ")", "cwd", "=", "process", ".", "cwd", "(", ")", ";", "if", "(", "argv", "===", "undefined", ")", "argv", "=", "process", ".", "argv", "const", "[", "options", ",", "args", ",", "helpText", "]", "=", "CLI", ".", "CliParse", "(", "argv", ")", ";", "const", "collection", "=", "getTasksFromYakefile", "(", "cwd", ",", "options", ".", "getValueFor", "(", "'file'", ")", ")", ";", "const", "p", "=", "loadPackageJson", "(", ")", ";", "if", "(", "tryShowVersion", "(", "options", ",", "p", ".", "version", ")", ")", "return", ";", "if", "(", "tryShowTasks", "(", "options", ",", "collection", ")", ")", "return", ";", "if", "(", "tryShowHelp", "(", "options", ",", "helpText", ")", ")", "return", ";", "tryRunTask", "(", "args", ",", "collection", ")", ";", "}" ]

[ "The", "mainline", "for", "use", "in", "the", "yake", "command", ".", "Depends", "on", "the", "options", "and", "arguments", "on", "the", "command", "line", "plus", "the", "directory", "from", "which", "to", "start", "the", "search", "for", "a", "yakefile" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "var", "insightsPanel", "=", "self", ".", "buildInsightsPanel", "(", ")", ";", "var", "media", "=", "insightsPanel", "+", "'<div class=\"media\">'", "+", "' <div class=\"media-left\">'", "+", "// the visual chart as media-object.", "' <div class=\"media-object\" id=\"'", "+", "self", ".", "getId", "(", "'chart'", ")", "+", "'\">Charts</div>'", "+", "' </div>'", "+", "' <div class=\"media-body\">'", "+", "' <div id=\"'", "+", "self", ".", "getId", "(", "'summary'", ")", "+", "'\">Summary</div>'", "+", "' </div>'", "+", "'</div>'", ";", "$", "(", "'#'", "+", "self", ".", "attrId", ")", ".", "html", "(", "media", ")", ";", "}" ]

[ "build", "the", "dashboard", "as", "media", "object", "." ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "var", "panel", "=", "'<div class=\"panel panel-success\">'", "+", "' <div class=\"panel-heading\">'", "+", "' visual data dashboard mockups'", "+", "' </div>'", "+", "' <div class=\"panel-body\">'", "+", "' <div class=\"row\">'", "+", "// the visual chart.", "' <div class=\"col-md-8\">'", "+", "' <div id=\"'", "+", "self", ".", "getId", "(", "'chart'", ")", "+", "'\">Charts</div>'", "+", "' </div>'", "+", "// the information column", "' <div class=\"col-md-4\">'", "+", "' <div id=\"'", "+", "self", ".", "getId", "(", "'summary'", ")", "+", "'\">Summary</div>'", "+", "' </div>'", "+", "' </div>'", "+", "' </div>'", "+", "' <div class=\"panel-footer\">'", "+", "' visual data footer mockups'", "+", "' </div>'", "+", "'</div>'", ";", "$", "(", "'#'", "+", "self", ".", "attrId", ")", ".", "html", "(", "panel", ")", ";", "// Draw the chart,", "$", "(", "'#'", "+", "self", ".", "getId", "(", "'chart'", ")", ")", ".", "html", "(", "''", ")", ".", "bilevelSunburst", "(", "{", "date", ":", "self", ".", "options", ".", "date", "}", ",", "self", ".", "treemapData", ")", ";", "}" ]

[ "build", "the", "panel", "as", "dashboard", ".", "Where", "is", "data", "from?" ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "// Draw the chart,", "$", "(", "'#'", "+", "self", ".", "getId", "(", "'chart'", ")", ")", ".", "html", "(", "''", ")", ".", "bilevelSunburst", "(", "{", "date", ":", "self", ".", "options", ".", "date", "}", ",", "self", ".", "treemapData", ")", ";", "}" ]

[ "create", "this", "utility", "function", "to", "draw", "chart", "we", "could", "use", "it", "whenever", "we", "need", ".", "For", "example", "after", "we", "re", "-", "arrange", "the", "dashboard", "we", "will", "need", "re", "-", "draw", "the", "chart", ".", "the", "chart", "will", "re", "-", "calculate", "all", "positions", "." ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "var", "summary", "=", "self", ".", "tableSummaryBuilder", "(", "self", ".", "groupsSummary", ",", "self", ".", "pagesSummary", ",", "self", ".", "total", ")", ";", "$", "(", "'#'", "+", "self", ".", "getId", "(", "'summary'", ")", ")", ".", "html", "(", "summary", ")", ";", "}" ]

[ "utility", "function", "to", "build", "summary", "." ]

[ "function", "(", "groupName", ",", "totalSites", ",", "totalPages", ",", "totalPageviews", ")", "{", "var", "format", "=", "d3", ".", "format", "(", "',d'", ")", ";", "// build", "var", "summary", "=", "'<tr>'", "+", "'<td>'", "+", "groupName", "+", "'</td>'", "+", "'<td>'", "+", "format", "(", "totalPageviews", ")", "+", "'</td>'", "+", "'<td>'", "+", "format", "(", "totalPages", ")", "+", "'</td>'", "+", "//'<td>' + totalSites + '</td>' +", "'</tr>'", ";", "return", "summary", ";", "}" ]

[ "build", "row", "for", "each", "table", ".." ]

[ "function", "(", ")", "{", "var", "self", "=", "this", ";", "if", "(", "this", ".", "options", ".", "insightsFeeder", ")", "{", "// use the customize insights feeder", "self", ".", "options", ".", "insightsFeeder", "(", "self", ")", ";", "}", "else", "{", "// using the default insights feeder.", "self", ".", "defaultInsightsFeeder", "(", "self", ")", ";", "}", "}" ]

[ "feed", "insights", "." ]

[ "function", "(", "visualData", ")", "{", "var", "insightsList", "=", "'<li class=\"list-group-item\">The site served'", "+", "' <strong>'", "+", "visualData", ".", "total", "[", "0", "]", "+", "'</strong> total pageviews on'", "+", "' <strong>'", "+", "visualData", ".", "total", "[", "1", "]", "+", "'</strong> pages of'", "+", "' <strong>'", "+", "visualData", ".", "total", "[", "2", "]", "+", "'</strong> sites'", "+", "'</li>'", "+", "// the first group", "'<li class=\"list-group-item\">The No. 1 group is <strong>'", "+", "visualData", ".", "groupsPageviews", "[", "0", "]", "[", "0", "]", "+", "'</strong>, which has <strong>'", "+", "visualData", ".", "groupsPageviews", "[", "0", "]", "[", "1", "]", "+", "'</strong> pageviews'", "+", "'</li>'", "+", "// the most viewed single page", "'<li class=\"list-group-item\">The most views single page is <strong>'", "+", "visualData", ".", "jsonData", "[", "0", "]", "[", "0", "]", "+", "'</strong>, which has <strong>'", "+", "visualData", ".", "jsonData", "[", "0", "]", "[", "2", "]", "+", "'</strong> pageviews'", "+", "'</li>'", ";", "$", "(", "'#'", "+", "visualData", ".", "getId", "(", "'insightsList'", ")", ")", ".", "html", "(", "insightsList", ")", ";", "}" ]

[ "the", "default", "Insights", "feeder", "." ]

[ "function", "run", "(", "x", ",", "cb", ")", "{", "const", "s", "=", "speculum", "(", "null", ",", "Echo", ",", "x", ")", "s", ".", "on", "(", "'end'", ",", "cb", ")", "s", ".", "on", "(", "'error'", ",", "cb", ")", "const", "reader", "=", "new", "Count", "(", "{", "highWaterMark", ":", "0", "}", ",", "10", ")", "reader", ".", "pipe", "(", "s", ")", ".", "resume", "(", ")", "}" ]

[ "Leverage", "x", "streams", "to", "transform", "delayed", "echoing", "in", "this", "example", "data", "from", "our", "readable", "stream", "." ]

[ "function", "Schema", "(", "config", ",", "data", ")", "{", "const", "controllers", "=", "data", ".", "controllers", ";", "const", "length", "=", "controllers", ".", "length", ";", "this", ".", "FullyTyped", "=", "FullyTyped", ";", "// apply controllers to this schema", "for", "(", "let", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "controllers", "[", "i", "]", ".", "call", "(", "this", ",", "config", ")", ";", "// add additional properties", "if", "(", "config", ".", "_extension_", "&&", "typeof", "config", ".", "_extension_", "===", "'object'", ")", "{", "const", "self", "=", "this", ";", "Object", ".", "keys", "(", "config", ".", "_extension_", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "self", "[", "key", "]", "=", "config", ".", "_extension_", "[", "key", "]", ";", "}", ")", ";", "}", "// store protected data with schema", "const", "protect", "=", "Object", ".", "assign", "(", "{", "}", ",", "data", ")", ";", "// create and store hash", "const", "options", "=", "getNormalizedSchemaConfiguration", "(", "this", ")", ";", "protect", ".", "hash", "=", "crypto", ".", "createHash", "(", "'sha256'", ")", ".", "update", "(", "JSON", ".", "stringify", "(", "prepareForHash", "(", "options", ")", ")", ")", ".", "digest", "(", "'hex'", ")", ";", "instances", ".", "set", "(", "this", ",", "protect", ")", ";", "/**\n * @name Schema#config\n * @type {object}\n */", "Object", ".", "defineProperty", "(", "this", ",", "'config'", ",", "{", "get", ":", "function", "(", ")", "{", "return", "util", ".", "copy", "(", "config", ")", ";", "}", "}", ")", ";", "}" ]

[ "Create", "a", "schema", "instance", "." ]

[ "function", "build", "(", "base", ",", "config", ")", "{", "var", "result", "=", "resolver", "(", "base", ")", ";", "Object", ".", "keys", "(", "config", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "var", "value", "=", "config", "[", "key", "]", ";", "if", "(", "typeof", "value", "===", "\"string\"", ")", "{", "result", "[", "key", "]", "=", "resolver", "(", "result", "(", "value", ",", "true", ")", ")", ";", "}", "else", "if", "(", "Array", ".", "isArray", "(", "value", ")", "&&", "value", ".", "length", "===", "2", "&&", "typeof", "value", "[", "0", "]", "===", "\"string\"", "&&", "typeof", "value", "[", "1", "]", "===", "\"object\"", ")", "{", "result", "[", "key", "]", "=", "build", "(", "result", "(", "value", "[", "0", "]", ",", "true", ")", ",", "value", "[", "1", "]", ")", ";", "}", "else", "{", "throw", "new", "TypeError", "(", "\"Invalid value at: \"", "+", "key", ")", ";", "}", "}", ")", ";", "return", "result", ";", "}" ]

[ "Process", "configuration", "file" ]

[ "function", "populateApiFromInterface", "(", "api", ",", "iface", ")", "{", "Object", ".", "keys", "(", "iface", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "api", ".", "add", "(", "key", ",", "iface", "[", "key", "]", ")", ";", "}", ")", ";", "}" ]

[ "fill", "api", "from", "interface" ]

[ "function", "router", "(", "rpc", ",", "handlers", ",", "req", ",", "res", ")", "{", "var", "$", "=", "rpc", ".", "$", ";", "var", "api", "=", "rpc", ".", "api", ";", "var", "request", "=", "api", ".", "handle", "(", "req", ".", "method", ",", "req", ".", "url", ")", ";", "var", "dom", "=", "domain", ".", "create", "(", ")", ";", "// the request handler doesn't exit", "// TODO: hoist response logic", "if", "(", "!", "request", ")", "{", "res", ".", "statusCode", "=", "404", ";", "res", ".", "end", "(", ")", ";", "return", ";", "}", "var", "context", "=", "new", "Context", "(", ")", ";", "// TODO: hoist to own module", "var", "handle", "=", "request", ".", "handle", ";", "var", "params", "=", "{", "}", ";", "// TODO: hoist logic to 'union' module", "var", "key", ";", "for", "(", "key", "in", "request", ".", "params", ")", "params", "[", "key", "]", "=", "request", ".", "params", "[", "key", "]", ";", "for", "(", "key", "in", "request", ".", "query", ")", "params", "[", "key", "]", "=", "request", ".", "query", "[", "key", "]", ";", "var", "future", "=", "$", ".", "future", "(", ")", ";", "future", ".", "setWritable", "(", "res", ")", ";", "future", ".", "setReadable", "(", "req", ")", ";", "// TODO: extract request making logic", "res", ".", "setHeader", "(", "'Transfer-Encoding'", ",", "'chunked'", ")", ";", "res", ".", "setHeader", "(", "'Content-Type'", ",", "'application/json'", ")", ";", "dom", ".", "on", "(", "'error'", ",", "function", "(", "err", ")", "{", "var", "statusCode", "=", "err", ".", "statusCode", ";", "// only catch known errors, re-throw unexpected errors", "if", "(", "!", "statusCode", ")", "throw", "err", ";", "// TODO: hoist response logic", "res", ".", "statusCode", "=", "statusCode", ";", "res", ".", "write", "(", "JSON", ".", "stringify", "(", "err", ")", ")", ";", "res", ".", "end", "(", ")", ";", "}", ")", ";", "// domain should handle all route errors", "dom", ".", "run", "(", "function", "(", ")", "{", "handlers", "[", "handle", "]", "(", "future", ",", "params", ",", "context", ")", ";", "}", ")", ";", "}" ]

[ "make", "http", "router", "use", "Function", ".", "bind", "to", "create", "a", "router", "given", "an", "rpc", "and", "set", "of", "handlers" ]

[ "function", "addSimpleMethod", "(", "name", ",", "msg", ",", "failureIsError", ")", "{", "LockdClient", ".", "prototype", "[", "name", "]", "=", "function", "(", "objName", ",", "cb", ")", "{", "var", "self", "=", "this", ";", "self", ".", "transport", ".", "request", "(", "util", ".", "format", "(", "msg", ",", "objName", ")", ",", "1", ",", "function", "(", "err", ",", "lines", ")", "{", "self", ".", "_processResponseLine", "(", "cb", ",", "err", ",", "lines", "&&", "lines", "[", "0", "]", ",", "failureIsError", ")", ";", "}", ")", ";", "}", ";", "}" ]

[ "Add", "a", "simple", "method", "to", "the", "client", "prototype", "which", "sends", "a", "message", "to", "the", "lockd", "server", "and", "expects", "a", "single", "line", "back", "in", "response", "." ]

[ "function", "runSingleBrowser", "(", "location", ",", "remote", ",", "platform", ",", "options", ")", "{", "var", "capabilities", "=", "{", "}", ";", "Object", ".", "keys", "(", "platform", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "capabilities", "[", "key", "]", "=", "platform", "[", "key", "]", ";", "}", ")", ";", "var", "extraCapabilities", "=", "typeof", "options", ".", "capabilities", "===", "'function'", "?", "options", ".", "capabilities", "(", "platform", ")", ":", "(", "options", ".", "capabilities", "||", "{", "}", ")", ";", "Object", ".", "keys", "(", "extraCapabilities", ")", ".", "forEach", "(", "function", "(", "key", ")", "{", "capabilities", "[", "key", "]", "=", "extraCapabilities", "[", "key", "]", ";", "}", ")", ";", "return", "retry", "(", "function", "(", "err", ")", "{", "var", "driver", "=", "getDriver", "(", "remote", ",", "capabilities", ",", "{", "mode", ":", "'async'", ",", "debug", ":", "options", ".", "debug", ",", "httpDebug", ":", "options", ".", "httpDebug", ",", "}", ")", ";", "return", "driver", ".", "_session", "(", ")", ".", "then", "(", "function", "(", ")", "{", "return", "driver", ";", "}", ")", ";", "}", ",", "4", ",", "function", "(", "attempt", ")", "{", "return", "attempt", "*", "attempt", "*", "5000", ";", "}", ",", "{", "debug", ":", "options", ".", "debug", "}", ")", ".", "then", "(", "function", "(", "driver", ")", "{", "return", "runDriver", "(", "location", ",", "driver", ",", "{", "name", ":", "options", ".", "name", ",", "jobInfo", ":", "typeof", "options", ".", "jobInfo", "===", "'function'", "?", "options", ".", "jobInfo", "(", "platform", ")", ":", "options", ".", "jobInfo", ",", "allowExceptions", ":", "options", ".", "allowExceptions", ",", "testComplete", ":", "options", ".", "testComplete", ",", "testPassed", ":", "options", ".", "testPassed", ",", "timeout", ":", "options", ".", "timeout", ",", "debug", ":", "options", ".", "debug", "}", ")", ".", "then", "(", "function", "(", "result", ")", "{", "return", "result", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Run", "a", "test", "in", "a", "single", "browser", "then", "return", "the", "result" ]

[ "function", "Cache", "(", "cache", ",", "options", ")", "{", "if", "(", "arguments", ".", "length", "===", "1", ")", "{", "if", "(", "cache", ".", "hasOwnProperty", "(", "'normalizeKey'", ")", "||", "cache", ".", "hasOwnProperty", "(", "'transform'", ")", ")", "{", "options", "=", "cache", ";", "cache", "=", "{", "}", ";", "}", "}", "options", "=", "options", "||", "{", "}", ";", "this", ".", "cache", "=", "cache", "||", "{", "}", ";", "this", ".", "normalizeKey", "=", "options", ".", "normalizeKey", "||", "function", "(", "key", ")", "{", "return", "key", ";", "}", ";", "this", ".", "transform", "=", "options", ".", "transform", "||", "function", "(", "value", ")", "{", "return", "value", ";", "}", ";", "}" ]

[ "Create", "a", "cache", "that", "transforms", "values", "when", "setting", "." ]

[ "function", "(", "attrs", ")", "{", "attrs", "=", "attrs", "||", "{", "}", ";", "attrs", ".", "state", "=", "attrs", ".", "state", "||", "{", "}", ";", "//\tBuild our class name", "var", "cName", "=", "cfgClasses", "(", "\"mdl-button--\"", ",", "[", "\"raised\"", ",", "\"fab\"", ",", "\"mini-fab\"", ",", "\"icon\"", ",", "\"colored\"", ",", "\"primary\"", ",", "\"accent\"", "]", ",", "attrs", ".", "state", ")", "+", "cfgClasses", "(", "\"mdl-js-\"", ",", "[", "\"ripple-effect\"", "]", ",", "attrs", ".", "state", ")", ";", "return", "attrsConfig", "(", "{", "className", ":", "\"mdl-button mdl-js-button\"", "+", "cName", "}", ",", "attrs", ")", ";", "}" ]

[ "Set", "button", "class", "names" ]

[ "function", "(", "ctrl", ",", "attrs", ")", "{", "attrs", "=", "mButton", ".", "attrs", "(", "attrs", ")", ";", "//\tIf there is a href, we assume this is a link button", "return", "m", "(", "attrs", ".", "cfg", ".", "href", "?", "'a'", ":", "'button'", ",", "attrExclude", "(", "attrs", ".", "cfg", ",", "[", "'text'", "]", ")", ",", "(", "attrs", ".", "state", ".", "fab", "||", "attrs", ".", "state", ".", "icon", "?", "m", "(", "'i'", ",", "{", "className", ":", "\"material-icons\"", "}", ",", "attrs", ".", "cfg", ".", "text", ")", ":", "attrs", ".", "cfg", ".", "text", ")", ")", ";", "}" ]

[ "Always", "use", "the", "attrs", "not", "ctrl", "as", "it", "isn", "t", "returned", "from", "the", "default", "controller", "." ]

[ "function", "(", "attrs", ")", "{", "attrs", "=", "attrs", "||", "{", "}", ";", "attrs", ".", "state", "=", "attrs", ".", "state", "||", "{", "}", ";", "return", "attrsConfig", "(", "{", "className", ":", "\"mdl-js-snackbar mdl-snackbar\"", "}", ",", "attrs", ")", ";", "}" ]

[ "Set", "the", "default", "attrs", "here" ]

[ "function", "tlid__xtro", "(", "str", ")", "{", "var", "r", "=", "new", "Object", "(", ")", ";", "r", ".", "tlid", "=", "\"-1\"", ";", "r", ".", "src", "=", "str", ";", "r", ".", "txt", "=", "\"\"", ";", "// r.deco = \"\";", "if", "(", "tlid__has", "(", "str", ")", ")", "{", "r", ".", "tlid", "=", "tlid__xtr", "(", "str", ")", ";", "r", ".", "txt", "=", "str", ".", "replace", "(", "r", ".", "tlid", "+", "\" \"", ",", "\"\"", ")", "// try to clear out the double space", ".", "replace", "(", "r", ".", "tlid", ",", "\"\"", ")", "// if ending the string, well we remove it", ".", "replace", "(", "\"@tlid \"", ",", "\"\"", ")", ";", "//remove the decorator", "}", "return", "r", ";", "}" ]

[ "Extract", "a", "structure", "from", "the", "string" ]

[ "function", "(", "obj", ",", "fn", ")", "{", "for", "(", "var", "i", "in", "obj", ")", "{", "if", "(", "typeof", "obj", "[", "i", "]", "===", "'object'", ")", "{", "obj", "[", "i", "]", "=", "parse", "(", "obj", "[", "i", "]", ",", "fn", ")", ";", "}", "else", "{", "obj", "[", "i", "]", "=", "fn", "(", "obj", "[", "i", "]", ",", "i", ")", ";", "}", "}", "return", "obj", ";", "}" ]

[ "Simple", "self", "iterative", "function" ]

[ "function", "changeKeys", "(", "src", ",", "dest", ")", "{", "for", "(", "var", "i", "in", "src", ")", "{", "if", "(", "typeof", "src", "[", "i", "]", "===", "'object'", ")", "{", "dest", "[", "escapedSingleQuotes", "+", "i", "+", "escapedSingleQuotes", "]", "=", "{", "}", ";", "changeKeys", "(", "src", "[", "i", "]", ",", "dest", "[", "escapedSingleQuotes", "+", "i", "+", "escapedSingleQuotes", "]", ")", ";", "}", "else", "{", "dest", "[", "escapedSingleQuotes", "+", "i", "+", "escapedSingleQuotes", "]", "=", "src", "[", "i", "]", ";", "}", "}", "return", "dest", ";", "}" ]

[ "Little", "hack", "to", "keep", "quotes", "on", "key", "names", "." ]

[ "function", "errorsMiddleware", "(", "req", ",", "res", ",", "next", ")", "{", "var", "errors", "=", "[", "]", ";", "res", ".", "addError", "=", "function", "(", "location", ",", "name", ",", "description", ")", "{", "if", "(", "[", "\"body\"", ",", "\"header\"", ",", "\"url\"", ",", "\"querystring\"", "]", ".", "indexOf", "(", "location", ")", "===", "-", "1", ")", "{", "throw", "new", "Error", "(", "'\"'", "+", "location", "+", "'\" is not a valid location. '", "+", "'Should be one of \"header\", \"body\", \"url\" or '", "+", "'\"querystring\".'", ")", ";", "}", "errors", ".", "push", "(", "{", "location", ":", "location", ",", "name", ":", "name", ",", "description", ":", "description", "}", ")", ";", "}", ";", "res", ".", "sendError", "=", "function", "(", "location", ",", "name", ",", "description", ")", "{", "if", "(", "typeof", "location", "!==", "\"undefined\"", ")", "{", "res", ".", "addError", "(", "location", ",", "name", ",", "description", ")", ";", "}", "res", ".", "json", "(", "400", ",", "{", "status", ":", "\"errors\"", ",", "errors", ":", "errors", "}", ")", ";", "}", ";", "res", ".", "hasErrors", "=", "function", "(", ")", "{", "return", "errors", ".", "length", "!==", "0", ";", "}", ";", "next", "(", ")", ";", "}" ]

[ "The", "errors", "middleware", "adds", "two", "functions", "to", "the", "response", "object", "in", "order", "to", "handle", "validation", "." ]

[ "function", "(", "internalInstance", ",", "transaction", ",", "updateBatchNumber", ")", "{", "if", "(", "internalInstance", ".", "_updateBatchNumber", "!==", "updateBatchNumber", ")", "{", "// The component's enqueued batch number should always be the current", "// batch or the following one.", "process", ".", "env", ".", "NODE_ENV", "!==", "'production'", "?", "warning", "(", "internalInstance", ".", "_updateBatchNumber", "==", "null", "||", "internalInstance", ".", "_updateBatchNumber", "===", "updateBatchNumber", "+", "1", ",", "'performUpdateIfNecessary: Unexpected batch number (current %s, '", "+", "'pending %s)'", ",", "updateBatchNumber", ",", "internalInstance", ".", "_updateBatchNumber", ")", ":", "void", "0", ";", "return", ";", "}", "if", "(", "process", ".", "env", ".", "NODE_ENV", "!==", "'production'", ")", "{", "if", "(", "internalInstance", ".", "_debugID", "!==", "0", ")", "{", "ReactInstrumentation", ".", "debugTool", ".", "onBeforeUpdateComponent", "(", "internalInstance", ".", "_debugID", ",", "internalInstance", ".", "_currentElement", ")", ";", "}", "}", "internalInstance", ".", "performUpdateIfNecessary", "(", "transaction", ")", ";", "if", "(", "process", ".", "env", ".", "NODE_ENV", "!==", "'production'", ")", "{", "if", "(", "internalInstance", ".", "_debugID", "!==", "0", ")", "{", "ReactInstrumentation", ".", "debugTool", ".", "onUpdateComponent", "(", "internalInstance", ".", "_debugID", ")", ";", "}", "}", "}" ]

[ "Flush", "any", "dirty", "changes", "in", "a", "component", "." ]

[ "function", "(", "publicInstance", ",", "completeState", ",", "callback", ")", "{", "var", "internalInstance", "=", "getInternalInstanceReadyForUpdate", "(", "publicInstance", ",", "'replaceState'", ")", ";", "if", "(", "!", "internalInstance", ")", "{", "return", ";", "}", "internalInstance", ".", "_pendingStateQueue", "=", "[", "completeState", "]", ";", "internalInstance", ".", "_pendingReplaceState", "=", "true", ";", "// Future-proof 15.5", "if", "(", "callback", "!==", "undefined", "&&", "callback", "!==", "null", ")", "{", "ReactUpdateQueue", ".", "validateCallback", "(", "callback", ",", "'replaceState'", ")", ";", "if", "(", "internalInstance", ".", "_pendingCallbacks", ")", "{", "internalInstance", ".", "_pendingCallbacks", ".", "push", "(", "callback", ")", ";", "}", "else", "{", "internalInstance", ".", "_pendingCallbacks", "=", "[", "callback", "]", ";", "}", "}", "enqueueUpdate", "(", "internalInstance", ")", ";", "}" ]

[ "Replaces", "all", "of", "the", "state", ".", "Always", "use", "this", "or", "setState", "to", "mutate", "state", ".", "You", "should", "treat", "this", ".", "state", "as", "immutable", "." ]

[ "function", "cps", "(", "fun", ")", "{", "/**\n * @param {...*} args\n * @param {Function} callback\n */", "return", "function", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "var", "callback", "=", "args", ".", "pop", "(", ")", ";", "var", "result", ";", "try", "{", "result", "=", "fun", ".", "apply", "(", "this", ",", "args", ")", ";", "}", "catch", "(", "err", ")", "{", "callback", "(", "err", ")", ";", "return", ";", "}", "callback", "(", "null", ",", "result", ")", ";", "}", "}" ]

[ "Returns", "function", "that", "provides", "results", "of", "fun", "in", "continuation", "-", "passing", "style" ]

[ "function", "setIceServers", "(", ")", "{", "if", "(", "stunServers", ")", "{", "for", "(", "var", "num", "=", "0", ";", "num", "<", "stunServers", ".", "length", ";", "num", "++", ")", "{", "connConfig", "[", "'iceServers'", "]", ".", "push", "(", "{", "'urls'", ":", "'stun:'", "+", "stunServers", "[", "num", "]", "}", ")", ";", "}", "}", "}" ]

[ "parses", "stun", "server", "array", "and", "returns", "rtc", "friendly", "object" ]

[ "function", "iceCandidateCallback", "(", "e", ")", "{", "if", "(", "e", ".", "candidate", "!=", "null", ")", "{", "if", "(", "scope", ".", "onIceCandidate", ")", "{", "scope", ".", "onIceCandidate", "(", "scope", ",", "JSON", ".", "stringify", "(", "{", "'ice'", ":", "e", ".", "candidate", "}", ")", ")", ";", "}", "}", "}" ]

[ "callback", "for", "ice", "candidate" ]

[ "function", "onStateChange", "(", "e", ")", "{", "if", "(", "scope", ".", "_conn", ")", "{", "if", "(", "scope", ".", "_conn", ".", "iceConnectionState", "==", "\"connected\"", ")", "{", "if", "(", "scope", ".", "onConnected", ")", "{", "scope", ".", "onConnected", "(", "scope", ")", ";", "}", "}", "if", "(", "scope", ".", "_conn", ".", "iceConnectionState", "==", "\"failed\"", "||", "scope", ".", "_conn", ".", "iceConnectionState", "==", "\"disconnected\"", ")", "{", "if", "(", "scope", ".", "onConnectionFail", ")", "{", "scope", ".", "onConnectionFail", "(", "scope", ")", ";", "}", "if", "(", "scope", ".", "type", "==", "\"offer\"", ")", "{", "scope", ".", "createOffer", "(", ")", ";", "}", "}", "if", "(", "scope", ".", "_conn", ".", "iceConnectionState", "==", "\"closed\"", ")", "{", "if", "(", "scope", ".", "onClosed", ")", "{", "scope", ".", "onClosed", "(", "scope", ")", ";", "}", "scope", ".", "dispose", "(", ")", ";", "}", "}", "}" ]

[ "called", "when", "ice", "connection", "state", "is", "changed" ]

[ "function", "remoteStreamCallback", "(", "e", ")", "{", "scope", ".", "remoteStream", "=", "e", ".", "stream", ";", "if", "(", "scope", ".", "onRemoteStream", ")", "{", "scope", ".", "onRemoteStream", "(", "scope", ".", "remoteStream", ")", ";", "}", "}" ]

[ "called", "when", "remote", "stream", "is", "connected" ]

[ "function", "ondatachannel", "(", "e", ")", "{", "if", "(", "e", ")", "{", "scope", ".", "_data", "=", "e", ".", "channel", ";", "}", "else", "{", "scope", ".", "_data", "=", "scope", ".", "_conn", ".", "createDataChannel", "(", "\"data\"", ")", ";", "}", "scope", ".", "_data", ".", "onopen", "=", "function", "(", ")", "{", "if", "(", "scope", ".", "_data", ")", "{", "if", "(", "scope", ".", "_data", ".", "readyState", "==", "\"open\"", ")", "{", "if", "(", "scope", ".", "onChannelState", ")", "{", "scope", ".", "onChannelState", "(", "scope", ",", "'open'", ")", ";", "}", "}", "}", "}", ";", "scope", ".", "_data", ".", "onmessage", "=", "function", "(", "e", ")", "{", "if", "(", "e", ".", "data", "instanceof", "ArrayBuffer", ")", "{", "if", "(", "scope", ".", "onBytesMessage", ")", "{", "scope", ".", "onBytesMessage", "(", "scope", ",", "e", ".", "data", ")", ";", "}", "}", "else", "{", "if", "(", "scope", ".", "onMessage", ")", "{", "var", "char", "=", "Number", "(", "e", ".", "data", "[", "0", "]", ")", ";", "if", "(", "char", "==", "MessageType", ".", "MESSAGE", ")", "{", "scope", ".", "onMessage", "(", "scope", ",", "JSON", ".", "parse", "(", "e", ".", "data", ".", "substring", "(", "1", ",", "e", ".", "data", ".", "length", ")", ")", ")", ";", "}", "else", "{", "scope", ".", "onMessage", "(", "scope", ",", "e", ".", "data", ")", ";", "}", "}", "}", "}", "scope", ".", "_data", ".", "onclose", "=", "function", "(", "e", ")", "{", "if", "(", "scope", ".", "onChannelState", ")", "{", "scope", ".", "onChannelState", "(", "scope", ",", "'closed'", ")", ";", "}", "}", "scope", ".", "_data", ".", "onerror", "=", "function", "(", "e", ")", "{", "if", "(", "scope", ".", "onError", ")", "{", "scope", ".", "onError", "(", "e", ")", ";", "}", "}", "}" ]

[ "called", "when", "datachannel", "event", "is", "invoked", "also", "called", "manually", "from", "offer", "to", "create", "new", "datachannel" ]

[ "function", "expandSmartyPathAttr", "(", "content", ",", "tagName", ",", "attrName", ",", "file", ")", "{", "var", "attrReg", "=", "new", "RegExp", "(", "'((?:^|\\\\s)'", "+", "her", ".", "util", ".", "pregQuote", "(", "attrName", ")", "+", "'\\\\s*=\\\\s*)(([\\\"\\']).*?\\\\3)'", ",", "'ig'", ")", ";", "content", "=", "tagFilter", ".", "filterTag", "(", "content", ",", "tagName", ",", "smarty_left_delimiter", ",", "smarty_right_delimiter", ",", "function", "(", "outter", ",", "attr", ")", "{", "attr", "=", "attr", ".", "replace", "(", "attrReg", ",", "function", "(", "all", ",", "preCodeHolder", ",", "valueCodeHolder", ")", "{", "var", "info", "=", "her", ".", "util", ".", "stringQuote", "(", "valueCodeHolder", ")", ";", "var", "path", "=", "info", ".", "rest", ";", "var", "ret", "=", "info", ".", "quote", "+", "her", ".", "uri", ".", "getId", "(", "path", ",", "file", ".", "dirname", ")", ".", "id", "+", "info", ".", "quote", ";", "return", "preCodeHolder", "+", "ret", ";", "}", ")", ";", "outter", "=", "smarty_left_delimiter", "+", "tagName", "+", "attr", "+", "smarty_right_delimiter", ";", "return", "outter", ";", "}", ")", ";", "return", "content", ";", "}" ]

[ "expand", "smarty", "template", "resource", "path" ]

[ "function", "deserializeParameter", "(", "server", ",", "name", ",", "value", ",", "schema", ")", "{", "if", "(", "!", "schema", ")", "return", "value", ";", "const", "type", "=", "schemaType", "(", "schema", ")", ";", "if", "(", "!", "type", ")", "server", ".", "log", "(", "'req-params'", ",", "'Indeterminate schema type for parameter '", "+", "name", ",", "schema", ")", ";", "if", "(", "type", "===", "'array'", ")", "{", "const", "format", "=", "schema", ".", "hasOwnProperty", "(", "'collectionFormat'", ")", "?", "schema", ".", "collectionFormat", ":", "'csv'", ";", "const", "delimiter", "=", "format", "===", "'csv'", "?", "','", ":", "format", "===", "'ssv'", "?", "' '", ":", "format", "===", "'tsv'", "?", "'\\t'", ":", "format", "===", "'pipes'", "?", "'|'", ":", "','", ";", "value", "=", "value", ".", "split", "(", "delimiter", ")", ";", "if", "(", "!", "schema", ".", "items", ")", "return", "value", ";", "return", "value", ".", "map", "(", "item", "=>", "{", "return", "deserializeParameter", "(", "server", ",", "'items for '", "+", "name", ",", "item", ",", "schema", ".", "items", ")", ";", "}", ")", ";", "}", "else", "if", "(", "type", "===", "'boolean'", ")", "{", "return", "!", "(", "value", "===", "'false'", "||", "value", "===", "'null'", "||", "value", "===", "'0'", "||", "value", "===", "''", ")", ";", "}", "else", "if", "(", "type", "===", "'integer'", "&&", "rxInteger", ".", "test", "(", "value", ")", ")", "{", "return", "parseInt", "(", "value", ")", ";", "}", "else", "if", "(", "type", "===", "'number'", "&&", "rxNumber", ".", "test", "(", "value", ")", ")", "{", "return", "parseFloat", "(", "value", ")", ";", "}", "else", "{", "return", "value", ";", "}", "}" ]

[ "Deserialize", "a", "single", "parameter", "." ]

[ "function", "schemaType", "(", "schema", ")", "{", "let", "type", ";", "if", "(", "schema", ".", "hasOwnProperty", "(", "'type'", ")", ")", "{", "type", "=", "schema", ".", "type", ";", "}", "else", "if", "(", "schema", ".", "hasOwnProperty", "(", "'properties'", ")", "||", "schema", ".", "hasOwnProperty", "(", "'allOf'", ")", "||", "schema", ".", "hasOwnProperty", "(", "'additionalProperties'", ")", ")", "{", "type", "=", "'object'", ";", "}", "else", "if", "(", "schema", ".", "hasOwnProperty", "(", "'items'", ")", ")", "{", "type", "=", "'array'", ";", "}", "switch", "(", "type", ")", "{", "case", "'array'", ":", "case", "'boolean'", ":", "case", "'file'", ":", "case", "'integer'", ":", "case", "'number'", ":", "case", "'object'", ":", "case", "'string'", ":", "return", "type", ";", "}", "}" ]

[ "Detect", "the", "schema", "type", "." ]

[ "function", "ObjectId", "(", "bytes", ")", "{", "if", "(", "Buffer", ".", "isBuffer", "(", "bytes", ")", ")", "{", "if", "(", "bytes", ".", "length", "!=", "12", ")", "throw", "new", "Error", "(", "\"Buffer-based ObjectId must be 12 bytes\"", ")", "this", ".", "bytes", "=", "bytes", "}", "else", "if", "(", "typeof", "bytes", "==", "'string'", ")", "{", "if", "(", "bytes", ".", "length", "!=", "24", ")", "throw", "new", "Error", "(", "\"String-based ObjectId must be 24 bytes\"", ")", "if", "(", "!", "/", "^[0-9a-f]{24}$", "/", "i", ".", "test", "(", "bytes", ")", ")", "throw", "new", "Error", "(", "\"String-based ObjectId must in hex-format:\"", "+", "bytes", ")", "this", ".", "bytes", "=", "fromHex", "(", "bytes", ")", "}", "else", "if", "(", "typeof", "bytes", "!==", "'undefined'", ")", "{", "throw", "new", "Error", "(", "\"Unrecognized type: \"", "+", "bytes", ")", "}", "else", "{", "var", "timestamp", "=", "(", "Date", ".", "now", "(", ")", "/", "1000", ")", "&", "0xFFFFFFFF", "inc", "=", "~", "~", "inc", "+", "1", "// keep as integer", "this", ".", "bytes", "=", "new", "Buffer", "(", "[", "timestamp", ">>", "24", ",", "timestamp", ">>", "16", ",", "timestamp", ">>", "8", ",", "timestamp", ",", "machineAndPid", "[", "0", "]", ",", "machineAndPid", "[", "1", "]", ",", "machineAndPid", "[", "2", "]", ",", "machineAndPid", "[", "3", "]", ",", "machineAndPid", "[", "4", "]", ",", "inc", ">>", "16", ",", "inc", ">>", "8", ",", "inc", "]", ")", "}", "}" ]

[ "32", "bit", "time", "24", "bit", "machine", "id", "16", "bit", "pid", "24", "bit", "increment" ]

[ "function", "(", "path", ")", "{", "var", "parts", "=", "path", ".", "split", "(", "rpathsplit", ")", ",", "ns", "=", "munit", ".", "ns", ",", "assert", ";", "// Grep for nested path module", "munit", ".", "each", "(", "parts", ",", "function", "(", "part", ")", "{", "if", "(", "assert", "=", "ns", "[", "part", "]", ")", "{", "ns", "=", "assert", ".", "ns", ";", "}", "else", "{", "throw", "new", "munit", ".", "AssertionError", "(", "\"Module path not found '\"", "+", "path", "+", "\"'\"", ",", "munit", ".", "_getModule", ")", ";", "}", "}", ")", ";", "return", "assert", ";", "}" ]

[ "Gets", "module", "on", "path" ]

[ "function", "(", "name", ",", "options", ",", "callback", ")", "{", "var", "ns", "=", "munit", ".", "ns", ",", "parts", "=", "name", ".", "split", "(", "rpathsplit", ")", ",", "finalPart", "=", "parts", ".", "pop", "(", ")", ",", "opts", "=", "munit", ".", "extend", "(", "true", ",", "{", "}", ",", "munit", ".", "defaults", ".", "settings", ")", ",", "assert", "=", "null", ",", "path", "=", "''", ";", "// Filter through all parents", "parts", ".", "forEach", "(", "function", "(", "mod", ")", "{", "// Update the path", "if", "(", "path", ".", "length", ")", "{", "path", "+=", "'.'", ";", "}", "path", "+=", "mod", ";", "// Assign assert module", "if", "(", "!", "ns", "[", "mod", "]", ")", "{", "assert", "=", "ns", "[", "mod", "]", "=", "new", "munit", ".", "Assert", "(", "path", ",", "assert", ",", "opts", ")", ";", "}", "// Trickle down the path", "assert", "=", "ns", "[", "mod", "]", ";", "ns", "=", "assert", ".", "ns", ";", "opts", "=", "munit", ".", "extend", "(", "true", ",", "{", "}", ",", "opts", ",", "assert", ".", "options", ")", ";", "}", ")", ";", "// Module already exists, update it", "if", "(", "ns", "[", "finalPart", "]", ")", "{", "assert", "=", "ns", "[", "finalPart", "]", ";", "// Test module is already in use, code setup is wrong", "if", "(", "assert", ".", "callback", ")", "{", "throw", "new", "munit", ".", "AssertionError", "(", "\"'\"", "+", "name", "+", "\"' module has already been created\"", ",", "munit", ".", "_createModule", ")", ";", "}", "assert", ".", "options", "=", "munit", ".", "extend", "(", "true", ",", "{", "}", ",", "opts", ",", "options", ")", ";", "assert", ".", "callback", "=", "callback", ";", "}", "else", "{", "options", "=", "munit", ".", "extend", "(", "true", ",", "{", "}", ",", "opts", ",", "options", ")", ";", "assert", "=", "ns", "[", "finalPart", "]", "=", "new", "munit", ".", "Assert", "(", "name", ",", "assert", ",", "options", ",", "callback", ")", ";", "}", "// Return the assertion module for use", "return", "assert", ";", "}" ]

[ "Internal", "module", "creation" ]

[ "function", "(", "name", ",", "depends", ",", "callback", ")", "{", "if", "(", "(", "!", "munit", ".", "isString", "(", "depends", ")", "&&", "!", "munit", ".", "isArray", "(", "depends", ")", ")", "||", "!", "depends", ".", "length", ")", "{", "throw", "new", "Error", "(", "\"Depends argument not found\"", ")", ";", "}", "return", "munit", ".", "_module", "(", "name", ",", "{", "depends", ":", "depends", "}", ",", "callback", ")", ";", "}" ]

[ "Creating", "module", "with", "dependencies" ]

[ "function", "(", "name", ",", "handle", ")", "{", "if", "(", "munit", ".", "isObject", "(", "name", ")", ")", "{", "return", "munit", ".", "each", "(", "name", ",", "function", "(", "fn", ",", "method", ")", "{", "munit", ".", "custom", "(", "method", ",", "fn", ")", ";", "}", ")", ";", "}", "// Ensure that name can be used", "if", "(", "munit", ".", "customReserved", ".", "indexOf", "(", "name", ")", ">", "-", "1", ")", "{", "throw", "new", "Error", "(", "\"'\"", "+", "name", "+", "\"' is a reserved name and cannot be added as a custom assertion test\"", ")", ";", "}", "// Send off to assertion module for attachment", "munit", ".", "Assert", ".", "prototype", "[", "name", "]", "=", "handle", ";", "munit", ".", "each", "(", "munit", ".", "ns", ",", "function", "(", "mod", ")", "{", "mod", ".", "custom", "(", "name", ",", "handle", ")", ";", "}", ")", ";", "}" ]

[ "Adding", "custom", "test", "comparisons" ]

[ "function", "(", "time", ")", "{", "var", "h", ",", "m", ",", "s", ";", "if", "(", "time", ">", "TIME_MINUTE", ")", "{", "m", "=", "parseInt", "(", "time", "/", "TIME_MINUTE", ",", "10", ")", ";", "s", "=", "(", "time", "%", "TIME_MINUTE", ")", "/", "TIME_SECOND", ";", "return", "m", "+", "'mins, '", "+", "s", "+", "'s'", ";", "}", "else", "if", "(", "time", ">", "TIME_SECOND", ")", "{", "return", "(", "time", "/", "TIME_SECOND", ")", "+", "'s'", ";", "}", "else", "{", "return", "time", "+", "'ms'", ";", "}", "}" ]

[ "Better", "timestamp", "readability" ]

[ "function", "(", "string", ")", "{", "return", "(", "string", "||", "''", ")", ".", "replace", "(", "ramp", ",", "\"&amp;\"", ")", ".", "replace", "(", "rquote", ",", "\"&quot;\"", ")", ".", "replace", "(", "rsquote", ",", "\"&#039;\"", ")", ".", "replace", "(", "rlt", ",", "\"&lt;\"", ")", ".", "replace", "(", "rgt", ",", "\"&gt;\"", ")", ";", "}" ]

[ "Converts", "strings", "to", "be", "xml", "safe" ]

[ "function", "(", "code", ",", "e", ",", "message", ")", "{", "var", "callback", "=", "munit", ".", "render", ".", "callback", ";", "// Force a numeric code for the first parameter", "if", "(", "!", "munit", ".", "isNumber", "(", "code", ")", ")", "{", "throw", "new", "Error", "(", "\"Numeric code parameter required for munit.exit\"", ")", ";", "}", "// Allow code, message only arguments", "if", "(", "message", "===", "undefined", "&&", "munit", ".", "isString", "(", "e", ")", ")", "{", "message", "=", "e", ";", "e", "=", "null", ";", "}", "// Messaging", "if", "(", "munit", ".", "isString", "(", "message", ")", ")", "{", "munit", ".", "color", ".", "red", "(", "message", ")", ";", "}", "// Force an error object for callbacks", "if", "(", "!", "munit", ".", "isError", "(", "e", ")", ")", "{", "e", "=", "new", "Error", "(", "message", "||", "'munit exited'", ")", ";", "}", "e", ".", "code", "=", "code", ";", "// Only print out stack trace on an active process", "if", "(", "munit", ".", "render", ".", "state", "!==", "munit", ".", "RENDER_STATE_COMPLETE", ")", "{", "munit", ".", "log", "(", "e", ".", "stack", ")", ";", "}", "// Callback takes priority", "if", "(", "callback", ")", "{", "munit", ".", "render", ".", "callback", "=", "undefined", ";", "callback", "(", "e", ",", "munit", ")", ";", "}", "// No callback, end the process", "else", "{", "munit", ".", "_exit", "(", "code", ")", ";", "}", "}" ]

[ "Helper", "for", "printing", "out", "errors", "before", "exiting" ]

[ "function", "AssertionError", "(", "message", ",", "startFunc", ")", "{", "var", "self", "=", "this", ";", "self", ".", "name", "=", "'Assertion Error'", ";", "self", ".", "message", "=", "message", ";", "if", "(", "Error", ".", "captureStackTrace", ")", "{", "Error", ".", "captureStackTrace", "(", "self", ",", "startFunc", ")", ";", "}", "}" ]

[ "AssertionError", "stolen", "from", "node", "src", "for", "throwing" ]

[ "function", "buildFromString", "(", "{", "declaration", ",", "name", ",", "mapActionType", "}", ")", "{", "if", "(", "typeof", "declaration", "===", "'string'", ")", "{", "return", "arg", "=>", "(", "{", "type", ":", "mapActionType", "(", "name", ")", ",", "[", "declaration", "]", ":", "arg", ",", "}", ")", ";", "}", "return", "null", ";", "}" ]

[ "Strings", "-", ">", "simple", "action", "creatos", "with", "one", "argument" ]

[ "function", "buildFromArray", "(", "{", "declaration", ",", "name", ",", "mapActionType", "}", ")", "{", "if", "(", "Array", ".", "isArray", "(", "declaration", ")", ")", "{", "return", "(", "...", "args", ")", "=>", "declaration", ".", "reduce", "(", "(", "result", ",", "key", ",", "index", ")", "=>", "Object", ".", "assign", "(", "result", ",", "{", "[", "key", "]", ":", "args", "[", "index", "]", "}", ")", ",", "{", "type", ":", "mapActionType", "(", "name", ")", "}", ")", ";", "}", "return", "null", ";", "}" ]

[ "Arrays", "-", ">", "simple", "action", "creators", "with", "multiple", "arguments" ]

[ "function", "buildFromObject", "(", "{", "declaration", ",", "name", ",", "mapActionType", "}", ")", "{", "if", "(", "typeof", "declaration", "===", "'object'", ")", "{", "return", "(", ")", "=>", "ensureActionType", "(", "declaration", ",", "name", ",", "mapActionType", ")", ";", "}", "return", "null", ";", "}" ]

[ "Objects", "-", ">", "simplea", "action", "creator", "with", "fixed", "payload" ]

[ "function", "(", ")", "{", "var", "html", "=", "template", "(", ")", ";", "var", "div", "=", "document", ".", "createElement", "(", "'div'", ")", ";", "div", ".", "innerHTML", "=", "html", ".", "trim", "(", ")", ";", "var", "searchBar", "=", "this", ".", "applySearcbarEvents", "(", "div", ".", "firstChild", ")", ";", "searchBar", "=", "this", ".", "setDefaultSearchTerm", "(", "searchBar", ")", ";", "return", "searchBar", ";", "}" ]

[ "Parses", "the", "searchbar", "template", "into", "an", "HTML", "string", "." ]

[ "function", "(", "searchbar", ")", "{", "var", "that", "=", "this", ";", "var", "button", "=", "searchbar", ".", "querySelector", "(", "'button[type=submit]'", ")", ";", "var", "search", "=", "searchbar", ".", "querySelector", "(", "'input[type=search]'", ")", ";", "if", "(", "typeof", "button", "===", "'undefined'", ")", "{", "return", "searchbar", ";", "}", "button", ".", "onclick", "=", "function", "(", "ev", ")", "{", "ev", ".", "preventDefault", "(", ")", ";", "that", ".", "emitter", ".", "emit", "(", "'search-request'", ",", "search", ")", ";", "}", ";", "return", "searchbar", ";", "}" ]

[ "Applies", "onclick", "events", "to", "this", "searchbar", "." ]

[ "function", "render", "(", "code", ",", "data", ")", "{", "var", "js", "=", "'```js'", "+", "code", "+", "'```'", "return", "`", "${", "marked", "(", "js", ")", "}", "${", "code", "}", "${", "JSON", ".", "stringify", "(", "data", ".", "data", ")", "}", "`", "}" ]

[ "Render", "code", "and", "live", "example", "." ]

[ "function", "route", "(", "name", ",", "titleToken", ",", "options", ")", "{", "var", "path", ",", "match", ";", "if", "(", "name", "instanceof", "RouteMeta", ")", "{", "return", "name", ";", "}", "if", "(", "name", ")", "{", "match", "=", "name", ".", "match", "(", "/", "^([^@]+)(?:@(.*))?$", "/", ")", ";", "name", "=", "match", "[", "1", "]", ";", "path", "=", "match", "[", "2", "]", ";", "if", "(", "path", "===", "undefined", ")", "{", "path", "=", "name", "===", "'index'", "?", "'/'", ":", "name", ";", "}", "else", "if", "(", "path", "===", "''", ")", "{", "path", "=", "'/'", ";", "}", "else", "if", "(", "path", "===", "'*'", ")", "{", "path", "=", "'/*wildcard'", ";", "}", "}", "else", "{", "path", "=", "'/'", ";", "}", "return", "RouteMeta", ".", "create", "(", "{", "name", ":", "name", "||", "'application'", ",", "path", ":", "path", ",", "routerTitleToken", ":", "{", "value", ":", "titleToken", "}", ",", "options", ":", "options", "||", "{", "}", "}", ")", ";", "}" ]

[ "Build", "the", "Ember", "expected", "map", "for", "a", "route" ]

[ "function", "(", "target", ")", "{", "if", "(", "this", ".", "get", "(", "'isResource'", ")", "&&", "!", "this", ".", "get", "(", "'indexChild'", ")", ")", "{", "// add index route if it does not exist", "this", ".", "_route", "(", "'index'", ")", ";", "}", "this", ".", "get", "(", "'children'", ")", ".", "forEach", "(", "function", "(", "meta", ")", "{", "var", "args", ",", "methodName", ",", "isResource", ";", "args", "=", "[", "meta", ".", "get", "(", "'name'", ")", ",", "{", "path", ":", "meta", ".", "get", "(", "'path'", ")", "}", "]", ";", "methodName", "=", "meta", ".", "get", "(", "'methodName'", ")", ";", "isResource", "=", "meta", ".", "get", "(", "'isResource'", ")", ";", "if", "(", "isResource", ")", "{", "args", ".", "push", "(", "meta", ".", "get", "(", "'mapFunction'", ")", ")", ";", "}", "console", "[", "isResource", "&&", "console", ".", "group", "?", "'group'", ":", "'log'", "]", "(", "'[enhanced-router] defining '", "+", "meta", ")", ";", "target", "[", "methodName", "]", ".", "apply", "(", "target", ",", "args", ")", ";", "if", "(", "isResource", "&&", "console", ".", "group", ")", "{", "console", ".", "groupEnd", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "The", "method", "doing", "the", "call", "as", "Router", ".", "map", "is", "expecting" ]

[ "function", "(", "name", ",", "titleToken", ",", "options", ")", "{", "var", "child", ";", "if", "(", "!", "this", ".", "get", "(", "'isResource'", ")", ")", "{", "this", ".", "set", "(", "'isResource'", ",", "true", ")", ";", "}", "child", "=", "route", "(", "name", ",", "titleToken", ",", "options", ",", "this", ")", ";", "child", ".", "set", "(", "'parent'", ",", "this", ")", ";", "this", ".", "get", "(", "'children'", ")", ".", "pushObject", "(", "child", ")", ";", "return", "this", ";", "}" ]

[ "Define", "a", "child", "-", "route", "to", "this", "route" ]

[ "function", "(", ")", "{", "var", "routes", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "if", "(", "routes", ".", "length", ")", "{", "Ember", ".", "A", "(", "routes", ")", ".", "forEach", "(", "function", "(", "child", ")", "{", "this", ".", "_route", "(", "child", ")", ";", "}", ",", "this", ")", ";", "}", "else", "{", "if", "(", "!", "this", ".", "get", "(", "'isResource'", ")", ")", "{", "this", ".", "set", "(", "'isResource'", ",", "true", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Define", "many", "child", "-", "routes", "to", "this", "route" ]

[ "function", "(", "options", ")", "{", "var", "Router", ",", "args", ";", "if", "(", "this", ".", "get", "(", "'parent'", ")", ")", "{", "throw", "new", "Error", "(", "'Only the root route may be exported as an Ember router.'", ")", ";", "}", "args", "=", "slice", ".", "call", "(", "arguments", ")", ";", "if", "(", "!", "args", ".", "length", "||", "args", "[", "args", ".", "length", "-", "1", "]", "instanceof", "Ember", ".", "Mixin", ")", "{", "args", ".", "push", "(", "options", "=", "{", "}", ")", ";", "}", "else", "{", "options", "=", "args", "[", "args", ".", "length", "-", "1", "]", ";", "}", "options", ".", "_enhancedRouterRootMeta", "=", "this", ";", "Router", "=", "Ember", ".", "Router", ".", "extend", ".", "apply", "(", "Ember", ".", "Router", ",", "args", ")", ";", "Router", ".", "map", "(", "this", ".", "get", "(", "'mapFunction'", ")", ")", ";", "return", "Router", ";", "}" ]

[ "Transforms", "this", "RouteMeta", "into", "an", "Ember", "router" ]

[ "function", "fuf", "(", "target", ",", "source", ",", "options", "=", "{", "}", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "if", "(", "!", "target", ")", "{", "return", "reject", "(", "new", "Error", "(", "'the target path is required'", ")", ")", "}", "if", "(", "!", "source", ")", "{", "return", "reject", "(", "new", "Error", "(", "'the source path is required'", ")", ")", "}", "if", "(", "options", "&&", "MATCHES", ".", "indexOf", "(", "options", ".", "match", ")", "===", "-", "1", ")", "{", "return", "reject", "(", "new", "Error", "(", "`", "${", "MATCHES", ".", "join", "(", "', '", ")", "}", "`", ")", ")", "}", "options", "=", "{", "...", "defaults", ",", "...", "options", "}", "Promise", ".", "all", "(", "[", "pglob", "(", "target", ",", "{", "nodir", ":", "true", ",", "ignore", ":", "source", "}", ")", ",", "findSourceFiles", "(", "source", ")", ",", "]", ")", ".", "then", "(", "(", "[", "targetFiles", ",", "sourceFiles", "]", ")", "=>", "{", "// By default all source files are considered unused.", "const", "unused", "=", "sourceFiles", ".", "map", "(", "file", "=>", "(", "{", "...", "file", "}", ")", ")", "// We loop through all files looking for unused files matches, when we", "// found a match we removed it from the unused bag.", "const", "results", "=", "targetFiles", ".", "map", "(", "file", "=>", "{", "return", "fs", ".", "readFile", "(", "file", ")", ".", "then", "(", "data", "=>", "{", "const", "matches", "=", "findMatches", "(", "data", ".", "toString", "(", ")", ",", "unused", ".", "map", "(", "u", "=>", "u", "[", "options", ".", "match", "]", ")", ")", "matches", ".", "forEach", "(", "match", "=>", "{", "// Remove match from unused.", "unused", ".", "splice", "(", "unused", ".", "findIndex", "(", "u", "=>", "u", "[", "options", ".", "match", "]", "===", "match", ".", "needle", ")", ",", "1", ")", "// Remove match from source files.", "sourceFiles", ".", "splice", "(", "sourceFiles", ".", "findIndex", "(", "f", "=>", "f", "[", "options", ".", "match", "]", "===", "match", ".", "needle", ")", ",", "1", ")", "}", ")", "}", ")", "}", ")", "Promise", ".", "all", "(", "results", ")", ".", "then", "(", "(", ")", "=>", "{", "resolve", "(", "{", "unused", "}", ")", "}", ")", "}", ")", ".", "catch", "(", "reject", ")", "}", ")", "}" ]

[ "Find", "unused", "files", "." ]

[ "function", "pglob", "(", "pattern", ",", "options", ")", "{", "return", "new", "Promise", "(", "(", "resolve", ",", "reject", ")", "=>", "{", "glob", "(", "pattern", ",", "options", ",", "(", "error", ",", "files", ")", "=>", "{", "if", "(", "error", ")", "{", "return", "reject", "(", "error", ")", "}", "resolve", "(", "files", ")", "}", ")", "}", ")", "}" ]

[ "Promisify", "version", "of", "glob", "." ]

[ "function", "chrootSpawn", "(", "command", ",", "argv", ",", "opts", ",", "callback", ")", "{", "argv", "=", "[", "opts", ".", "uid", ",", "opts", ".", "gid", ",", "command", "]", ".", "concat", "(", "argv", ")", "const", "options", "=", "{", "cwd", ":", "opts", ".", "cwd", ",", "env", ":", "opts", ".", "env", ",", "stdio", ":", "'inherit'", "}", "proc", ".", "spawn", "(", "`", "${", "__dirname", "}", "`", ",", "argv", ",", "options", ")", ".", "on", "(", "'exit'", ",", "callback", ")", "}" ]

[ "Exec", "a", "command", "on", "a", "chroot", "ed", "directory", "with", "un", "-", "priviledged", "permissions" ]

[ "function", "mkdirMountInfo", "(", "info", ",", "callback", ")", "{", "utils", ".", "mkdirMount", "(", "info", ".", "path", ",", "info", ".", "type", ",", "info", ".", "flags", ",", "info", ".", "extras", ",", "callback", ")", "}" ]

[ "Mounts", "the", "provided", "path", "to", "the", "device" ]

[ "function", "create", "(", "upperdir", ",", "callback", ")", "{", "var", "workdir", "=", "upperdir", ".", "split", "(", "'/'", ")", "var", "user", "=", "workdir", ".", "pop", "(", ")", "var", "workdir", "=", "workdir", ".", "join", "(", "'/'", ")", "+", "'/.workdirs/'", "+", "user", "mkdirp", "(", "workdir", ",", "'0100'", ",", "function", "(", "error", ")", "{", "if", "(", "error", "&&", "error", ".", "code", "!==", "'EEXIST'", ")", "return", "callback", "(", "error", ")", "// Craft overlayed filesystem", "var", "type", "=", "'overlay'", "var", "extras", "=", "{", "lowerdir", ":", "'/'", ",", "upperdir", ":", "upperdir", ",", "workdir", ":", "workdir", "}", "utils", ".", "mkdirMount", "(", "upperdir", ",", "type", ",", "MS_NOSUID", ",", "extras", ",", "function", "(", "error", ")", "{", "if", "(", "error", ")", "return", "callback", "(", "error", ")", "var", "arr", "=", "[", "{", "path", ":", "upperdir", "+", "'/dev'", ",", "flags", ":", "MS_BIND", ",", "extras", ":", "{", "devFile", ":", "'/tmp/dev'", "}", "}", ",", "{", "path", ":", "upperdir", "+", "'/proc'", ",", "flags", ":", "MS_BIND", ",", "extras", ":", "{", "devFile", ":", "'/proc'", "}", "}", ",", "{", "path", ":", "upperdir", "+", "'/tmp'", ",", "type", ":", "'tmpfs'", ",", "flags", ":", "MS_NODEV", "|", "MS_NOSUID", "}", "]", "each", "(", "arr", ",", "mkdirMountInfo", ",", "callback", ")", "}", ")", "}", ")", "}" ]

[ "Public", "API", "Execute", "the", "command", "file" ]

[ "function", "clas", "(", "elem", ",", "className", ")", "{", "/**\n * @param {boolean} [val]\n * @returns {boolean|undefined}\n */", "return", "function", "(", ")", "{", "if", "(", "arguments", ".", "length", ")", "{", "elem", ".", "classList", "[", "arguments", "[", "0", "]", "?", "\"add\"", ":", "\"remove\"", "]", "(", "className", ")", ";", "}", "else", "{", "return", "elem", ".", "classList", ".", "has", "(", "className", ")", ";", "}", "}", "}" ]

[ "Create", "function", "bound", "to", "DOM", "class", ".", "Class", "will", "be", "enabled", "when", "function", "is", "called", "with", "truthy", "value", "and", "disabled", "when", "called", "with", "falsey", "value", ".", "When", "called", "without", "an", "argument", "the", "function", "will", "return", "a", "boolean", "indicating", "if", "the", "class", "is", "set", "." ]

[ "function", "formatStr", "(", "str", ",", "values", ")", "{", "values", "=", "values", "||", "{", "}", ";", "if", "(", "typeof", "str", "!==", "'string'", ")", "{", "return", "str", ";", "}", "return", "str", ".", "replace", "(", "FORMAT_REGEXP", ",", "(", "m0", ",", "m1", ",", "m2", ")", "=>", "(", "m1", "===", "'%'", "?", "\"%{\"", "+", "m2", "+", "\"}\"", ":", "values", "[", "m2", "]", ")", ")", ";", "}" ]

[ "Format", "string", "with", "patterns" ]

[ "function", "(", "keyCode", ",", "strokesPerSnapshotExceeded", ")", "{", "var", "keyGroup", "=", "UndoManager", ".", "getKeyGroup", "(", "keyCode", ")", ",", "// Count of keystrokes in current a row.\r", "// Note if strokesPerSnapshotExceeded will be exceeded, it'll be restarted.\r", "strokesRecorded", "=", "this", ".", "strokesRecorded", "[", "keyGroup", "]", "+", "1", ";", "strokesPerSnapshotExceeded", "=", "(", "strokesPerSnapshotExceeded", "||", "strokesRecorded", ">=", "this", ".", "strokesLimit", ")", ";", "if", "(", "!", "this", ".", "typing", ")", "onTypingStart", "(", "this", ")", ";", "if", "(", "strokesPerSnapshotExceeded", ")", "{", "// Reset the count of strokes, so it'll be later assigned to this.strokesRecorded.\r", "strokesRecorded", "=", "0", ";", "this", ".", "editor", ".", "fire", "(", "'saveSnapshot'", ")", ";", "}", "else", "{", "// Fire change event.\r", "this", ".", "editor", ".", "fire", "(", "'change'", ")", ";", "}", "// Store recorded strokes count.\r", "this", ".", "strokesRecorded", "[", "keyGroup", "]", "=", "strokesRecorded", ";", "// This prop will tell in next itaration what kind of group was processed previously.\r", "this", ".", "previousKeyGroup", "=", "keyGroup", ";", "}" ]

[ "Handles", "keystroke", "support", "for", "the", "undo", "manager", ".", "It", "is", "called", "on", "keyup", "event", "for", "keystrokes", "that", "can", "change", "the", "editor", "content", "." ]

[ "function", "(", ")", "{", "// Stack for all the undo and redo snapshots, they're always created/removed\r", "// in consistency.\r", "this", ".", "snapshots", "=", "[", "]", ";", "// Current snapshot history index.\r", "this", ".", "index", "=", "-", "1", ";", "this", ".", "currentImage", "=", "null", ";", "this", ".", "hasUndo", "=", "false", ";", "this", ".", "hasRedo", "=", "false", ";", "this", ".", "locked", "=", "null", ";", "this", ".", "resetType", "(", ")", ";", "}" ]

[ "Resets", "the", "undo", "stack", "." ]

[ "function", "(", "onContentOnly", ",", "image", ",", "autoFireChange", ")", "{", "var", "editor", "=", "this", ".", "editor", ";", "// Do not change snapshots stack when locked, editor is not ready,\r", "// editable is not ready or when editor is in mode difference than 'wysiwyg'.\r", "if", "(", "this", ".", "locked", "||", "editor", ".", "status", "!=", "'ready'", "||", "editor", ".", "mode", "!=", "'wysiwyg'", ")", "return", "false", ";", "var", "editable", "=", "editor", ".", "editable", "(", ")", ";", "if", "(", "!", "editable", "||", "editable", ".", "status", "!=", "'ready'", ")", "return", "false", ";", "var", "snapshots", "=", "this", ".", "snapshots", ";", "// Get a content image.\r", "if", "(", "!", "image", ")", "image", "=", "new", "Image", "(", "editor", ")", ";", "// Do nothing if it was not possible to retrieve an image.\r", "if", "(", "image", ".", "contents", "===", "false", ")", "return", "false", ";", "// Check if this is a duplicate. In such case, do nothing.\r", "if", "(", "this", ".", "currentImage", ")", "{", "if", "(", "image", ".", "equalsContent", "(", "this", ".", "currentImage", ")", ")", "{", "if", "(", "onContentOnly", ")", "return", "false", ";", "if", "(", "image", ".", "equalsSelection", "(", "this", ".", "currentImage", ")", ")", "return", "false", ";", "}", "else", "if", "(", "autoFireChange", "!==", "false", ")", "{", "editor", ".", "fire", "(", "'change'", ")", ";", "}", "}", "// Drop future snapshots.\r", "snapshots", ".", "splice", "(", "this", ".", "index", "+", "1", ",", "snapshots", ".", "length", "-", "this", ".", "index", "-", "1", ")", ";", "// If we have reached the limit, remove the oldest one.\r", "if", "(", "snapshots", ".", "length", "==", "this", ".", "limit", ")", "snapshots", ".", "shift", "(", ")", ";", "// Add the new image, updating the current index.\r", "this", ".", "index", "=", "snapshots", ".", "push", "(", "image", ")", "-", "1", ";", "this", ".", "currentImage", "=", "image", ";", "if", "(", "autoFireChange", "!==", "false", ")", "this", ".", "refreshState", "(", ")", ";", "return", "true", ";", "}" ]

[ "Saves", "a", "snapshot", "of", "the", "document", "image", "for", "later", "retrieval", "." ]

[ "function", "(", "isUndo", ")", "{", "var", "snapshots", "=", "this", ".", "snapshots", ",", "currentImage", "=", "this", ".", "currentImage", ",", "image", ",", "i", ";", "if", "(", "currentImage", ")", "{", "if", "(", "isUndo", ")", "{", "for", "(", "i", "=", "this", ".", "index", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "image", "=", "snapshots", "[", "i", "]", ";", "if", "(", "!", "currentImage", ".", "equalsContent", "(", "image", ")", ")", "{", "image", ".", "index", "=", "i", ";", "return", "image", ";", "}", "}", "}", "else", "{", "for", "(", "i", "=", "this", ".", "index", "+", "1", ";", "i", "<", "snapshots", ".", "length", ";", "i", "++", ")", "{", "image", "=", "snapshots", "[", "i", "]", ";", "if", "(", "!", "currentImage", ".", "equalsContent", "(", "image", ")", ")", "{", "image", ".", "index", "=", "i", ";", "return", "image", ";", "}", "}", "}", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "closest", "available", "image", "." ]