Datasets:

---

CM

/

codexglue_code2text_javascript

like 12

[ "function", "(", "newImage", ")", "{", "// Do not change snapshots stack is locked.\r", "if", "(", "this", ".", "locked", ")", "return", ";", "if", "(", "!", "newImage", ")", "newImage", "=", "new", "Image", "(", "this", ".", "editor", ")", ";", "var", "i", "=", "this", ".", "index", ",", "snapshots", "=", "this", ".", "snapshots", ";", "// Find all previous snapshots made for the same content (which differ\r", "// only by selection) and replace all of them with the current image.\r", "while", "(", "i", ">", "0", "&&", "this", ".", "currentImage", ".", "equalsContent", "(", "snapshots", "[", "i", "-", "1", "]", ")", ")", "i", "-=", "1", ";", "snapshots", ".", "splice", "(", "i", ",", "this", ".", "index", "-", "i", "+", "1", ",", "newImage", ")", ";", "this", ".", "index", "=", "i", ";", "this", ".", "currentImage", "=", "newImage", ";", "}" ]

[ "Updates", "the", "last", "snapshot", "of", "the", "undo", "stack", "with", "the", "current", "editor", "content", "." ]

[ "function", "(", ")", "{", "if", "(", "this", ".", "locked", ")", "{", "// Decrease level of lock and check if equals 0, what means that undoM is completely unlocked.\r", "if", "(", "!", "--", "this", ".", "locked", ".", "level", ")", "{", "var", "update", "=", "this", ".", "locked", ".", "update", ";", "this", ".", "locked", "=", "null", ";", "// forceUpdate was passed to lock().\r", "if", "(", "update", "===", "true", ")", "this", ".", "update", "(", ")", ";", "// update is instance of Image.\r", "else", "if", "(", "update", ")", "{", "var", "newImage", "=", "new", "Image", "(", "this", ".", "editor", ",", "true", ")", ";", "if", "(", "!", "update", ".", "equalsContent", "(", "newImage", ")", ")", "this", ".", "update", "(", ")", ";", "}", "}", "}", "}" ]

[ "Unlocks", "the", "snapshot", "stack", "and", "checks", "to", "amend", "the", "last", "snapshot", "." ]

[ "function", "onTypingStart", "(", "undoManager", ")", "{", "// It's safe to now indicate typing state.\r", "undoManager", ".", "typing", "=", "true", ";", "// Manually mark snapshot as available.\r", "undoManager", ".", "hasUndo", "=", "true", ";", "undoManager", ".", "hasRedo", "=", "false", ";", "undoManager", ".", "onChange", "(", ")", ";", "}" ]

[ "Helper", "method", "called", "when", "undoManager", ".", "typing", "val", "was", "changed", "to", "true", "." ]

[ "function", "(", "evt", ")", "{", "// Block undo/redo keystrokes when at the bottom/top of the undo stack (#11126 and #11677).\r", "if", "(", "CKEDITOR", ".", "tools", ".", "indexOf", "(", "keystrokes", ",", "evt", ".", "data", ".", "getKeystroke", "(", ")", ")", ">", "-", "1", ")", "{", "evt", ".", "data", ".", "preventDefault", "(", ")", ";", "return", ";", "}", "// Cleaning tab functional keys.\r", "this", ".", "keyEventsStack", ".", "cleanUp", "(", "evt", ")", ";", "var", "keyCode", "=", "evt", ".", "data", ".", "getKey", "(", ")", ",", "undoManager", "=", "this", ".", "undoManager", ";", "// Gets last record for provided keyCode. If not found will create one.\r", "var", "last", "=", "this", ".", "keyEventsStack", ".", "getLast", "(", "keyCode", ")", ";", "if", "(", "!", "last", ")", "{", "this", ".", "keyEventsStack", ".", "push", "(", "keyCode", ")", ";", "}", "// We need to store an image which will be used in case of key group\r", "// change.\r", "this", ".", "lastKeydownImage", "=", "new", "Image", "(", "undoManager", ".", "editor", ")", ";", "if", "(", "UndoManager", ".", "isNavigationKey", "(", "keyCode", ")", "||", "this", ".", "undoManager", ".", "keyGroupChanged", "(", "keyCode", ")", ")", "{", "if", "(", "undoManager", ".", "strokesRecorded", "[", "0", "]", "||", "undoManager", ".", "strokesRecorded", "[", "1", "]", ")", "{", "// We already have image, so we'd like to reuse it.\r", "undoManager", ".", "save", "(", "false", ",", "this", ".", "lastKeydownImage", ")", ";", "undoManager", ".", "resetType", "(", ")", ";", "}", "}", "}" ]

[ "The", "keydown", "event", "listener", "." ]

[ "function", "(", ")", "{", "// Input event is ignored if paste/drop event were fired before.\r", "if", "(", "this", ".", "ignoreInputEvent", ")", "{", "// Reset flag - ignore only once.\r", "this", ".", "ignoreInputEvent", "=", "false", ";", "return", ";", "}", "var", "lastInput", "=", "this", ".", "keyEventsStack", ".", "getLast", "(", ")", ";", "// Nothing in key events stack, but input event called. Interesting...\r", "// That's because on Android order of events is buggy and also keyCode is set to 0.\r", "if", "(", "!", "lastInput", ")", "{", "lastInput", "=", "this", ".", "keyEventsStack", ".", "push", "(", "0", ")", ";", "}", "// Increment inputs counter for provided key code.\r", "this", ".", "keyEventsStack", ".", "increment", "(", "lastInput", ".", "keyCode", ")", ";", "// Exceeded limit.\r", "if", "(", "this", ".", "keyEventsStack", ".", "getTotalInputs", "(", ")", ">=", "this", ".", "undoManager", ".", "strokesLimit", ")", "{", "this", ".", "undoManager", ".", "type", "(", "lastInput", ".", "keyCode", ",", "true", ")", ";", "this", ".", "keyEventsStack", ".", "resetInputs", "(", ")", ";", "}", "}" ]

[ "The", "input", "event", "listener", "." ]

[ "function", "(", "evt", ")", "{", "var", "undoManager", "=", "this", ".", "undoManager", ",", "keyCode", "=", "evt", ".", "data", ".", "getKey", "(", ")", ",", "totalInputs", "=", "this", ".", "keyEventsStack", ".", "getTotalInputs", "(", ")", ";", "// Remove record from stack for provided key code.\r", "this", ".", "keyEventsStack", ".", "remove", "(", "keyCode", ")", ";", "// Second part of the workaround for IEs functional keys bug. We need to check whether something has really\r", "// changed because we blindly mocked the keypress event.\r", "// Also we need to be aware that lastKeydownImage might not be available (#12327).\r", "if", "(", "UndoManager", ".", "ieFunctionalKeysBug", "(", "keyCode", ")", "&&", "this", ".", "lastKeydownImage", "&&", "this", ".", "lastKeydownImage", ".", "equalsContent", "(", "new", "Image", "(", "undoManager", ".", "editor", ",", "true", ")", ")", ")", "{", "return", ";", "}", "if", "(", "totalInputs", ">", "0", ")", "{", "undoManager", ".", "type", "(", "keyCode", ")", ";", "}", "else", "if", "(", "UndoManager", ".", "isNavigationKey", "(", "keyCode", ")", ")", "{", "// Note content snapshot has been checked in keydown.\r", "this", ".", "onNavigationKey", "(", "true", ")", ";", "}", "}" ]

[ "The", "keyup", "event", "listener", "." ]

[ "function", "(", "skipContentCompare", ")", "{", "var", "undoManager", "=", "this", ".", "undoManager", ";", "// We attempt to save content snapshot, if content didn't change, we'll\r", "// only amend selection.\r", "if", "(", "skipContentCompare", "||", "!", "undoManager", ".", "save", "(", "true", ",", "null", ",", "false", ")", ")", "undoManager", ".", "updateSelection", "(", "new", "Image", "(", "undoManager", ".", "editor", ")", ")", ";", "undoManager", ".", "resetType", "(", ")", ";", "}" ]

[ "Method", "called", "for", "navigation", "change", ".", "At", "first", "it", "will", "check", "if", "current", "content", "does", "not", "differ", "from", "the", "last", "saved", "snapshot", "." ]

[ "function", "(", ")", "{", "var", "editor", "=", "this", ".", "undoManager", ".", "editor", ",", "editable", "=", "editor", ".", "editable", "(", ")", ",", "that", "=", "this", ";", "// We'll create a snapshot here (before DOM modification), because we'll\r", "// need unmodified content when we got keygroup toggled in keyup.\r", "editable", ".", "attachListener", "(", "editable", ",", "'keydown'", ",", "function", "(", "evt", ")", "{", "that", ".", "onKeydown", "(", "evt", ")", ";", "// On IE keypress isn't fired for functional (backspace/delete) keys.\r", "// Let's pretend that something's changed.\r", "if", "(", "UndoManager", ".", "ieFunctionalKeysBug", "(", "evt", ".", "data", ".", "getKey", "(", ")", ")", ")", "{", "that", ".", "onInput", "(", ")", ";", "}", "}", ",", "null", ",", "null", ",", "999", ")", ";", "// Only IE can't use input event, because it's not fired in contenteditable.\r", "editable", ".", "attachListener", "(", "editable", ",", "(", "CKEDITOR", ".", "env", ".", "ie", "?", "'keypress'", ":", "'input'", ")", ",", "that", ".", "onInput", ",", "that", ",", "null", ",", "999", ")", ";", "// Keyup executes main snapshot logic.\r", "editable", ".", "attachListener", "(", "editable", ",", "'keyup'", ",", "that", ".", "onKeyup", ",", "that", ",", "null", ",", "999", ")", ";", "// On paste and drop we need to ignore input event.\r", "// It would result with calling undoManager.type() on any following key.\r", "editable", ".", "attachListener", "(", "editable", ",", "'paste'", ",", "that", ".", "ignoreInputEventListener", ",", "that", ",", "null", ",", "999", ")", ";", "editable", ".", "attachListener", "(", "editable", ",", "'drop'", ",", "that", ".", "ignoreInputEventListener", ",", "that", ",", "null", ",", "999", ")", ";", "// Click should create a snapshot if needed, but shouldn't cause change event.\r", "// Don't pass onNavigationKey directly as a listener because it accepts one argument which\r", "// will conflict with evt passed to listener.\r", "// #12324 comment:4\r", "editable", ".", "attachListener", "(", "editable", ".", "isInline", "(", ")", "?", "editable", ":", "editor", ".", "document", ".", "getDocumentElement", "(", ")", ",", "'click'", ",", "function", "(", ")", "{", "that", ".", "onNavigationKey", "(", ")", ";", "}", ",", "null", ",", "null", ",", "999", ")", ";", "// When pressing `Tab` key while editable is focused, `keyup` event is not fired.\r", "// Which means that record for `tab` key stays in key events stack.\r", "// We assume that when editor is blurred `tab` key is already up.\r", "editable", ".", "attachListener", "(", "this", ".", "undoManager", ".", "editor", ",", "'blur'", ",", "function", "(", ")", "{", "that", ".", "keyEventsStack", ".", "remove", "(", "9", "/*Tab*/", ")", ";", "}", ",", "null", ",", "null", ",", "999", ")", ";", "}" ]

[ "Attaches", "editable", "listeners", "required", "to", "provide", "the", "undo", "functionality", "." ]

[ "function", "(", "keyCode", ")", "{", "if", "(", "typeof", "keyCode", "!=", "'number'", ")", "{", "return", "this", ".", "stack", ".", "length", "-", "1", ";", "// Last index or -1.\r", "}", "else", "{", "var", "i", "=", "this", ".", "stack", ".", "length", ";", "while", "(", "i", "--", ")", "{", "if", "(", "this", ".", "stack", "[", "i", "]", ".", "keyCode", "==", "keyCode", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}", "}" ]

[ "Returns", "the", "index", "of", "the", "last", "registered", "keyCode", "in", "the", "stack", ".", "If", "no", "keyCode", "is", "provided", "then", "the", "function", "will", "return", "the", "index", "of", "the", "last", "item", ".", "If", "an", "item", "is", "not", "found", "it", "will", "return", "-", "1", "." ]

[ "function", "(", "keyCode", ")", "{", "if", "(", "typeof", "keyCode", "==", "'number'", ")", "{", "var", "last", "=", "this", ".", "getLast", "(", "keyCode", ")", ";", "if", "(", "!", "last", ")", "{", "// %REMOVE_LINE%\r", "throw", "new", "Error", "(", "'Trying to reset inputs count, but could not found by keyCode: '", "+", "keyCode", "+", "'.'", ")", ";", "// %REMOVE_LINE%\r", "}", "// %REMOVE_LINE%\r", "last", ".", "inputs", "=", "0", ";", "}", "else", "{", "var", "i", "=", "this", ".", "stack", ".", "length", ";", "while", "(", "i", "--", ")", "{", "this", ".", "stack", "[", "i", "]", ".", "inputs", "=", "0", ";", "}", "}", "}" ]

[ "Resets", "the", "inputs", "value", "to", "0", "for", "a", "given", "keyCode", "or", "in", "entire", "stack", "if", "a", "keyCode", "is", "not", "specified", "." ]

[ "function", "(", ")", "{", "var", "i", "=", "this", ".", "stack", ".", "length", ",", "total", "=", "0", ";", "while", "(", "i", "--", ")", "{", "total", "+=", "this", ".", "stack", "[", "i", "]", ".", "inputs", ";", "}", "return", "total", ";", "}" ]

[ "Sums", "up", "inputs", "number", "for", "each", "key", "code", "and", "returns", "it", "." ]

[ "function", "(", ")", "{", "$", ".", "fn", ".", "mediumInsert", ".", "settings", ".", "enabled", "=", "false", ";", "$", ".", "fn", ".", "mediumInsert", ".", "insert", ".", "$el", ".", "find", "(", "'.mediumInsert-buttons'", ")", ".", "addClass", "(", "'hide'", ")", ";", "}" ]

[ "Disable", "the", "plugin" ]

[ "function", "(", ")", "{", "$", ".", "fn", ".", "mediumInsert", ".", "settings", ".", "enabled", "=", "true", ";", "$", ".", "fn", ".", "mediumInsert", ".", "insert", ".", "$el", ".", "find", "(", "'.mediumInsert-buttons'", ")", ".", "removeClass", "(", "'hide'", ")", ";", "}" ]

[ "Enable", "the", "plugin" ]

[ "function", "(", "addon", ")", "{", "var", "editor", "=", "$", ".", "fn", ".", "mediumInsert", ".", "settings", ".", "editor", ",", "buttonLabels", "=", "(", "editor", "&&", "editor", ".", "options", ")", "?", "editor", ".", "options", ".", "buttonLabels", ":", "''", ";", "var", "buttons", ";", "if", "(", "$", ".", "fn", ".", "mediumInsert", ".", "settings", ".", "enabled", ")", "{", "buttons", "=", "'<div class=\"mediumInsert-buttons\">'", "+", "'<a class=\"mediumInsert-buttonsShow\">+</a>'", "+", "'<ul class=\"mediumInsert-buttonsOptions medium-editor-toolbar medium-editor-toolbar-active\">'", ";", "}", "else", "{", "buttons", "=", "'<div class=\"mediumInsert-buttons hide\">'", "+", "'<a class=\"mediumInsert-buttonsShow\">+</a>'", "+", "'<ul class=\"mediumInsert-buttonsOptions medium-editor-toolbar medium-editor-toolbar-active\">'", ";", "}", "if", "(", "Object", ".", "keys", "(", "$", ".", "fn", ".", "mediumInsert", ".", "settings", ".", "addons", ")", ".", "length", "===", "0", ")", "{", "return", "false", ";", "}", "if", "(", "typeof", "addon", "===", "'undefined'", ")", "{", "$", ".", "each", "(", "$", ".", "fn", ".", "mediumInsert", ".", "settings", ".", "addons", ",", "function", "(", "i", ")", "{", "buttons", "+=", "'<li>'", "+", "addons", "[", "i", "]", ".", "insertButton", "(", "buttonLabels", ")", "+", "'</li>'", ";", "}", ")", ";", "}", "else", "{", "buttons", "+=", "'<li>'", "+", "addons", "[", "addon", "]", ".", "insertButton", "(", "buttonLabels", ")", "+", "'</li>'", ";", "}", "buttons", "+=", "'</ul></div>'", ";", "return", "buttons", ";", "}" ]

[ "Return", "insert", "buttons", "optionally", "filtered", "by", "addon", "name" ]

[ "function", "update", "(", "item", ",", "model", ",", "data", ",", "funcParams", ")", "{", "var", "working", "=", "[", "]", ";", "var", "definedByData", "=", "[", "]", ";", "_", ".", "forEach", "(", "data", ",", "function", "(", "value", ",", "key", ")", "{", "if", "(", "_", ".", "isFunction", "(", "value", ")", ")", "{", "working", ".", "push", "(", "Promise", ".", "resolve", "(", "value", "(", ")", ")", ".", "then", "(", "function", "(", "val", ")", "{", "item", "[", "key", "]", "=", "val", ";", "}", ")", ")", ";", "}", "else", "item", "[", "key", "]", "=", "value", ";", "definedByData", ".", "push", "(", "value", ")", ";", "}", ")", ";", "_", ".", "forEach", "(", "model", ".", "itemDef", ",", "function", "(", "value", ",", "key", ")", "{", "if", "(", "value", "&&", "value", ".", "__precalc", ")", "{", "var", "func", "=", "value", ".", "__precalc", ",", "previousVal", "=", "data", "[", "key", "]", ";", "working", ".", "push", "(", "Promise", ".", "resolve", "(", "func", ".", "call", "(", "item", ",", "previousVal", ",", "funcParams", "||", "{", "}", ")", ")", ".", "then", "(", "function", "(", "val", ")", "{", "item", "[", "key", "]", "=", "(", "val", "&&", "val", ".", "_stWrapped", ")", "?", "val", ".", "val", ":", "val", ";", "}", ")", ")", ";", "}", "// if the property has not been set from the itemDef yet. This allows item def properties to be changed", "else", "if", "(", "!", "_", ".", "has", "(", "item", ",", "key", ")", "||", "definedByData", ".", "indexOf", "(", "key", ")", "!==", "-", "1", ")", "item", "[", "key", "]", "=", "value", ";", "}", ")", ";", "return", "Promise", ".", "all", "(", "working", ")", ";", "}" ]

[ "Updates", "the", "model", "to", "represent", "the", "given", "data" ]

[ "function", "serverProperties", "(", "item", ",", "model", ",", "props", ")", "{", "var", "result", "=", "{", "}", ";", "var", "toRefresh", "=", "[", "]", ";", "_", ".", "forEach", "(", "props", "||", "item", ",", "function", "(", "val", ",", "key", ")", "{", "if", "(", "val", "==", "null", ")", "return", ";", "if", "(", "val", ".", "_isModelItem", ")", "{", "result", "[", "key", "]", "=", "val", ".", "id", ";", "toRefresh", ".", "push", "(", "val", ")", ";", "}", "else", "if", "(", "_", ".", "isArray", "(", "val", ")", ")", "{", "result", "[", "key", "]", "=", "_", ".", "map", "(", "val", ",", "function", "(", "item", ")", "{", "if", "(", "item", ".", "_isModelItem", ")", "{", "toRefresh", ".", "push", "(", "item", ")", ";", "return", "item", ".", "id", ";", "}", "return", "item", ";", "}", ")", ";", "}", "else", "if", "(", "_", ".", "has", "(", "model", ".", "itemDef", ",", "key", ")", ")", "{", "if", "(", "_", ".", "has", "(", "model", ".", "itemDef", "[", "key", "]", ",", "'__connection'", ")", ")", "result", "[", "key", "]", "=", "val", ";", "}", "else", "result", "[", "key", "]", "=", "val", ";", "}", ")", ";", "return", "{", "properties", ":", "result", ",", "refresh", ":", "toRefresh", "}", ";", "}" ]

[ "Gets", "properties", "to", "be", "synced", "with", "the", "server" ]

[ "function", "create", "(", "item", ",", "model", ",", "data", ")", "{", "var", "serverProps", "=", "serverProperties", "(", "item", ",", "model", ",", "data", ")", ".", "properties", ";", "return", "utils", ".", "socketPut", "(", "model", ".", "io", ",", "model", ".", "url", "+", "'/create/'", ",", "serverProps", ")", ".", "then", "(", "function", "(", "response", ")", "{", "_", ".", "merge", "(", "serverProps", ",", "response", ")", ";", "return", "update", "(", "item", ",", "model", ",", "serverProps", ")", ";", "}", ")", ".", "then", "(", "function", "(", ")", "{", "// Refresh all items that were referenced - some of their properties might change", "return", "Promise", ".", "all", "(", "_", ".", "map", "(", "serverProps", ".", "refresh", ",", "function", "(", "item", ")", "{", "return", "item", ".", "refresh", "(", ")", ";", "}", ")", ")", ";", "}", ")", ";", "}" ]

[ "Creates", "the", "item", "on", "the", "server" ]

[ "function", "modelItem", "(", "data", ",", "model", ")", "{", "var", "res", "=", "{", "}", ";", "utils", ".", "defineProperties", "(", "res", ",", "{", "_isModelItem", ":", "{", "value", ":", "true", "}", ",", "model", ":", "{", "value", ":", "model", ".", "value", "}", ",", "update", ":", "{", "value", ":", "function", "(", "data", ",", "sync", ")", "{", "if", "(", "sync", "==", "null", ")", "sync", "=", "true", ";", "return", "update", "(", "res", ",", "model", ",", "data", ")", ".", "then", "(", "function", "(", ")", "{", "if", "(", "!", "sync", ")", "return", ";", "return", "res", ".", "save", "(", ")", ";", "}", ")", ";", "}", "}", ",", "save", ":", "{", "value", ":", "function", "(", ")", "{", "if", "(", "_", ".", "has", "(", "res", ",", "'id'", ")", ")", "{", "var", "props", "=", "serverProperties", "(", "res", ",", "model", ")", ";", "return", "utils", ".", "socketPost", "(", "model", ".", "io", ",", "model", ".", "url", "+", "'/update/'", "+", "res", ".", "id", ",", "props", ".", "properties", ")", ".", "then", "(", "function", "(", ")", "{", "return", "Promise", ".", "all", "(", "_", ".", "map", "(", "props", ".", "refresh", ",", "function", "(", "item", ")", "{", "return", "item", ".", "refresh", "(", ")", ";", "}", ")", ")", ";", "}", ")", ";", "}", "return", "create", "(", "res", ",", "model", ")", ";", "}", "}", ",", "refresh", ":", "{", "value", ":", "function", "(", ")", "{", "if", "(", "!", "_", ".", "has", "(", "res", ",", "'id'", ")", ")", "return", "create", "(", "res", ",", "model", ")", ";", "return", "utils", ".", "socketGet", "(", "model", ".", "io", ",", "model", ".", "url", "+", "'/'", "+", "res", ".", "id", ")", ".", "then", "(", "function", "(", "data", ")", "{", "return", "update", "(", "res", ",", "model", ",", "data", ",", "{", "noRefresh", ":", "true", "}", ")", ";", "}", ")", ";", "}", "}", ",", "delete", ":", "{", "value", ":", "function", "(", ")", "{", "model", ".", "_removeItem", "(", "res", ")", ";", "return", "utils", ".", "socketDelete", "(", "model", ".", "io", ",", "model", ".", "url", ",", "{", "id", ":", "res", ".", "id", "}", ")", ";", "}", "}", ",", "matches", ":", "{", "value", ":", "function", "(", "query", ")", "{", "return", "utils", ".", "socketGet", "(", "model", ".", "io", ",", "model", ".", "url", ",", "query", ")", ".", "then", "(", "function", "(", "r", ")", "{", "for", "(", "var", "i", "=", "0", ";", "i", "<", "r", ".", "length", ";", "i", "++", ")", "{", "if", "(", "r", "[", "i", "]", ".", "id", "===", "res", ".", "id", ")", "return", "true", ";", "}", "return", "false", ";", "}", ")", ";", "}", "}", ",", "then", ":", "{", "value", ":", "function", "(", ")", "{", "return", "res", ".", "ready", ".", "then", ".", "apply", "(", "res", ".", "ready", ",", "arguments", ")", ";", "}", "}", ",", "catch", ":", "{", "value", ":", "function", "(", ")", "{", "return", "res", ".", "ready", ".", "catch", ".", "apply", "(", "res", ".", "ready", ",", "arguments", ")", ";", "}", "}", "}", ")", ";", "res", ".", "ready", "=", "Promise", ".", "resolve", "(", ")", ";", "update", "(", "res", ",", "model", ",", "data", "||", "{", "}", ")", ";", "return", "res", ";", "}" ]

[ "A", "single", "model", "item", "that", "is", "synced", "with", "the", "server" ]

[ "function", "(", "name", ",", "opt_path", ")", "{", "var", "path", "=", "opt_path", "||", "\"/\"", ";", "/**\n * Sets the cookie\n * @param {string} value value for cookie\n * @param {number?} opt_days number of days until cookie\n * expires. Default = none\n */", "this", ".", "set", "=", "function", "(", "value", ",", "opt_days", ")", "{", "if", "(", "value", "===", "undefined", ")", "{", "this", ".", "erase", "(", ")", ";", "return", ";", "}", "// Cordova/Phonegap doesn't support cookies so use localStorage?", "if", "(", "window", ".", "hftSettings", "&&", "window", ".", "hftSettings", ".", "inApp", ")", "{", "window", ".", "localStorage", ".", "setItem", "(", "name", ",", "value", ")", ";", "return", ";", "}", "var", "expires", "=", "\"\"", ";", "opt_days", "=", "opt_days", "||", "9999", ";", "var", "date", "=", "new", "Date", "(", ")", ";", "date", ".", "setTime", "(", "Date", ".", "now", "(", ")", "+", "Math", ".", "floor", "(", "opt_days", "*", "24", "*", "60", "*", "60", "*", "1000", ")", ")", ";", "// > 32bits. Don't use | 0", "expires", "=", "\"; expires=\"", "+", "date", ".", "toGMTString", "(", ")", ";", "var", "cookie", "=", "encodeURIComponent", "(", "name", ")", "+", "\"=\"", "+", "encodeURIComponent", "(", "value", ")", "+", "expires", "+", "\"; path=\"", "+", "path", ";", "document", ".", "cookie", "=", "cookie", ";", "}", ";", "/**\n * Gets the value of the cookie\n * @return {string?} value of cookie\n */", "this", ".", "get", "=", "function", "(", ")", "{", "// Cordova/Phonegap doesn't support cookies so use localStorage?", "if", "(", "window", ".", "hftSettings", "&&", "window", ".", "hftSettings", ".", "inApp", ")", "{", "return", "window", ".", "localStorage", ".", "getItem", "(", "name", ")", ";", "}", "var", "nameEQ", "=", "encodeURIComponent", "(", "name", ")", "+", "\"=\"", ";", "var", "ca", "=", "document", ".", "cookie", ".", "split", "(", "';'", ")", ";", "for", "(", "var", "i", "=", "0", ";", "i", "<", "ca", ".", "length", ";", "++", "i", ")", "{", "var", "c", "=", "ca", "[", "i", "]", ";", "while", "(", "c", ".", "charAt", "(", "0", ")", "===", "' '", ")", "{", "c", "=", "c", ".", "substring", "(", "1", ",", "c", ".", "length", ")", ";", "}", "if", "(", "c", ".", "indexOf", "(", "nameEQ", ")", "===", "0", ")", "{", "return", "decodeURIComponent", "(", "c", ".", "substring", "(", "nameEQ", ".", "length", ",", "c", ".", "length", ")", ")", ";", "}", "}", "}", ";", "/**\n * Erases the cookie.\n */", "this", ".", "erase", "=", "function", "(", ")", "{", "if", "(", "window", ".", "hftSettings", "&&", "window", ".", "hftSettings", ".", "inApp", ")", "{", "return", "window", ".", "localStorage", ".", "removeItem", "(", "name", ")", ";", "}", "document", ".", "cookie", "=", "this", ".", "set", "(", "\" \"", ",", "-", "1", ")", ";", "}", ";", "}" ]

[ "Represents", "a", "cookie", "." ]

[ "function", "SimpleLogger", "(", ")", "{", "/* This class is a singleton */", "if", "(", "arguments", ".", "callee", ".", "_singletonInstance", ")", "{", "return", "arguments", ".", "callee", ".", "_singletonInstance", ";", "}", "arguments", ".", "callee", ".", "_singletonInstance", "=", "this", ";", "EventEmitter", ".", "call", "(", "this", ")", ";", "// First, some basic loglevels. These can be overridden by the developer if desired.", "this", ".", "LOGLEVELS", "=", "{", "'fatal'", ":", "0", ",", "'error'", ":", "100", ",", "'warning'", ":", "200", ",", "'debug'", ":", "300", ",", "'info'", ":", "400", ",", "'trace'", ":", "500", "}", ";", "// defaults to debug.", "this", ".", "loglevel", "=", "'debug'", ";", "this", ".", "getLogLevelValue", "=", "function", "(", ")", "{", "return", "this", ".", "LOGLEVELS", "[", "this", ".", "loglevel", "]", ";", "}", ";", "this", ".", "log", "=", "function", "(", "level", ",", "message", ",", "fn", ")", "{", "var", "logNumber", "=", "this", ".", "LOGLEVELS", "[", "level", "]", ";", "if", "(", "logNumber", "<=", "this", ".", "getLogLevelValue", "(", ")", ")", "{", "this", ".", "emit", "(", "'log'", ",", "level", ",", "message", ")", ";", "this", ".", "emit", "(", "level", ",", "message", ")", ";", "if", "(", "!", "_", ".", "isUndefined", "(", "fn", ")", "&&", "!", "_", ".", "isNull", "(", "fn", ")", ")", "{", "fn", "(", "message", ")", ";", "}", "}", "}", ";", "this", ".", "on", "(", "'log'", ",", "function", "(", "level", ",", "message", ")", "{", "console", ".", "log", "(", "level", "+", "\": \"", "+", "message", ")", ";", "}", ")", "}" ]

[ "SimpleLogger", "is", "a", "basic", "logging", "utility", "that", "uses", "events", "to", "let", "developers", "manage", "logging", "facilities", ".", "By", "default", "events", "are", "merely", "fired", "when", "the", "appropriate", "loglevels", "are", "encountered", "and", "provides", "a", "basic", "console", "logger", "that", "can", "be", "used", "by", "the", "developer", ".", "Logging", "functionality", "can", "be", "overridden", "by", "removing", "the", "listeners", "that", "are", "attached", "to", "this", "EventEmitter", "." ]

[ "function", "activate", "(", ")", "{", "if", "(", "_active", ")", "return", "node", "_active", "=", "true", "debug", "(", "'activated'", ")", "if", "(", "!", "external", ")", "{", "_masterBroker", ".", "bind", "(", ")", "_masterResolver", ".", "bind", "(", ")", "}", "if", "(", "!", "node", ".", "isReady", ")", "_seekForMaster", "(", ")", "return", "node", "}" ]

[ "Activates", "the", "node" ]

[ "function", "deactivate", "(", ")", "{", "if", "(", "!", "_active", "||", "_deactivating", ")", "return", "node", "debug", "(", "'deactivating'", ")", "if", "(", "external", ")", "{", "_active", "=", "false", "_subConnection", ".", "disconnect", "(", ")", "_pubConnection", ".", "disconnect", "(", ")", "node", ".", "emit", "(", "'deactivated'", ")", "}", "else", "{", "_deactivating", "=", "true", "let", "ensuredMaster", "=", "Promise", ".", "resolve", "(", ")", "const", "isMaster", "=", "_subConnection", ".", "master", "&&", "_subConnection", ".", "master", ".", "name", "===", "_name", "if", "(", "isMaster", ")", "{", "debug", "(", "`", "`", ")", "let", "advertiseId", "=", "`", "${", "_id", "}", "`", "ensuredMaster", "=", "_masterResolver", ".", "resolve", "(", "advertiseId", ")", ".", "then", "(", "master", "=>", "{", "debug", "(", "`", "${", "master", ".", "name", "}", "`", ")", "try", "{", "_masterBroker", ".", "signalNewMaster", "(", "master", ")", "}", "catch", "(", "e", ")", "{", "console", ".", "log", "(", "e", ")", "}", "}", ")", ".", "catch", "(", "(", ")", "=>", "{", "debug", "(", "`", "`", ")", "}", ")", "}", "ensuredMaster", ".", "then", "(", "(", ")", "=>", "{", "_subConnection", ".", "disconnect", "(", ")", "_pubConnection", ".", "disconnect", "(", ")", "_masterResolver", ".", "unbind", "(", ")", "let", "timeout", "=", "isMaster", "?", "1000", ":", "1", "setTimeout", "(", "(", ")", "=>", "{", "debug", "(", "'deactivated'", ")", "node", ".", "emit", "(", "'deactivated'", ")", "_masterBroker", ".", "unbind", "(", ")", "}", ",", "timeout", ")", "}", ")", "}", "return", "node", "}" ]

[ "Starts", "the", "node", "s", "deactivation", "routine" ]

[ "function", "publish", "(", "channel", ",", "...", "args", ")", "{", "if", "(", "!", "isString", "(", "channel", ")", ")", "throw", "new", "TypeError", "(", "`", "${", "_debugStr", "}", "`", ")", "if", "(", "~", "internalChannels", ".", "indexOf", "(", "channel", ")", ")", "{", "console", ".", "warn", "(", "`", "${", "_debugStr", "}", "${", "channel", "}", "`", ")", "return", "node", "}", "if", "(", "!", "_pubConnection", ".", "connected", ")", "{", "console", ".", "warn", "(", "`", "${", "_debugStr", "}", "`", ")", "return", "node", "}", "_pubConnection", ".", "publish", "(", "channel", ",", "...", "args", ")", "return", "node", "}" ]

[ "Sends", "a", "message", "through", "the", "bus", "published", "on", "a", "particular", "channel" ]

[ "function", "unsubscribe", "(", "channels", ")", "{", "if", "(", "!", "isArray", "(", "channels", ")", ")", "channels", "=", "[", "channels", "]", "if", "(", "!", "every", "(", "channels", ",", "isString", ")", ")", "throw", "new", "TypeError", "(", "`", "${", "_debugStr", "}", "`", ")", "channels", ".", "forEach", "(", "channel", "=>", "{", "if", "(", "~", "internalChannels", ".", "indexOf", "(", "channel", ")", ")", "{", "console", ".", "warn", "(", "`", "${", "_debugStr", "}", "${", "channel", "}", "`", ")", "return", "}", "_subConnection", ".", "unsubscribe", "(", "[", "channel", "]", ")", "}", ")", "return", "node", "}" ]

[ "Unsubscribes", "the", "node", "from", "the", "provided", "channels" ]

[ "function", "_validateSettings", "(", "settings", ")", "{", "let", "{", "host", ",", "external", ",", "voteTimeout", ",", "electionPriority", ",", "coordinationPort", "}", "=", "settings", "if", "(", "!", "host", "||", "!", "isString", "(", "host", ")", ")", "throw", "new", "TypeError", "(", "ctorMessage", "(", "'host is mandatory and should be a string.'", ")", ")", "if", "(", "!", "isInteger", "(", "coordinationPort", ")", "||", "coordinationPort", "<=", "0", ")", "throw", "new", "TypeError", "(", "ctorMessage", "(", "'settings.coordinationPort should be a positive integer.'", ")", ")", "if", "(", "!", "external", ")", "{", "if", "(", "!", "isInteger", "(", "voteTimeout", ")", "||", "voteTimeout", "<=", "0", ")", "throw", "new", "TypeError", "(", "ctorMessage", "(", "'settings.voteTimeout should be a positive integer.'", ")", ")", "if", "(", "!", "isInteger", "(", "electionPriority", ")", "||", "electionPriority", "<", "0", "||", "electionPriority", ">", "99", ")", "throw", "new", "TypeError", "(", "ctorMessage", "(", "'settings.electionPriority should be an integer between 0 and 99.'", ")", ")", "}", "}" ]

[ "Validates", "a", "map", "of", "node", "settings" ]

[ "function", "findAll", "(", "tree", ",", "test", ")", "{", "var", "found", "=", "test", "(", "tree", ")", "?", "[", "tree", "]", ":", "[", "]", "if", "(", "isNode", "(", "tree", ")", ")", "{", "if", "(", "tree", ".", "children", ".", "length", ">", "0", ")", "{", "tree", ".", "children", ".", "forEach", "(", "function", "(", "child", ")", "{", "found", "=", "found", ".", "concat", "(", "findAll", "(", "child", ",", "test", ")", ")", "}", ")", "}", "}", "return", "found", "}" ]

[ "Traverses", "the", "tree", "and", "returns", "all", "components", "that", "satisfy", "the", "function", "test", "." ]

[ "function", "quote", "(", "string", ")", "{", "var", "_Object$assign", "var", "quoteChar", "=", "arguments", ".", "length", ">", "1", "&&", "arguments", "[", "1", "]", "!==", "undefined", "?", "arguments", "[", "1", "]", ":", "'\"'", "if", "(", "quoteChar", ".", "length", ">", "1", "&&", "process", ".", "env", ".", "NODE_ENV", "!==", "'production'", ")", "{", "console", ".", "error", "(", "'quote: `quoteChar` is recommended as single character, but '", "+", "JSON", ".", "stringify", "(", "quoteChar", ")", "+", "'.'", ")", "}", "return", "_quote", "(", "string", ",", "quoteChar", ",", "getEscapable", "(", "quoteChar", ")", ",", "Object", ".", "assign", "(", "{", "}", ",", "commonMeta", ",", "(", "(", "_Object$assign", "=", "{", "}", ")", ",", "(", "_Object$assign", "[", "quoteChar", "]", "=", "'\\\\'", "+", "quoteChar", ")", ",", "_Object$assign", ")", ")", ")", "}" ]

[ "Uses", "quoteChar", "to", "wrap", "string", "." ]

[ "function", "cloneValue", "(", "value", ",", "traversedValues", ")", "{", "if", "(", "!", "(", "value", "instanceof", "Object", ")", ")", "{", "return", "value", "}", "if", "(", "value", "instanceof", "Boolean", ")", "{", "return", "new", "Boolean", "(", "value", ".", "valueOf", "(", ")", ")", "}", "if", "(", "value", "instanceof", "Number", ")", "{", "return", "new", "Number", "(", "value", ".", "valueOf", "(", ")", ")", "}", "if", "(", "value", "instanceof", "String", ")", "{", "return", "new", "String", "(", "value", ".", "valueOf", "(", ")", ")", "}", "if", "(", "value", "instanceof", "Date", ")", "{", "return", "new", "Date", "(", "value", ".", "valueOf", "(", ")", ")", "}", "if", "(", "value", "instanceof", "RegExp", ")", "{", "return", "new", "RegExp", "(", "value", ".", "source", ",", "value", ".", "flags", ")", "}", "if", "(", "(", "typeof", "Blob", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "Blob", ")", ")", "{", "return", "value", "// immutable", "}", "if", "(", "(", "typeof", "File", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "File", ")", ")", "{", "return", "value", "// immutable", "}", "if", "(", "(", "typeof", "FileList", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "FileList", ")", ")", "{", "return", "value", "// immutable", "}", "if", "(", "(", "typeof", "ArrayBuffer", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "ArrayBuffer", ")", ")", "{", "return", "value", ".", "slice", "(", ")", "}", "if", "(", "(", "typeof", "DataView", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "DataView", ")", ")", "{", "return", "new", "DataView", "(", "value", ".", "buffer", ".", "slice", "(", ")", ",", "value", ".", "byteOffset", ",", "value", ".", "byteLength", ")", "}", "let", "isTypedArray", "=", "TYPED_ARRAY_TYPES", ".", "some", "(", "type", "=>", "value", "instanceof", "type", ")", "if", "(", "isTypedArray", ")", "{", "return", "value", ".", "subarray", "(", ")", "}", "if", "(", "(", "typeof", "ImageData", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "ImageData", ")", ")", "{", "return", "new", "ImageData", "(", "value", ".", "data", ",", "value", ".", "width", ",", "value", ".", "height", ")", "}", "if", "(", "(", "typeof", "ImageBitmap", "===", "\"function\"", ")", "&&", "(", "value", "instanceof", "ImageBitmap", ")", ")", "{", "return", "value", "}", "if", "(", "value", "instanceof", "Array", ")", "{", "return", "cloneArray", "(", "value", ",", "traversedValues", ")", "}", "if", "(", "value", "instanceof", "Map", ")", "{", "return", "cloneMap", "(", "value", ",", "traversedValues", ")", "}", "if", "(", "value", "instanceof", "Set", ")", "{", "return", "cloneSet", "(", "value", ",", "traversedValues", ")", "}", "if", "(", "isPlainObjectOrEntity", "(", "value", ")", ")", "{", "return", "cloneObject", "(", "value", ",", "traversedValues", ")", "}", "throw", "new", "Error", "(", "`", "${", "value", "}", "`", ")", "}" ]

[ "Clones", "the", "provided", "value", "using", "the", "structured", "clone", "algorithm", "." ]

[ "function", "cloneArray", "(", "source", ",", "traversedValues", ")", "{", "let", "clone", "=", "[", "]", "traversedValues", ".", "set", "(", "source", ",", "clone", ")", "cloneStructure", "(", "source", ".", "keys", "(", ")", ",", "key", "=>", "source", "[", "key", "]", ",", "(", "key", ",", "value", ")", "=>", "clone", "[", "key", "]", "=", "value", ",", "traversedValues", ")", "return", "clone", "}" ]

[ "Clones", "the", "provided", "array", "." ]

[ "function", "cloneMap", "(", "source", ",", "traversedValues", ")", "{", "let", "clone", "=", "new", "Map", "(", ")", "traversedValues", ".", "set", "(", "source", ",", "clone", ")", "cloneStructure", "(", "source", ".", "keys", "(", ")", ",", "key", "=>", "source", ".", "get", "(", "key", ")", ",", "(", "key", ",", "value", ")", "=>", "clone", ".", "set", "(", "key", ",", "value", ")", ",", "traversedValues", ")", "return", "clone", "}" ]

[ "Clones", "the", "provided", "map", "." ]

[ "function", "cloneSet", "(", "source", ",", "traversedValues", ")", "{", "let", "clone", "=", "new", "Set", "(", ")", "traversedValues", ".", "set", "(", "source", ",", "clone", ")", "cloneStructure", "(", "source", ".", "values", "(", ")", ",", "entry", "=>", "undefined", ",", "entry", "=>", "clone", ".", "add", "(", "entry", ")", ",", "traversedValues", ")", "return", "clone", "}" ]

[ "Clones", "the", "provided", "set", "." ]

[ "function", "cloneObject", "(", "source", ",", "traversedValues", ")", "{", "let", "clone", "=", "{", "}", "traversedValues", ".", "set", "(", "source", ",", "clone", ")", "cloneStructure", "(", "Object", ".", "keys", "(", "source", ")", ",", "key", "=>", "source", "[", "key", "]", ",", "(", "key", ",", "value", ")", "=>", "clone", "[", "key", "]", "=", "value", ",", "traversedValues", ")", "return", "clone", "}" ]

[ "Clones", "the", "provided", "plain", "object", ".", "Symbol", "and", "prototype", "properties", "are", "not", "copied", "." ]

[ "function", "cloneStructure", "(", "keys", ",", "getter", ",", "setter", ",", "traversedValues", ")", "{", "for", "(", "let", "key", "of", "keys", ")", "{", "let", "value", "=", "getter", "(", "key", ")", "let", "keyClone", "if", "(", "key", "instanceof", "Object", ")", "{", "if", "(", "traversedValues", ".", "has", "(", "key", ")", ")", "{", "keyClone", "=", "traversedValues", ".", "get", "(", "key", ")", "}", "else", "{", "keyClone", "=", "cloneValue", "(", "key", ",", "traversedValues", ")", "traversedValues", ".", "set", "(", "key", ",", "keyClone", ")", "}", "}", "else", "{", "keyClone", "=", "key", "}", "if", "(", "value", "instanceof", "Object", ")", "{", "if", "(", "traversedValues", ".", "has", "(", "value", ")", ")", "{", "setter", "(", "keyClone", ",", "traversedValues", ".", "get", "(", "value", ")", ")", "}", "else", "{", "let", "clonedValue", "=", "cloneValue", "(", "value", ",", "traversedValues", ")", "traversedValues", ".", "set", "(", "value", ",", "clonedValue", ")", "setter", "(", "keyClone", ",", "clonedValue", ")", "}", "}", "else", "{", "setter", "(", "keyClone", ",", "value", ")", "}", "}", "}" ]

[ "Clones", "the", "structure", "having", "the", "specified", "property", "keys", "using", "the", "provided", "getters", "and", "setters", ".", "The", "function", "clones", "the", "keys", "and", "values", "before", "setting", "them", "using", "the", "setters", "." ]

[ "function", "getStagedFiles", "(", "callback", ")", "{", "const", "options", "=", "[", "'diff'", ",", "'--cached'", ",", "'--name-only'", ",", "'--diff-filter=ACM'", "]", "execFile", "(", "'git'", ",", "options", ",", "(", "err", ",", "stdout", ")", "=>", "{", "if", "(", "err", ")", "return", "callback", "(", "err", ")", "const", "stagedFiles", "=", "stdout", ".", "split", "(", "'\\n'", ")", ".", "filter", "(", "filename", "=>", "filename", ".", "match", "(", "/", ".js$", "/", ")", ")", "callback", "(", "null", ",", "stagedFiles", ")", "}", ")", "}" ]

[ "Calls", "callback", "with", "list", "of", "staged", "files" ]

[ "function", "lintFiles", "(", "files", ")", "{", "const", "eslint", "=", "new", "CLIEngine", "(", ")", "const", "report", "=", "eslint", ".", "executeOnFiles", "(", "files", ")", "return", "{", "text", ":", "friendlyFormatter", "(", "report", ".", "results", ")", ",", "errorCount", ":", "report", ".", "errorCount", ",", "}", "}" ]

[ "Perform", "ESLint", "validation", "on", "list", "of", "files" ]

[ "function", "isSupportedElement", "(", "element", ",", "mode", ")", "{", "if", "(", "mode", "==", "CKEDITOR", ".", "ELEMENT_MODE_INLINE", ")", "return", "element", ".", "is", "(", "CKEDITOR", ".", "dtd", ".", "$editable", ")", "||", "element", ".", "is", "(", "'textarea'", ")", ";", "else", "if", "(", "mode", "==", "CKEDITOR", ".", "ELEMENT_MODE_REPLACE", ")", "return", "!", "element", ".", "is", "(", "CKEDITOR", ".", "dtd", ".", "$nonBodyContent", ")", ";", "return", "1", ";", "}" ]

[ "Asserting", "element", "DTD", "depending", "on", "mode", "." ]

[ "function", "initComponents", "(", "editor", ")", "{", "// Documented in dataprocessor.js.", "editor", ".", "dataProcessor", "=", "new", "CKEDITOR", ".", "htmlDataProcessor", "(", "editor", ")", ";", "// Set activeFilter directly to avoid firing event.", "editor", ".", "filter", "=", "editor", ".", "activeFilter", "=", "new", "CKEDITOR", ".", "filter", "(", "editor", ")", ";", "loadSkin", "(", "editor", ")", ";", "}" ]

[ "Various", "other", "core", "components", "that", "read", "editor", "configuration", "." ]

[ "function", "updateEditorElement", "(", ")", "{", "var", "element", "=", "this", ".", "element", ";", "// Some editor creation mode will not have the", "// associated element.", "if", "(", "element", "&&", "this", ".", "elementMode", "!=", "CKEDITOR", ".", "ELEMENT_MODE_APPENDTO", ")", "{", "var", "data", "=", "this", ".", "getData", "(", ")", ";", "if", "(", "this", ".", "config", ".", "htmlEncodeOutput", ")", "data", "=", "CKEDITOR", ".", "tools", ".", "htmlEncode", "(", "data", ")", ";", "if", "(", "element", ".", "is", "(", "'textarea'", ")", ")", "element", ".", "setValue", "(", "data", ")", ";", "else", "element", ".", "setHtml", "(", "data", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Send", "to", "data", "output", "back", "to", "editor", "s", "associated", "element", "." ]

[ "function", "(", "commandName", ",", "data", ")", "{", "var", "command", "=", "this", ".", "getCommand", "(", "commandName", ")", ";", "var", "eventData", "=", "{", "name", ":", "commandName", ",", "commandData", ":", "data", ",", "command", ":", "command", "}", ";", "if", "(", "command", "&&", "command", ".", "state", "!=", "CKEDITOR", ".", "TRISTATE_DISABLED", ")", "{", "if", "(", "this", ".", "fire", "(", "'beforeCommandExec'", ",", "eventData", ")", "!==", "false", ")", "{", "eventData", ".", "returnValue", "=", "command", ".", "exec", "(", "eventData", ".", "commandData", ")", ";", "// Fire the 'afterCommandExec' immediately if command is synchronous.", "if", "(", "!", "command", ".", "async", "&&", "this", ".", "fire", "(", "'afterCommandExec'", ",", "eventData", ")", "!==", "false", ")", "return", "eventData", ".", "returnValue", ";", "}", "}", "// throw 'Unknown command name \"' + commandName + '\"';", "return", "false", ";", "}" ]

[ "Executes", "a", "command", "associated", "with", "the", "editor", "." ]

[ "function", "(", ")", "{", "var", "keystrokes", "=", "this", ".", "keystrokeHandler", ".", "keystrokes", ",", "newKeystrokes", "=", "CKEDITOR", ".", "tools", ".", "isArray", "(", "arguments", "[", "0", "]", ")", "?", "arguments", "[", "0", "]", ":", "[", "[", "]", ".", "slice", ".", "call", "(", "arguments", ",", "0", ")", "]", ",", "keystroke", ",", "behavior", ";", "for", "(", "var", "i", "=", "newKeystrokes", ".", "length", ";", "i", "--", ";", ")", "{", "keystroke", "=", "newKeystrokes", "[", "i", "]", ";", "behavior", "=", "0", ";", "// It may be a pair of: [ key, command ]", "if", "(", "CKEDITOR", ".", "tools", ".", "isArray", "(", "keystroke", ")", ")", "{", "behavior", "=", "keystroke", "[", "1", "]", ";", "keystroke", "=", "keystroke", "[", "0", "]", ";", "}", "if", "(", "behavior", ")", "keystrokes", "[", "keystroke", "]", "=", "behavior", ";", "else", "delete", "keystrokes", "[", "keystroke", "]", ";", "}", "}" ]

[ "Assigns", "keystrokes", "associated", "to", "editor", "commands", "." ]

[ "function", "transform", "(", ")", "{", "for", "(", "var", "_len", "=", "arguments", ".", "length", ",", "matrices", "=", "Array", "(", "_len", ")", ",", "_key", "=", "0", ";", "_key", "<", "_len", ";", "_key", "++", ")", "{", "matrices", "[", "_key", "]", "=", "arguments", "[", "_key", "]", ";", "}", "matrices", "=", "Array", ".", "isArray", "(", "matrices", "[", "0", "]", ")", "?", "matrices", "[", "0", "]", ":", "matrices", ";", "var", "multiply", "=", "function", "multiply", "(", "m1", ",", "m2", ")", "{", "return", "{", "a", ":", "m1", ".", "a", "*", "m2", ".", "a", "+", "m1", ".", "c", "*", "m2", ".", "b", ",", "c", ":", "m1", ".", "a", "*", "m2", ".", "c", "+", "m1", ".", "c", "*", "m2", ".", "d", ",", "e", ":", "m1", ".", "a", "*", "m2", ".", "e", "+", "m1", ".", "c", "*", "m2", ".", "f", "+", "m1", ".", "e", ",", "b", ":", "m1", ".", "b", "*", "m2", ".", "a", "+", "m1", ".", "d", "*", "m2", ".", "b", ",", "d", ":", "m1", ".", "b", "*", "m2", ".", "c", "+", "m1", ".", "d", "*", "m2", ".", "d", ",", "f", ":", "m1", ".", "b", "*", "m2", ".", "e", "+", "m1", ".", "d", "*", "m2", ".", "f", "+", "m1", ".", "f", "}", ";", "}", ";", "switch", "(", "matrices", ".", "length", ")", "{", "case", "0", ":", "throw", "new", "Error", "(", "'no matrices provided'", ")", ";", "case", "1", ":", "return", "matrices", "[", "0", "]", ";", "case", "2", ":", "return", "multiply", "(", "matrices", "[", "0", "]", ",", "matrices", "[", "1", "]", ")", ";", "default", ":", "var", "_matrices", "=", "matrices", ",", "_matrices2", "=", "_toArray", "(", "_matrices", ")", ",", "m1", "=", "_matrices2", "[", "0", "]", ",", "m2", "=", "_matrices2", "[", "1", "]", ",", "rest", "=", "_matrices2", ".", "slice", "(", "2", ")", ";", "var", "m", "=", "multiply", "(", "m1", ",", "m2", ")", ";", "return", "transform", ".", "apply", "(", "undefined", ",", "[", "m", "]", ".", "concat", "(", "_toConsumableArray", "(", "rest", ")", ")", ")", ";", "}", "}" ]

[ "Merge", "multiple", "matrices", "into", "one" ]

[ "function", "correctQuestionMarkAndAnd", "(", "url", ")", "{", "var", "baseURL", "=", "url", ";", "// Remove && mistake", "baseURL", "=", "baseURL", ".", "replace", "(", "new", "RegExp", "(", "'&&'", ",", "'g'", ")", ",", "'&'", ")", ";", "// Ends width ?", "if", "(", "new", "RegExp", "(", "'[\\?]$'", ")", ".", "test", "(", "baseURL", ")", ")", "{", "// Do nothing", "}", "else", "{", "// Does not end on ?", "// Contains ?", "if", "(", "baseURL", ".", "includes", "(", "'?'", ")", ")", "{", "// Ends width &", "if", "(", "new", "RegExp", "(", "'[\\&]$'", ")", ".", "test", "(", "baseURL", ")", ")", "{", "// Do nothing", "}", "else", "{", "// Does not end on &", "// Add &", "baseURL", "+=", "'&'", ";", "}", "}", "else", "{", "// Does not contain on ?", "// Count of &", "var", "countOfAnd", "=", "baseURL", ".", "split", "(", "'&'", ")", ".", "length", "-", "1", ";", "// Ends with &", "if", "(", "new", "RegExp", "(", "'[\\&]$'", ")", ".", "test", "(", "baseURL", ")", ")", "{", "if", "(", "countOfAnd", "===", "1", ")", "{", "// Remove &", "baseURL", "=", "baseURL", ".", "slice", "(", "0", ",", "-", "1", ")", ";", "// Add ?", "baseURL", "+=", "'?'", ";", "}", "else", "{", "// Replace first & with ?", "baseURL", "=", "baseURL", ".", "replace", "(", "'&'", ",", "'?'", ")", ";", "}", "}", "else", "{", "// Does not contain on ? ends not on &", "// Contains one or more &", "if", "(", "countOfAnd", ">", "1", ")", "{", "// Replace first & with ?", "baseURL", "=", "baseURL", ".", "replace", "(", "'&'", ",", "'?'", ")", ";", "// Add &", "baseURL", "+=", "'&'", ";", "}", "else", "{", "// Does not contain &", "// Add ?", "baseURL", "+=", "'?'", ";", "}", "}", "}", "}", "return", "baseURL", ";", "}" ]

[ "Correct", "mistakes", "with", "the", "characters", "?", "and", "&", "." ]

[ "function", "removeParameters", "(", "url", ")", "{", "var", "baseURL", "=", "url", ";", "// Iterate over all parameters", "for", "(", "var", "int", "=", "0", ";", "int", "<", "params", ".", "length", ";", "int", "++", ")", "{", "// Remove parameter", "baseURL", "=", "baseURL", ".", "replace", "(", "new", "RegExp", "(", "params", "[", "int", "]", "+", "'=[^&]*&'", ",", "'ig'", ")", ",", "''", ")", ";", "}", "return", "baseURL", ";", "}" ]

[ "Removes", "OWS", "-", "Parameters", "from", "URL", ".", "The", "Parameters", "are", "defined", "at", "removeParameters", ".", "json", "." ]

[ "function", "determineBaseURL", "(", "url", ")", "{", "var", "baseURL", ";", "// Check if url is set", "if", "(", "url", ")", "{", "// Remove whitespace", "baseURL", "=", "url", ".", "trim", "(", ")", ";", "baseURL", "=", "correctHttpAndHttps", "(", "baseURL", ")", ";", "baseURL", "=", "correctQuestionMarkAndAnd", "(", "baseURL", ")", ";", "baseURL", "=", "removeParameters", "(", "baseURL", ")", ";", "}", "else", "{", "// Throw error (no url)", "throw", "new", "Error", "(", "'The url parameter is not set.'", ")", ";", "}", "return", "baseURL", ";", "}" ]

[ "Corrects", "all", "mistakes", "in", "a", "URL", "." ]

[ "function", "ParseWithConfig", "(", "config", ",", "argv", ")", "{", "const", "debug", "=", "false", ";", "const", "parser", "=", "dashdash", ".", "createParser", "(", "{", "options", ":", "config", "}", ")", ";", "const", "helpText", "=", "parser", ".", "help", "(", "{", "includeEnv", ":", "true", "}", ")", ".", "trimRight", "(", ")", ";", "try", "{", "const", "opts", "=", "parser", ".", "parse", "(", "argv", ",", "2", ")", ";", "const", "innerOptions", "=", "parser", ".", "options", ";", "const", "keyValues", "=", "{", "}", ";", "/**\n * From opts build a key/value object consting ONLY of the options keys and no extra stuff\n * Note that dashdash puts a bunch of other stuff in opts.\n * AND then wrap the keyValue object in a CliOptions object for returing\n */", "innerOptions", ".", "forEach", "(", "(", "element", ")", "=>", "{", "const", "k", "=", "element", ".", "key", ";", "if", "(", "debug", ")", "debugLog", "(", "`", "${", "k", "}", "${", "opts", "[", "k", "]", "}", "`", ")", ";", "const", "v", "=", "(", "opts", ".", "hasOwnProperty", "(", "k", ")", ")", "?", "opts", "[", "k", "]", ":", "undefined", ";", "keyValues", "[", "k", "]", "=", "v", ";", "}", ")", ";", "/**\n * @NOTE - the next two variables are temporary and disappear when the function is complete\n * so there is no need to copy them\n */", "const", "cliOptions", "=", "CliOptions", "(", "keyValues", ")", ";", "const", "cliArgs", "=", "CliArguments", "(", "opts", ".", "_args", ")", ";", "if", "(", "debug", ")", "debugLog", "(", "util", ".", "inspect", "(", "cliOptions", ".", "getOptions", "(", ")", ")", ")", ";", "return", "[", "cliOptions", ",", "cliArgs", ",", "helpText", "]", ";", "}", "catch", "(", "e", ")", "{", "debugger", ";", "console", ".", "log", "(", "e", ".", "stack", ")", ";", "raiseError", "(", "`", "${", "e", ".", "message", "}", "`", ")", ";", "console", ".", "error", "(", "'Command Line Parser found an error: %s'", ",", "e", ".", "message", ")", ";", "process", ".", "exit", "(", "1", ")", ";", "}", "}" ]

[ "ParseWithConfig", "-", "A", "function", "that", "parses", "an", "array", "of", "command", "line", "options", "and", "arguments" ]

[ "function", "hasEscapeFirst", "(", "data", ",", "offset", ")", "{", "isBuffer", "=", "(", "!", "isQuiet", "&&", "typeof", "data", "!==", "'string'", ")", "escaped", "=", "(", "this", ".", "prev", ".", "idx", ">", "0", ")", "return", "escaped", "?", "(", "escapeOffset", "=", "offset", "-", "escLength", ",", "-", "1", ")", "//HACK to bypass the trimLeft/trimRight properties", ":", "(", "this", ".", "prev", ".", "prev", ".", "length", "=", "leftLength", "+", "1", ",", "atok", ".", "offset", "--", ",", "1", ")", "}" ]

[ "Make", "the", "rule", "fail", "if", "an", "escape", "char", "was", "found" ]

[ "function", "(", "config", ")", "{", "'use strict'", ";", "//If is not instance of SaySomething return a new instance", "if", "(", "false", "===", "(", "this", "instanceof", "SaySomething", ")", ")", "{", "return", "new", "SaySomething", "(", "config", ")", ";", "}", "events", ".", "EventEmitter", ".", "call", "(", "this", ")", ";", "this", ".", "defaults", "=", "{", "language", ":", "'en'", "}", ";", "//Extend default with the config object", "_", ".", "extend", "(", "this", ".", "defaults", ",", "config", ")", ";", "return", "this", ";", "}" ]

[ "Creates", "an", "instance", "of", "the", "SaySomething", "object", "." ]

[ "function", "executeController", "(", "server", ",", "controller", ",", "req", ",", "res", ")", "{", "try", "{", "const", "promise", "=", "controller", ".", "call", "(", "server", ",", "req", ",", "res", ")", ";", "if", "(", "promise", "&&", "typeof", "promise", ".", "catch", "===", "'function'", ")", "{", "promise", ".", "catch", "(", "function", "(", "err", ")", "{", "res", ".", "status", "(", "500", ")", ".", "send", "(", "err", ")", ";", "}", ")", ";", "}", "}", "catch", "(", "err", ")", "{", "res", ".", "send", "(", "err", ")", ";", "}", "}" ]

[ "Safely", "execute", "a", "controller", "." ]

[ "function", "findMatchingExample", "(", "req", ",", "code", ",", "type", ")", "{", "const", "swagger", "=", "req", ".", "swagger", ".", "root", ";", "const", "responses", "=", "req", ".", "swagger", ".", "rel", ".", "responses", ";", "// if no responses then exit", "const", "responseKeys", "=", "responses", "&&", "typeof", "responses", "===", "'object'", "?", "Object", ".", "keys", "(", "responses", ")", ":", "[", "]", ";", "if", "(", "responseKeys", ".", "length", "===", "0", ")", "return", "{", "code", ":", "501", ",", "type", ":", "undefined", "}", ";", "// get first code if not provided", "if", "(", "arguments", ".", "length", "<", "1", ")", "code", "=", "responseKeys", "[", "0", "]", ";", "// validate that responses exist", "const", "responseSchema", "=", "responses", "[", "code", "]", ";", "if", "(", "!", "responseSchema", ")", "return", "{", "code", ":", "501", ",", "type", ":", "undefined", "}", ";", "const", "examples", "=", "responses", "[", "code", "]", ".", "examples", ";", "const", "accept", "=", "type", "?", "type", ":", "req", ".", "headers", ".", "hasOwnProperty", "(", "'accept'", ")", "?", "req", ".", "headers", ".", "accept", ":", "Array", ".", "isArray", "(", "swagger", ".", "produces", ")", "&&", "swagger", ".", "produces", ".", "length", ">", "0", "?", "swagger", ".", "produces", "[", "0", "]", ":", "examples", "&&", "Object", ".", "keys", "(", "examples", ")", "[", "0", "]", ";", "// check if there are examples", "const", "keys", "=", "examples", "?", "Object", ".", "keys", "(", "examples", ")", ":", "[", "]", ";", "const", "typesLength", "=", "keys", ".", "length", ";", "if", "(", "typesLength", "===", "0", ")", "return", "{", "code", ":", "501", ",", "type", ":", "undefined", "}", ";", "// if anything is accepted then return first example", "if", "(", "accept", "===", "'*'", ")", "return", "{", "code", ":", "code", ",", "type", ":", "keys", "[", "0", "]", "}", ";", "// determine what types and subtypes are supported by examples", "const", "types", "=", "keys", ".", "map", "(", "key", "=>", "{", "const", "ar", "=", "key", ".", "split", "(", "'/'", ")", ";", "return", "{", "type", ":", "ar", "[", "0", "]", "||", "'*'", ",", "subtype", ":", "ar", "[", "1", "]", "||", "'*'", "}", ";", "}", ")", ";", "// find all the types that the client accepts", "const", "accepts", "=", "accept", ".", "split", "(", "/", ",\\s*", "/", ")", ";", "const", "length", "=", "accepts", ".", "length", ";", "for", "(", "let", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "// remove variable from type and separate type and subtype", "const", "item", "=", "accepts", "[", "i", "]", ".", "split", "(", "';'", ")", "[", "0", "]", ";", "const", "parts", "=", "item", ".", "split", "(", "'/'", ")", ";", "const", "a", "=", "{", "type", ":", "parts", "[", "0", "]", "||", "'*'", ",", "subtype", ":", "parts", "[", "1", "]", "||", "'*'", "}", ";", "// look for a match between types and accepts", "for", "(", "let", "j", "=", "0", ";", "j", "<", "typesLength", ";", "j", "++", ")", "{", "const", "t", "=", "types", "[", "j", "]", ";", "if", "(", "(", "t", ".", "type", "===", "'*'", "||", "a", ".", "type", "===", "'*'", "||", "a", ".", "type", "===", "t", ".", "type", ")", "&&", "(", "t", ".", "subtype", "===", "'*'", "||", "a", ".", "subtype", "===", "'*'", "||", "a", ".", "subtype", "===", "t", ".", "subtype", ")", ")", "return", "{", "code", ":", "code", ",", "type", ":", "keys", "[", "j", "]", "}", ";", "}", "}", "return", "{", "code", ":", "406", ",", "type", ":", "undefined", "}", ";", "}" ]

[ "Look", "through", "swagger", "examples", "and", "find", "a", "match", "based", "on", "the", "accept", "content", "type" ]

[ "function", "loadController", "(", "controllersDirectory", ",", "controller", ",", "development", ")", "{", "const", "filePath", "=", "path", ".", "resolve", "(", "controllersDirectory", ",", "controller", ")", ";", "try", "{", "return", "require", "(", "filePath", ")", ";", "}", "catch", "(", "e", ")", "{", "if", "(", "e", ".", "code", "===", "'MODULE_NOT_FOUND'", "&&", "e", ".", "message", ".", "indexOf", "(", "\"Cannot find module '\"", "+", "filePath", "+", "\"'\"", ")", "===", "0", "&&", "development", ")", "{", "console", ".", "error", "(", "'Cannot find controller: '", "+", "filePath", ")", ";", "return", "null", ";", "}", "else", "{", "throw", "e", ";", "}", "}", "}" ]

[ "Attempt", "to", "load", "a", "node", "module", "as", "a", "controller", "." ]

[ "function", "full_uri_encode", "(", "string", ")", "{", "string", "=", "encodeURIComponent", "(", "string", ")", ";", "string", "=", "string", ".", "replace", "(", "/", "\\.", "/", "g", ",", "'%2E'", ")", ";", "return", "(", "string", ")", ";", "}" ]

[ "Special", "Heroku", "URI", "encoding", ".", "Used", "for", "key", "deletes", "." ]

[ "function", "(", "err", ",", "privkey", ",", "pubkey", ")", "{", "if", "(", "err", ")", "throw", "err", ";", "this", ".", "pubkey", "=", "pubkey", ";", "this", ".", "privkey", "=", "privkey", ";", "this", ".", "user_host_field", "=", "pubkey", ".", "split", "(", "' '", ")", "[", "2", "]", ".", "trim", "(", ")", ";", "console", ".", "log", "(", "\"Adding Heroku SSH keypair via API\"", ")", ";", "add_ssh_key", "(", "api_key", ",", "pubkey", ",", "this", ")", ";", "}" ]

[ "Add", "keypair", "to", "Heroku", "account" ]

[ "function", "(", "err", ",", "r", ",", "b", ")", "{", "if", "(", "err", ")", "throw", "err", ";", "try", "{", "fs", ".", "unlink", "(", "keyname", ",", "this", ".", "parallel", "(", ")", ")", ";", "fs", ".", "unlink", "(", "keyname", "+", "\".pub\"", ",", "this", ".", "parallel", "(", ")", ")", ";", "}", "catch", "(", "e", ")", "{", "// do nothing", "}", ";", "console", ".", "log", "(", "\"Heroku SSH keypair deleted from local FS\"", ")", ";", "callback", "(", "err", ",", "this", ".", "privkey", ",", "this", ".", "pubkey", ",", "this", ".", "user_host_field", ")", ";", "}" ]

[ "SSH", "key", "has", "been", "added", "unlink", "files" ]

[ "function", "preparePackage", "(", ")", "{", "var", "ignoreFiles", "=", "[", "'package.json'", ",", "'README.md'", ",", "'LICENSE.md'", ",", "'.gitignore'", ",", "'.npmignore'", "]", ";", "var", "ignoreCopyFiles", "=", "[", "]", ";", "var", "copyRecursiveSync", "=", "function", "(", "src", ",", "dest", ")", "{", "var", "exists", "=", "fs", ".", "existsSync", "(", "src", ")", ";", "var", "stats", "=", "exists", "&&", "fs", ".", "statSync", "(", "src", ")", ";", "var", "isDirectory", "=", "exists", "&&", "stats", ".", "isDirectory", "(", ")", ";", "if", "(", "exists", "&&", "isDirectory", ")", "{", "if", "(", "!", "fs", ".", "existsSync", "(", "dest", ")", ")", "{", "fs", ".", "mkdirSync", "(", "dest", ")", ";", "}", "fs", ".", "readdirSync", "(", "src", ")", ".", "forEach", "(", "function", "(", "filename", ")", "{", "copyRecursiveSync", "(", "upath", ".", "join", "(", "src", ",", "filename", ")", ",", "upath", ".", "join", "(", "dest", ",", "filename", ")", ")", ";", "}", ")", ";", "}", "else", "{", "if", "(", "ignoreCopyFiles", ".", "indexOf", "(", "upath", ".", "basename", "(", "src", ")", ")", "===", "-", "1", ")", "{", "fs", ".", "linkSync", "(", "src", ",", "dest", ")", ";", "}", "}", "}", ";", "var", "srcPkg", "=", "upath", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'src'", ")", ";", "if", "(", "fs", ".", "existsSync", "(", "srcPkg", ")", ")", "{", "fs", ".", "readdirSync", "(", "process", ".", "cwd", "(", ")", ")", ".", "forEach", "(", "function", "(", "filename", ")", "{", "var", "curPath", "=", "upath", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "filename", ")", ";", "if", "(", "ignoreFiles", ".", "indexOf", "(", "upath", ".", "basename", "(", "curPath", ")", ")", "===", "-", "1", "&&", "fs", ".", "statSync", "(", "curPath", ")", ".", "isFile", "(", ")", ")", "{", "fs", ".", "unlinkSync", "(", "curPath", ")", ";", "}", "}", ")", ";", "copyRecursiveSync", "(", "srcPkg", ",", "process", ".", "cwd", "(", ")", ")", ";", "}", "deleteFolderRecursive", "(", "srcPkg", ")", ";", "deleteFolderRecursive", "(", "upath", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'test'", ")", ")", ";", "deleteFolderRecursive", "(", "upath", ".", "join", "(", "process", ".", "cwd", "(", ")", ",", "'env'", ")", ")", ";", "}" ]

[ "Clean", "package", "root", "and", "exclude", "src" ]

[ "function", "describe", "(", "object", ")", "{", "return", "Object", ".", "getOwnPropertyNames", "(", "object", ")", ".", "reduce", "(", "function", "(", "desc", ",", "key", ")", "{", "desc", "[", "key", "]", "=", "Object", ".", "getOwnPropertyDescriptor", "(", "object", ",", "key", ")", "return", "desc", "}", ",", "Object", ".", "create", "(", "null", ")", ")", "}" ]

[ "Retrieves", "an", "object", "s", "description" ]

[ "function", "inherit", "(", "ctor", ",", "sctor", ")", "{", "ctor", ".", "prototype", "=", "Object", ".", "create", "(", "sctor", ".", "prototype", ",", "describe", "(", "ctor", ".", "prototype", ")", ")", "}" ]

[ "Inherits", "from", "sctor", "to", "ctor" ]

[ "function", "CommandAsker", "(", "questions", ",", "options", ")", "{", "options", "=", "options", "||", "{", "}", ";", "if", "(", "!", "_", ".", "isArray", "(", "questions", ")", ")", "{", "throw", "\"there are no questions available :'(\"", ";", "}", "this", ".", "questions", "=", "questions", ";", "this", ".", "response", "=", "{", "}", ";", "this", ".", "cli", "=", "readline", ".", "createInterface", "(", "{", "input", ":", "process", ".", "stdin", ",", "output", ":", "process", ".", "stdout", "}", ")", ";", "this", ".", "askCallback", "=", "null", ";", "this", ".", "errorMsg", "=", "options", ".", "errorMsg", "||", "clc", ".", "xterm", "(", "160", ")", ";", "this", ".", "currentQuestion", "=", "0", ";", "}" ]

[ "Create", "new", "asker" ]

[ "function", "(", "editor", ")", "{", "// Backward compatibility.", "if", "(", "editor", "instanceof", "CKEDITOR", ".", "dom", ".", "document", ")", "return", "applyStyleOnSelection", ".", "call", "(", "this", ",", "editor", ".", "getSelection", "(", ")", ")", ";", "if", "(", "this", ".", "checkApplicable", "(", "editor", ".", "elementPath", "(", ")", ",", "editor", ")", ")", "{", "var", "initialEnterMode", "=", "this", ".", "_", ".", "enterMode", ";", "// See comment in removeStyle.", "if", "(", "!", "initialEnterMode", ")", "this", ".", "_", ".", "enterMode", "=", "editor", ".", "activeEnterMode", ";", "applyStyleOnSelection", ".", "call", "(", "this", ",", "editor", ".", "getSelection", "(", ")", ",", "0", ",", "editor", ")", ";", "this", ".", "_", ".", "enterMode", "=", "initialEnterMode", ";", "}", "}" ]

[ "Applies", "the", "style", "on", "the", "editor", "s", "current", "selection", "." ]

[ "function", "(", "elementPath", ",", "editor", ",", "filter", ")", "{", "// Backward compatibility.", "if", "(", "editor", "&&", "editor", "instanceof", "CKEDITOR", ".", "filter", ")", "filter", "=", "editor", ";", "if", "(", "filter", "&&", "!", "filter", ".", "check", "(", "this", ")", ")", "return", "false", ";", "switch", "(", "this", ".", "type", ")", "{", "case", "CKEDITOR", ".", "STYLE_OBJECT", ":", "return", "!", "!", "elementPath", ".", "contains", "(", "this", ".", "element", ")", ";", "case", "CKEDITOR", ".", "STYLE_BLOCK", ":", "return", "!", "!", "elementPath", ".", "blockLimit", ".", "getDtd", "(", ")", "[", "this", ".", "element", "]", ";", "}", "return", "true", ";", "}" ]

[ "Whether", "this", "style", "can", "be", "applied", "at", "the", "specified", "elements", "path", "." ]

[ "function", "(", "element", ",", "fullMatch", ")", "{", "var", "def", "=", "this", ".", "_", ".", "definition", ";", "if", "(", "!", "element", "||", "!", "def", ".", "ignoreReadonly", "&&", "element", ".", "isReadOnly", "(", ")", ")", "return", "false", ";", "var", "attribs", ",", "name", "=", "element", ".", "getName", "(", ")", ";", "// If the element name is the same as the style name.", "if", "(", "typeof", "this", ".", "element", "==", "'string'", "?", "name", "==", "this", ".", "element", ":", "name", "in", "this", ".", "element", ")", "{", "// If no attributes are defined in the element.", "if", "(", "!", "fullMatch", "&&", "!", "element", ".", "hasAttributes", "(", ")", ")", "return", "true", ";", "attribs", "=", "getAttributesForComparison", "(", "def", ")", ";", "if", "(", "attribs", ".", "_length", ")", "{", "for", "(", "var", "attName", "in", "attribs", ")", "{", "if", "(", "attName", "==", "'_length'", ")", "continue", ";", "var", "elementAttr", "=", "element", ".", "getAttribute", "(", "attName", ")", "||", "''", ";", "// Special treatment for 'style' attribute is required.", "if", "(", "attName", "==", "'style'", "?", "compareCssText", "(", "attribs", "[", "attName", "]", ",", "elementAttr", ")", ":", "attribs", "[", "attName", "]", "==", "elementAttr", ")", "{", "if", "(", "!", "fullMatch", ")", "return", "true", ";", "}", "else", "if", "(", "fullMatch", ")", "{", "return", "false", ";", "}", "}", "if", "(", "fullMatch", ")", "return", "true", ";", "}", "else", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Checks", "if", "the", "element", "matches", "the", "current", "style", "definition", "." ]

[ "function", "checkIfNodeCanBeChildOfStyle", "(", "def", ",", "currentNode", ",", "lastNode", ",", "nodeName", ",", "dtd", ",", "nodeIsNoStyle", ",", "nodeIsReadonly", ",", "includeReadonly", ")", "{", "// Style can be applied to text node.", "if", "(", "!", "nodeName", ")", "return", "1", ";", "// Style definitely cannot be applied if DTD or data-nostyle do not allow.", "if", "(", "!", "dtd", "[", "nodeName", "]", "||", "nodeIsNoStyle", ")", "return", "0", ";", "// Non-editable element cannot be styled is we shouldn't include readonly elements.", "if", "(", "nodeIsReadonly", "&&", "!", "includeReadonly", ")", "return", "0", ";", "// Check that we haven't passed lastNode yet and that style's childRule allows this style on current element.", "return", "checkPositionAndRule", "(", "currentNode", ",", "lastNode", ",", "def", ",", "posPrecedingIdenticalContained", ")", ";", "}" ]

[ "Checks", "if", "the", "current", "node", "can", "be", "a", "child", "of", "the", "style", "element", "." ]

[ "function", "checkIfStyleCanBeChildOf", "(", "def", ",", "currentParent", ",", "elementName", ",", "isUnknownElement", ")", "{", "return", "currentParent", "&&", "(", "(", "currentParent", ".", "getDtd", "(", ")", "||", "CKEDITOR", ".", "dtd", ".", "span", ")", "[", "elementName", "]", "||", "isUnknownElement", ")", "&&", "(", "!", "def", ".", "parentRule", "||", "def", ".", "parentRule", "(", "currentParent", ")", ")", ";", "}" ]

[ "Check", "if", "the", "style", "element", "can", "be", "a", "child", "of", "the", "current", "node", "parent", "or", "if", "the", "element", "is", "not", "defined", "in", "the", "DTD", "." ]

[ "function", "checkPositionAndRule", "(", "nodeA", ",", "nodeB", ",", "def", ",", "posBitFlags", ")", "{", "return", "(", "nodeA", ".", "getPosition", "(", "nodeB", ")", "|", "posBitFlags", ")", "==", "posBitFlags", "&&", "(", "!", "def", ".", "childRule", "||", "def", ".", "childRule", "(", "nodeA", ")", ")", ";", "}" ]

[ "Checks", "if", "position", "is", "a", "subset", "of", "posBitFlags", "and", "that", "nodeA", "fulfills", "style", "def", "rule", "." ]

[ "function", "applyStyleOnNestedEditables", "(", "editablesContainer", ")", "{", "var", "editables", "=", "findNestedEditables", "(", "editablesContainer", ")", ",", "editable", ",", "l", "=", "editables", ".", "length", ",", "i", "=", "0", ",", "range", "=", "l", "&&", "new", "CKEDITOR", ".", "dom", ".", "range", "(", "editablesContainer", ".", "getDocument", "(", ")", ")", ";", "for", "(", ";", "i", "<", "l", ";", "++", "i", ")", "{", "editable", "=", "editables", "[", "i", "]", ";", "// Check if style is allowed by this editable's ACF.", "if", "(", "checkIfAllowedInEditable", "(", "editable", ",", "this", ")", ")", "{", "range", ".", "selectNodeContents", "(", "editable", ")", ";", "applyInlineStyle", ".", "call", "(", "this", ",", "range", ")", ";", "}", "}", "}" ]

[ "Apply", "style", "to", "nested", "editables", "inside", "editablesContainer", "." ]

[ "function", "checkIfAllowedInEditable", "(", "editable", ",", "style", ")", "{", "var", "filter", "=", "CKEDITOR", ".", "filter", ".", "instances", "[", "editable", ".", "data", "(", "'cke-filter'", ")", "]", ";", "return", "filter", "?", "filter", ".", "check", "(", "style", ")", ":", "1", ";", "}" ]

[ "Checks", "if", "style", "is", "allowed", "in", "this", "editable", "." ]

[ "function", "toPre", "(", "block", ",", "newBlock", ")", "{", "var", "bogus", "=", "block", ".", "getBogus", "(", ")", ";", "bogus", "&&", "bogus", ".", "remove", "(", ")", ";", "// First trim the block content.", "var", "preHtml", "=", "block", ".", "getHtml", "(", ")", ";", "// 1. Trim head/tail spaces, they're not visible.", "preHtml", "=", "replace", "(", "preHtml", ",", "/", "(?:^[ \\t\\n\\r]+)|(?:[ \\t\\n\\r]+$)", "/", "g", ",", "''", ")", ";", "// 2. Delete ANSI whitespaces immediately before and after <BR> because", "// they are not visible.", "preHtml", "=", "preHtml", ".", "replace", "(", "/", "[ \\t\\r\\n]*(<br[^>]*>)[ \\t\\r\\n]*", "/", "gi", ",", "'$1'", ")", ";", "// 3. Compress other ANSI whitespaces since they're only visible as one", "// single space previously.", "// 4. Convert &nbsp; to spaces since &nbsp; is no longer needed in <PRE>.", "preHtml", "=", "preHtml", ".", "replace", "(", "/", "([ \\t\\n\\r]+|&nbsp;)", "/", "g", ",", "' '", ")", ";", "// 5. Convert any <BR /> to \\n. This must not be done earlier because", "// the \\n would then get compressed.", "preHtml", "=", "preHtml", ".", "replace", "(", "/", "<br\\b[^>]*>", "/", "gi", ",", "'\\n'", ")", ";", "// Krugle: IE normalizes innerHTML to <pre>, breaking whitespaces.", "if", "(", "CKEDITOR", ".", "env", ".", "ie", ")", "{", "var", "temp", "=", "block", ".", "getDocument", "(", ")", ".", "createElement", "(", "'div'", ")", ";", "temp", ".", "append", "(", "newBlock", ")", ";", "newBlock", ".", "$", ".", "outerHTML", "=", "'<pre>'", "+", "preHtml", "+", "'</pre>'", ";", "newBlock", ".", "copyAttributes", "(", "temp", ".", "getFirst", "(", ")", ")", ";", "newBlock", "=", "temp", ".", "getFirst", "(", ")", ".", "remove", "(", ")", ";", "}", "else", "{", "newBlock", ".", "setHtml", "(", "preHtml", ")", ";", "}", "return", "newBlock", ";", "}" ]

[ "Converting", "from", "a", "non", "-", "PRE", "block", "to", "a", "PRE", "block", "in", "formatting", "operations", "." ]

[ "function", "getAttributesForComparison", "(", "styleDefinition", ")", "{", "// If we have already computed it, just return it.", "var", "attribs", "=", "styleDefinition", ".", "_AC", ";", "if", "(", "attribs", ")", "return", "attribs", ";", "attribs", "=", "{", "}", ";", "var", "length", "=", "0", ";", "// Loop through all defined attributes.", "var", "styleAttribs", "=", "styleDefinition", ".", "attributes", ";", "if", "(", "styleAttribs", ")", "{", "for", "(", "var", "styleAtt", "in", "styleAttribs", ")", "{", "length", "++", ";", "attribs", "[", "styleAtt", "]", "=", "styleAttribs", "[", "styleAtt", "]", ";", "}", "}", "// Includes the style definitions.", "var", "styleText", "=", "CKEDITOR", ".", "style", ".", "getStyleText", "(", "styleDefinition", ")", ";", "if", "(", "styleText", ")", "{", "if", "(", "!", "attribs", ".", "style", ")", "length", "++", ";", "attribs", ".", "style", "=", "styleText", ";", "}", "// Appends the \"length\" information to the object.", "attribs", ".", "_length", "=", "length", ";", "// Return it, saving it to the next request.", "return", "(", "styleDefinition", ".", "_AC", "=", "attribs", ")", ";", "}" ]

[ "Returns", "an", "object", "that", "can", "be", "used", "for", "style", "matching", "comparison", ".", "Attributes", "names", "and", "values", "are", "all", "lowercased", "and", "the", "styles", "get", "merged", "with", "the", "style", "attribute", "." ]

[ "function", "(", "callback", ")", "{", "if", "(", "!", "this", ".", "_", ".", "stylesDefinitions", ")", "{", "var", "editor", "=", "this", ",", "// Respect the backwards compatible definition entry", "configStyleSet", "=", "editor", ".", "config", ".", "stylesCombo_stylesSet", "||", "editor", ".", "config", ".", "stylesSet", ";", "// The false value means that none styles should be loaded.", "if", "(", "configStyleSet", "===", "false", ")", "{", "callback", "(", "null", ")", ";", "return", ";", "}", "// #5352 Allow to define the styles directly in the config object", "if", "(", "configStyleSet", "instanceof", "Array", ")", "{", "editor", ".", "_", ".", "stylesDefinitions", "=", "configStyleSet", ";", "callback", "(", "configStyleSet", ")", ";", "return", ";", "}", "// Default value is 'default'.", "if", "(", "!", "configStyleSet", ")", "configStyleSet", "=", "'default'", ";", "var", "partsStylesSet", "=", "configStyleSet", ".", "split", "(", "':'", ")", ",", "styleSetName", "=", "partsStylesSet", "[", "0", "]", ",", "externalPath", "=", "partsStylesSet", "[", "1", "]", ";", "CKEDITOR", ".", "stylesSet", ".", "addExternal", "(", "styleSetName", ",", "externalPath", "?", "partsStylesSet", ".", "slice", "(", "1", ")", ".", "join", "(", "':'", ")", ":", "CKEDITOR", ".", "getUrl", "(", "'styles.js'", ")", ",", "''", ")", ";", "CKEDITOR", ".", "stylesSet", ".", "load", "(", "styleSetName", ",", "function", "(", "stylesSet", ")", "{", "editor", ".", "_", ".", "stylesDefinitions", "=", "stylesSet", "[", "styleSetName", "]", ";", "callback", "(", "editor", ".", "_", ".", "stylesDefinitions", ")", ";", "}", ")", ";", "}", "else", "{", "callback", "(", "this", ".", "_", ".", "stylesDefinitions", ")", ";", "}", "}" ]

[ "Gets", "the", "current", "stylesSet", "for", "this", "instance", "." ]

[ "function", "walk", "(", "directoryPath", ",", "filter", ",", "collector", ")", "{", "var", "defer", "=", "Q", ".", "defer", "(", ")", "fs", ".", "stat", "(", "directoryPath", ",", "function", "(", "err", ",", "stat", ")", "{", "if", "(", "err", ")", "{", "if", "(", "err", ".", "code", "===", "'ENOENT'", ")", "{", "// Like q-io/fs, return an empty array, if the directory does not exist", "return", "defer", ".", "resolve", "(", "[", "]", ")", "}", "return", "defer", ".", "reject", "(", "err", ")", "}", "// Call filter to get result, \"true\" if no filter is set", "var", "filterResult", "=", "!", "filter", "||", "filter", "(", "directoryPath", ",", "stat", ")", "if", "(", "filterResult", ")", "{", "collector", ".", "push", "(", "directoryPath", ")", "}", "// false/true => iterate directory", "if", "(", "stat", ".", "isDirectory", "(", ")", "&&", "filterResult", "!==", "null", ")", "{", "fs", ".", "readdir", "(", "directoryPath", ",", "function", "(", "err", ",", "filenames", ")", "{", "if", "(", "err", ")", "{", "return", "defer", ".", "reject", "(", "err", ")", "}", "var", "paths", "=", "filenames", ".", "map", "(", "function", "(", "name", ")", "{", "return", "path", ".", "join", "(", "directoryPath", ",", "name", ")", "}", ")", "// Walk all files/subdirs", "Q", ".", "all", "(", "paths", ".", "map", "(", "function", "(", "filepath", ")", "{", "return", "walk", "(", "filepath", ",", "filter", ",", "collector", ")", "}", ")", ")", ".", "then", "(", "function", "(", ")", "{", "defer", ".", "fulfill", "(", "collector", ")", "}", ")", "}", ")", "}", "else", "{", "// No recursive call with a file", "defer", ".", "fulfill", "(", "collector", ")", "}", "}", ")", "return", "defer", ".", "promise", "}" ]

[ "Walk", "a", "directory", "tree", "collect", "paths", "of", "files", "in", "an", "Array", "and", "return", "a", "Promise", "for", "the", "fulfilled", "action" ]

[ "function", "doesEscapeRoot", "(", "root", ",", "file", ")", "{", "if", "(", "file", ".", "indexOf", "(", "path", ".", "normalize", "(", "root", "+", "\"/\"", ")", ")", "===", "0", ")", "return", "just", "(", "file", ")", ";", "else", "return", "nothing", "(", ")", ";", "}" ]

[ "The", "computed", "path", "for", "the", "requested", "file", "should", "always", "have", "the", "root", "as", "the", "prefix", ".", "When", "it", "does", "not", "that", "means", "the", "computed", "request", "path", "is", "pointing", "outside", "of", "the", "root", "which", "could", "be", "malicious", "." ]

[ "function", "httpOk", "(", "response", ",", "isHead", ",", "body", ")", "{", "response", ".", "setHeader", "(", "HTTP_CONTENT_TYPE", ",", "MIME_TYPE_JAVASCRIPT", ")", ";", "response", ".", "setHeader", "(", "HTTP_CONTENT_LENGTH", ",", "body", ".", "length", ")", ";", "response", ".", "statusCode", "=", "HTTP_OK", ";", "if", "(", "isHead", ")", "response", ".", "end", "(", ")", ";", "else", "response", ".", "end", "(", "body", ")", ";", "}" ]

[ "Helper", "method", "to", "response", "with", "an", "HTTP", "ok", "with", "a", "body", "when", "the", "isHead", "is", "true", "then", "no", "body", "is", "returned" ]

[ "function", "closeConnection", "(", "options", ")", "{", "//no options, close/delete all connection references", "if", "(", "!", "options", ")", "{", "try", "{", "mssql", ".", "close", "(", ")", ";", "}", "catch", "(", "err", ")", "{", "}", "//create list to track items to close", "let", "closeList", "=", "[", "]", ";", "//iterate through each connection", "for", "(", "let", "key", "in", "promises", ")", "{", "//if there's a close method (connection match), add it to the list", "if", "(", "promises", "[", "key", "]", "&&", "typeof", "promises", "[", "key", "]", ".", "close", "===", "'function'", ")", "closeList", ".", "push", "(", "promises", "[", "key", "]", ")", ";", "}", "//iterate through list and close each connection", "closeList", ".", "forEach", "(", "(", "item", ")", "=>", "item", ".", "close", "(", ")", ")", ";", "}", "//either a connection promise, or a connection", "if", "(", "options", ".", "_mssqlngKey", "&&", "typeof", "options", ".", "close", "===", "'function'", ")", "return", "options", ".", "close", "(", ")", ";", "//match against connection options", "let", "key", "=", "stringify", "(", "options", "||", "{", "}", ")", ";", "if", "(", "connections", "[", "key", "]", ")", "connections", "[", "key", "]", ".", "close", "(", ")", ";", "if", "(", "promises", "[", "key", "]", ")", "promises", "[", "key", "]", ".", "then", "(", "(", "conn", ")", "=>", "conn", ".", "close", "(", ")", ")", ".", "catch", "(", "(", ")", "=>", "{", "delete", "promises", "[", "key", "]", ";", "delete", "connections", "[", "key", "]", "}", ")", ";", "}" ]

[ "close", "a", "specific", "connection", "if", "no", "options", "specified", "deletes", "all", "connections" ]

[ "function", "(", "_data", ",", "cb", ")", "{", "if", "(", "!", "db", ".", "data", ")", "return", "cb", "(", "new", "Error", "(", "'kiddb not open'", ")", ")", "if", "(", "!", "writing", ")", "return", "db", ".", "_update", "(", "_data", ",", "cb", ")", "db", ".", "__data", "=", "_data", "qcb", ".", "push", "(", "cb", ")", "onWrote", "=", "function", "(", ")", "{", "onWrote", "=", "null", "var", "cbs", "=", "qcb", ";", "qcb", "=", "[", "]", "var", "_data", "=", "db", ".", "__data", "db", ".", "__data", "=", "null", "db", ".", "update", "(", "_data", ",", "function", "(", "err", ")", "{", "cbs", ".", "forEach", "(", "function", "(", "cb", ")", "{", "cb", "(", "err", ")", "}", ")", "}", ")", "}", "}" ]

[ "instead", "of", "doing", "a", "concurrent", "write", "queue", "the", "new", "writes", ".", "these", "can", "probably", "be", "merged", "together", "and", "then", "a", "bunch", "will", "succeed", "at", "once", ".", "if", "you", "contrived", "your", "benchmark", "the", "right", "way", "this", "could", "look", "like", "really", "great", "performance!" ]

[ "function", "(", "key", ",", "cb", ")", "{", "if", "(", "!", "db", ".", "data", ")", "return", "cb", "(", "new", "Error", "(", "'kiddb not open'", ")", ")", "if", "(", "db", ".", "data", "[", "key", "]", ")", "cb", "(", "null", ",", "db", ".", "data", "[", "key", "]", ")", "else", "cb", "(", "new", "Error", "(", "'not found'", ")", ")", "}" ]

[ "following", "is", "a", "bunch", "of", "stuff", "to", "make", "give", "the", "leveldown", "api", "..." ]

[ "function", "downloadArchive", "(", "id", ",", "call", ",", "options", ",", "done", ")", "{", "grunt", ".", "log", ".", "write", "(", "'Downloading '", ".", "gray", "+", "id", ".", "yellow", "+", "' ... '", ".", "gray", ")", ";", "request", "(", "call", ",", "function", "(", "err", ",", "response", ",", "body", ")", "{", "if", "(", "err", ")", "return", "done", "(", "err", ")", ";", "var", "result", "=", "JSON", ".", "parse", "(", "body", ")", ";", "if", "(", "!", "result", ".", "success", ")", "{", "return", "done", "(", "result", ".", "error", "+", "' with game \"'", "+", "id", "+", "'\"'", ")", ";", "}", "if", "(", "options", ".", "json", ")", "{", "grunt", ".", "log", ".", "write", "(", "'Writing json ... '", ".", "gray", ")", ";", "var", "writeStream", "=", "fs", ".", "createWriteStream", "(", "path", ".", "join", "(", "options", ".", "dest", ",", "id", "+", "'.json'", ")", ")", ";", "writeStream", ".", "write", "(", "JSON", ".", "stringify", "(", "result", ".", "data", ",", "null", ",", "options", ".", "debug", "?", "\"\\t\"", ":", "\"\"", ")", ")", ";", "writeStream", ".", "end", "(", ")", ";", "}", "grunt", ".", "log", ".", "write", "(", "'Installing ... '", ".", "gray", ")", ";", "this", ".", "get", "(", "result", ".", "data", ".", "url", ")", ".", "run", "(", "function", "(", "err", ",", "files", ")", "{", "if", "(", "err", ")", "{", "return", "done", "(", "'Unable to download archive for game \"'", "+", "id", "+", "'\"'", ")", ";", "}", "grunt", ".", "log", ".", "writeln", "(", "'Done.'", ".", "green", ")", ";", "done", "(", "null", ",", "files", ")", ";", "}", ")", ";", "}", ".", "bind", "(", "this", ")", ")", ";", "}" ]

[ "Handle", "the", "request" ]

[ "function", "(", "dest", ",", "src", ")", "{", "if", "(", "src", ".", "indexOf", "(", "'.js'", ")", ">", "-", "1", ")", "{", "return", "dest", "+", "src", ".", "replace", "(", "'.js'", ",", "'.'", "+", "tsPrefix", "+", "newTS", "+", "'.js'", ")", ";", "}", "else", "{", "return", "dest", "+", "src", ".", "replace", "(", "'.css'", ",", "'.'", "+", "tsPrefix", "+", "newTS", "+", "'.css'", ")", ";", "}", "}" ]

[ "Add", "rename", "function", "to", "copy", "task", "config" ]

[ "function", "isEscapeingAt", "(", "string", ",", "index", ")", "{", "if", "(", "index", "===", "0", ")", "{", "return", "false", ";", "}", "let", "i", "=", "index", "-", "1", ";", "while", "(", "i", ">=", "0", "&&", "string", "[", "i", "]", "===", "'\\\\'", ")", "{", "--", "i", ";", "}", "return", "(", "index", "-", "i", ")", "%", "2", "===", "0", ";", "}" ]

[ "checks", "whether", "the", "string", "is", "escaping", "the", "char", "at", "index" ]

[ "function", "parse", "(", "defaultValue", ",", "data", ")", "{", "try", "{", "return", "JSON", ".", "parse", "(", "data", ")", "}", "catch", "(", "error", ")", "{", "if", "(", "defaultValue", "===", "null", "||", "defaultValue", "===", "undefined", ")", "{", "throw", "error", "}", "else", "{", "return", "defaultValue", "}", "}", "}" ]

[ "Curried", "function", "that", "calls", "JSON", ".", "parse", "on", "provided", "input", "returning", "either", "the", "parsed", "JSON", "or", "the", "specified", "default", "value", "if", "the", "data", "fails", "to", "parse", "as", "valid", "JSON", "instead", "of", "throwing", "a", "SyntaxError", "." ]

[ "function", "load", "(", "fromPath", ",", "relativePaths", ",", "opts", ")", "{", "opts", "=", "opts", "||", "{", "}", ";", "var", "ignores", "=", "opts", ".", "ignores", "||", "[", "]", ";", "if", "(", "typeof", "ignores", "===", "'string'", ")", "ignores", "=", "[", "ignores", "]", ";", "var", "conf", "=", "{", "}", ";", "relativePaths", ".", "forEach", "(", "function", "(", "relativePath", ")", "{", "var", "path", "=", "Path", ".", "resolve", "(", "fromPath", ",", "relativePath", ")", ";", "var", "config", "=", "loadFile", "(", "path", ",", "ignores", ")", ";", "extend", "(", "conf", ",", "config", ")", ";", "}", ")", ";", "if", "(", "conf", ".", "get", "===", "undefined", ")", "{", "bindGetMethod", "(", "conf", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "'`get` property cannot be the root key of config'", ")", ";", "}", "return", "conf", ";", "}" ]

[ "Load", "your", "config", "files", "." ]

[ "function", "create", "(", ")", "{", "var", "args", "=", "Array", ".", "prototype", ".", "slice", ".", "call", "(", "arguments", ")", ";", "var", "conf", "=", "{", "}", ";", "args", ".", "forEach", "(", "function", "(", "config", ")", "{", "extend", "(", "conf", ",", "config", ")", ";", "}", ")", ";", "if", "(", "conf", ".", "get", "===", "undefined", ")", "{", "bindGetMethod", "(", "conf", ")", ";", "}", "else", "{", "throw", "new", "Error", "(", "'`get` property cannot be the root key of config'", ")", ";", "}", "return", "conf", ";", "}" ]

[ "create", "a", "config", "with", "multi", "objects", "." ]

[ "function", "SettingsFile", "(", "app", ",", "options", ")", "{", "if", "(", "!", "app", ")", "{", "throw", "new", "TypeError", "(", "'SettingsFile must accept an app name'", ")", ";", "}", "else", "if", "(", "typeof", "app", "!==", "'string'", ")", "{", "throw", "new", "TypeError", "(", "'SettingsFile app name must be a string'", ")", ";", "}", "debug", "(", "'initialize new settings file for app: %s'", ",", "app", ")", ";", "this", ".", "_app", "=", "app", ";", "this", ".", "_path", "=", "nachosHome", "(", "'data'", ",", "app", "+", "'.json'", ")", ";", "debug", "(", "'resolved path is %s'", ",", "this", ".", "_path", ")", ";", "this", ".", "_options", "=", "defaults", "(", "options", ",", "{", "globalDefaults", ":", "{", "}", ",", "instanceDefaults", ":", "{", "}", "}", ")", ";", "}" ]

[ "Nachos", "settings", "file" ]

[ "function", "(", "content", ")", "{", "var", "fileContent", "=", "self", ".", "_readFileSync", "(", ")", ";", "fileContent", ".", "instances", "=", "fileContent", ".", "instances", "||", "{", "}", ";", "fileContent", ".", "instances", "[", "this", ".", "_id", "]", "=", "content", ";", "self", ".", "_writeFileSync", "(", "fileContent", ")", ";", "}" ]

[ "Save", "the", "instance", "settings" ]

[ "function", "(", "id", ",", "params", ")", "{", "return", "req", ".", "standardRequest", "(", "`", "${", "config", ".", "host", "}", "${", "id", "}", "${", "req", ".", "assembleQueryParams", "(", "params", ",", "[", "'page'", "]", ")", "}", "`", ")", ";", "}" ]

[ "List", "child", "teams" ]

[ "function", "(", "id", ",", "projectId", ",", "body", ")", "{", "return", "req", ".", "standardRequest", "(", "`", "${", "config", ".", "host", "}", "${", "id", "}", "${", "projectId", "}", "`", ",", "'put'", ",", "body", ")", ";", "}" ]

[ "Add", "or", "update", "team", "project" ]

[ "function", "createStream", "(", "options", ")", "{", "options", "=", "options", "||", "{", "}", "var", "stream", "=", "through2", ".", "obj", "(", "function", "transform", "(", "chunk", ",", "encoding", ",", "cb", ")", "{", "stream", ".", "push", "(", "options", ".", "objectMode", "?", "chunk", ":", "JSON", ".", "stringify", "(", "chunk", ")", "+", "'\\n'", ")", "cb", "(", ")", "}", ")", "stream", ".", "close", "=", "function", "close", "(", ")", "{", "setImmediate", "(", "function", "(", ")", "{", "stream", ".", "push", "(", "null", ")", "changes", ".", "unpipe", "(", "stream", ")", "}", ")", "numStreams", "--", "}", "changes", ".", "pipe", "(", "stream", ")", "numStreams", "++", "return", "stream", "}" ]

[ "create", "stream", "of", "changes" ]

[ "function", "feed", "(", "op", ",", "pnode", ")", "{", "if", "(", "numStreams", ">", "0", ")", "{", "changes", ".", "push", "(", "{", "op", ":", "op", ",", "pnode", ":", "pnode", ".", "toJSON", "(", ")", "}", ")", "}", "}" ]

[ "feed", "change", "streams" ]

[ "function", "setPnodeData", "(", "pnode", ",", "value", ")", "{", "if", "(", "!", "pnode", ".", "exists", ")", "{", "pnode", ".", "_data", "=", "value", "persistPnode", "(", "pnode", ")", "}", "else", "if", "(", "pnode", ".", "_data", "!==", "value", ")", "{", "pnode", ".", "_data", "=", "value", "incTransaction", "(", ")", "incPnodeVersion", "(", "pnode", ")", "feed", "(", "'change'", ",", "pnode", ")", "}", "return", "pnode", "}" ]

[ "set", "pnode", "data" ]

[ "function", "unsetPnodeData", "(", "pnode", ")", "{", "if", "(", "pnode", ".", "hasOwnProperty", "(", "'_data'", ")", "&&", "pnode", ".", "_data", "!==", "undefined", ")", "{", "pnode", ".", "_data", "=", "undefined", "incTransaction", "(", ")", "incPnodeVersion", "(", "pnode", ")", "feed", "(", "'change'", ",", "pnode", ")", "}", "return", "pnode", "}" ]

[ "unset", "pnode", "data" ]

[ "function", "incPnodeVersion", "(", "pnode", ")", "{", "pnode", ".", "_version", "=", "pnode", ".", "_version", "?", "pnode", ".", "_version", "+", "1", ":", "1", "pnode", ".", "_mtxid", "=", "ptree", ".", "txid", "pnode", ".", "_mtime", "=", "new", "Date", "if", "(", "!", "pnode", ".", "_ctxid", ")", "pnode", ".", "_ctxid", "=", "pnode", ".", "_mtxid", "if", "(", "!", "pnode", ".", "_ctime", ")", "pnode", ".", "_ctime", "=", "pnode", ".", "_mtime", "return", "pnode", "}" ]

[ "increment", "pnode", "version" ]

[ "function", "incChildrenVersion", "(", "pnode", ")", "{", "if", "(", "pnode", "&&", "pnode", ".", "_childrenVersion", ")", "pnode", ".", "_childrenVersion", "++", "else", "pnode", ".", "_childrenVersion", "=", "1", "return", "pnode", "}" ]

[ "incrememnt", "childrenVersion", "of", "pnode" ]

[ "function", "addChild", "(", "parent", ",", "child", ")", "{", "parent", ".", "_children", ".", "push", "(", "child", ")", "incChildrenVersion", "(", "parent", ")", "return", "parent", "}" ]

[ "add", "child", "to", "pnode" ]

[ "function", "removeChild", "(", "parent", ",", "child", ")", "{", "var", "parentChildIdx", "=", "parent", ".", "_children", ".", "indexOf", "(", "child", ")", "parent", ".", "_children", ".", "splice", "(", "parentChildIdx", ",", "1", ")", "incChildrenVersion", "(", "parent", ")", "return", "parent", "}" ]

[ "remove", "child", "from", "pnode" ]

[ "function", "pnodeParents", "(", "pnode", ")", "{", "if", "(", "!", "pnode", ".", "valid", ")", "return", "undefined", "var", "parentPaths", "=", "parents", "(", "pnode", ".", "path", ")", ",", "list", "=", "[", "]", "for", "(", "var", "i", "=", "0", ";", "i", "<", "parentPaths", ".", "length", ";", "i", "++", ")", "list", ".", "push", "(", "ptree", "(", "parentPaths", "[", "i", "]", ")", ")", "return", "list", "}" ]

[ "get", "all", "parents", "of", "a", "pnoce" ]

[ "function", "pnodeParent", "(", "pnode", ")", "{", "if", "(", "!", "pnode", ".", "valid", ")", "return", "undefined", "var", "parentPath", "=", "parents", ".", "immediate", "(", "pnode", ".", "path", ")", "return", "parentPath", "?", "ptree", "(", "parentPath", ")", ":", "null", "}" ]

[ "get", "immediate", "parent", "of", "pnode" ]

[ "function", "parameters", "(", "spec", ")", "{", "var", "defs", "=", "{", "}", "var", "envs", "=", "{", "}", "return", "function", "(", "params", ")", "{", "init", "(", "spec", ",", "defs", ",", "envs", ")", "var", "opts", "=", "cat", "(", "defs", ",", "envs", ",", "params", ")", "var", "errs", "=", "[", "]", "def", "(", "opts", ",", "spec", ",", "errs", ")", "req", "(", "opts", ",", "spec", ",", "errs", ")", "val", "(", "opts", ",", "spec", ",", "errs", ")", "return", "{", "error", ":", "errs", ".", "length", "?", "errs", "[", "0", "]", ":", "null", ",", "errors", ":", "errs", ",", "params", ":", "opts", "}", "}", "}" ]

[ "Named", "parameters", "supporting", "default", "value", "validation", "and", "environment", "variables", "." ]

[ "function", "init", "(", "spec", ",", "defs", ",", "envs", ")", "{", "for", "(", "var", "key", "in", "spec", "||", "{", "}", ")", "{", "if", "(", "spec", "[", "key", "]", ".", "def", ")", "defs", "[", "key", "]", "=", "spec", "[", "key", "]", ".", "def", "if", "(", "has", "(", "spec", "[", "key", "]", ".", "env", ")", ")", "envs", "[", "key", "]", "=", "get", "(", "spec", "[", "key", "]", ".", "env", ")", "}", "}" ]

[ "Initialize", "defaults", "and", "environment", "variables", "." ]

[ "function", "def", "(", "params", ",", "spec", ",", "errs", ")", "{", "for", "(", "var", "key", "in", "params", ")", "{", "if", "(", "!", "spec", ".", "hasOwnProperty", "(", "key", ")", ")", "defError", "(", "key", ",", "errs", ")", "}", "}" ]

[ "Ensure", "that", "parameter", "is", "defined", "." ]

[ "function", "req", "(", "params", ",", "spec", ",", "errs", ")", "{", "for", "(", "var", "key", "in", "spec", ")", "{", "if", "(", "spec", "[", "key", "]", ".", "req", "&&", "!", "params", ".", "hasOwnProperty", "(", "key", ")", ")", "reqError", "(", "key", ",", "errs", ")", "}", "}" ]

[ "Ensure", "that", "required", "keys", "are", "set", "." ]

[ "function", "val", "(", "params", ",", "spec", ",", "errs", ")", "{", "for", "(", "var", "key", "in", "params", ")", "{", "if", "(", "key", "in", "spec", "&&", "isFunction", "(", "spec", "[", "key", "]", ".", "val", ")", "&&", "!", "spec", "[", "key", "]", ".", "val", "(", "params", "[", "key", "]", ")", ")", "valError", "(", "key", ",", "errs", ")", "}", "}" ]

[ "Ensure", "that", "validation", "predicates", "pass", "." ]

[ "function", "header", "(", "length", ")", "{", "var", "res", "=", "[", "0x09", ",", "0x09", ",", "0x00", ",", "0x00", "]", ";", "res", ".", "push", "(", "(", "length", "&", "0x000000FF", ")", ">>", "0", ")", ";", "res", ".", "push", "(", "(", "length", "&", "0x0000FF00", ")", ">>", "8", ")", ";", "res", ".", "push", "(", "(", "length", "&", "0x00FF0000", ")", ">>", "16", ")", ";", "res", ".", "push", "(", "(", "length", "&", "0xFF000000", ")", ">>", "24", ")", ";", "return", "new", "Buffer", "(", "res", ")", ";", "}" ]

[ "Creates", "header", "for", "clusterpoint", "messages" ]